diff --git a/.github/ISSUE_TEMPLATE/BUG.yml b/.github/ISSUE_TEMPLATE/BUG.yml
index 8af5a0b..f71b668 100644
--- a/.github/ISSUE_TEMPLATE/BUG.yml
+++ b/.github/ISSUE_TEMPLATE/BUG.yml
@@ -21,7 +21,7 @@ body:
id: version
attributes:
label: Version
- description: What version of the Discord Game SDK Godot plugin are you running?
+ description: What version of the Discord RPC Godot plugin are you running?
options:
- 1.2.0
- 1.1.0
@@ -94,5 +94,5 @@ body:
required: true
- label: I tried restarting Discord and Godot completely.
required: true
- - label: I did read the documentation https://vaporvee.com/docs/discord-sdk-godot/
+ - label: I did read the documentation https://vaporvee.com/docs/discord-rpc-godot/
required: true
diff --git a/.gitignore b/.gitignore
index a2efecc..ad38f6c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,7 +22,7 @@ build/
*.a
#Clean files from setup.py
-src/lib/discord_game_sdk/
+src/lib/discord_rpc/
# release
release/
diff --git a/README.md b/README.md
index 6a7f40e..6623c8e 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/project/assets/Banner_v1.png b/project/assets/Banner_v1.png
deleted file mode 100644
index e8ba85e..0000000
Binary files a/project/assets/Banner_v1.png and /dev/null differ
diff --git a/project/assets/discordgodot_banner.png b/project/assets/discordgodot_banner.png
new file mode 100644
index 0000000..1c491a0
Binary files /dev/null and b/project/assets/discordgodot_banner.png differ
diff --git a/project/assets/Banner.svg.import b/project/assets/discordgodot_banner.png.import
similarity index 62%
rename from project/assets/Banner.svg.import
rename to project/assets/discordgodot_banner.png.import
index c1f8d15..fc863ce 100644
--- a/project/assets/Banner.svg.import
+++ b/project/assets/discordgodot_banner.png.import
@@ -2,16 +2,16 @@
importer="texture"
type="CompressedTexture2D"
-uid="uid://c0i5gy8pvdnwt"
-path="res://.godot/imported/Banner.svg-5bd63979daa8dcc3afce0089ffa91a12.ctex"
+uid="uid://c7h7lup1lw58j"
+path="res://.godot/imported/discordgodot_banner.png-eb84eabd38610228ef9dc43dbd0407a1.ctex"
metadata={
"vram_texture": false
}
[deps]
-source_file="res://assets/Banner.svg"
-dest_files=["res://.godot/imported/Banner.svg-5bd63979daa8dcc3afce0089ffa91a12.ctex"]
+source_file="res://assets/discordgodot_banner.png"
+dest_files=["res://.godot/imported/discordgodot_banner.png-eb84eabd38610228ef9dc43dbd0407a1.ctex"]
[params]
@@ -32,6 +32,3 @@ process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
diff --git a/project/assets/discordgodot_cover.png b/project/assets/discordgodot_cover.png
new file mode 100644
index 0000000..8551b9b
Binary files /dev/null and b/project/assets/discordgodot_cover.png differ
diff --git a/project/assets/Banner_v1.png.import b/project/assets/discordgodot_cover.png.import
similarity index 66%
rename from project/assets/Banner_v1.png.import
rename to project/assets/discordgodot_cover.png.import
index 9f480aa..a6decf6 100644
--- a/project/assets/Banner_v1.png.import
+++ b/project/assets/discordgodot_cover.png.import
@@ -2,16 +2,16 @@
importer="texture"
type="CompressedTexture2D"
-uid="uid://bwdma28ey44h0"
-path="res://.godot/imported/Banner_v1.png-5ed14d0906a04274d823c02cd90d1aad.ctex"
+uid="uid://dumc28wi63nnc"
+path="res://.godot/imported/discordgodot_cover.png-5ee32fcd652e9995745e14429baed069.ctex"
metadata={
"vram_texture": false
}
[deps]
-source_file="res://assets/Banner_v1.png"
-dest_files=["res://.godot/imported/Banner_v1.png-5ed14d0906a04274d823c02cd90d1aad.ctex"]
+source_file="res://assets/discordgodot_cover.png"
+dest_files=["res://.godot/imported/discordgodot_cover.png-5ee32fcd652e9995745e14429baed069.ctex"]
[params]
diff --git a/project/export_presets.cfg b/project/export_presets.cfg
index 0bf7554..6ca76b3 100644
--- a/project/export_presets.cfg
+++ b/project/export_presets.cfg
@@ -8,7 +8,7 @@ custom_features=""
export_filter="all_resources"
include_filter=""
exclude_filter=""
-export_path="export/windows/discord-sdk-godot-demo.exe"
+export_path="export/windows/discord-rpc-godot-demo.exe"
encryption_include_filters=""
encryption_exclude_filters=""
encrypt_pck=false
@@ -39,7 +39,7 @@ application/file_version=""
application/product_version=""
application/company_name=""
application/product_name=""
-application/file_description="Discord SDK Godot Test"
+application/file_description="Discord RPC Godot Test"
application/copyright=""
application/trademarks=""
application/export_angle=0
@@ -71,7 +71,7 @@ custom_features=""
export_filter="all_resources"
include_filter=""
exclude_filter=""
-export_path="export/linux/discord-sdk-godot-demo.x86_64"
+export_path="export/linux/discord-rpc-godot-demo.x86_64"
encryption_include_filters=""
encryption_exclude_filters=""
encrypt_pck=false
@@ -111,7 +111,7 @@ custom_features=""
export_filter="all_resources"
include_filter=""
exclude_filter=""
-export_path="export/macos/discord-sdk-godot-demo.zip"
+export_path="export/macos/discord-rpc-godot-demo.zip"
encryption_include_filters=""
encryption_exclude_filters=""
encrypt_pck=false
@@ -126,7 +126,7 @@ custom_template/release=""
debug/export_console_wrapper=1
application/icon=""
application/icon_interpolation=4
-application/bundle_identifier="com.vaporvee.discord-sdk-godot-demo"
+application/bundle_identifier="com.vaporvee.discord-rpc-godot-demo"
application/signature=""
application/app_category="Games"
application/short_version=""
diff --git a/project/main.gd b/project/main.gd
index cab40d6..68a649f 100644
--- a/project/main.gd
+++ b/project/main.gd
@@ -2,40 +2,40 @@ extends Node
func _ready() -> void:
set_activity()
- DiscordSDK.connect("activity_join_request",_on_activity_join_request)
- DiscordSDK.connect("activity_join",_on_activity_join)
- DiscordSDK.connect("activity_spectate",_on_activity_spectate)
- DiscordSDK.connect("relationships_init",_on_relationship_init)
- DiscordSDK.connect("updated_relationship", _on_updated_relationship)
+ DiscordRPC.connect("activity_join_request",_on_activity_join_request)
+ DiscordRPC.connect("activity_join",_on_activity_join)
+ DiscordRPC.connect("activity_spectate",_on_activity_spectate)
+ DiscordRPC.connect("relationships_init",_on_relationship_init)
+ DiscordRPC.connect("updated_relationship", _on_updated_relationship)
func set_activity() -> void:
- DiscordSDK.clear(false)
- DiscordSDK.app_id = 1099618430065324082
- DiscordSDK.details = "A demo activity by vaporvee#1231"
- DiscordSDK.state = "Checkpoint 23/23"
+ DiscordRPC.clear(false)
+ DiscordRPC.app_id = 1099618430065324082
+ DiscordRPC.details = "A demo activity by vaporvee#1231"
+ DiscordRPC.state = "Checkpoint 23/23"
- DiscordSDK.large_image = "example_game"
- DiscordSDK.large_image_text = "Try it now!"
- DiscordSDK.small_image = "boss"
- DiscordSDK.small_image_text = "Fighting the end boss! D:"
- DiscordSDK.end_timestamp = int(Time.get_unix_time_from_system()) + 3600 # +1 hour in unix time
+ DiscordRPC.large_image = "example_game"
+ DiscordRPC.large_image_text = "Try it now!"
+ DiscordRPC.small_image = "boss"
+ DiscordRPC.small_image_text = "Fighting the end boss! D:"
+ DiscordRPC.end_timestamp = int(Time.get_unix_time_from_system()) + 3600 # +1 hour in unix time
# It is NOT recommended to manage secrets locally! It's meant to be a payload wich the server understands and
# returns the other variables like current_party_size, party_id etc. Most of the values must differ from the others.
var my_secret: String = str(randi_range(0,999999))
- DiscordSDK.party_id = "mylobbycanbeeverything_" + my_secret
- DiscordSDK.current_party_size = 1
- DiscordSDK.max_party_size = 4
- DiscordSDK.match_secret = "m_" + my_secret #better use seeds with 1 to 1 range instead of just chars
- DiscordSDK.join_secret = "j_" + my_secret
- DiscordSDK.spectate_secret = "s_" + my_secret
- DiscordSDK.is_public_party = true
- DiscordSDK.instanced = true #required for spectate
- #DiscordSDK.start_timestamp = int(Time.get_unix_time_from_system())
- DiscordSDK.register_command("C:\\Users\\yanni\\Desktop\\demo\\DiscordSDK.exe")
- #DiscordSDK.register_steam(1389990)
- DiscordSDK.refresh()
+ DiscordRPC.party_id = "mylobbycanbeeverything_" + my_secret
+ DiscordRPC.current_party_size = 1
+ DiscordRPC.max_party_size = 4
+ DiscordRPC.match_secret = "m_" + my_secret #better use seeds with 1 to 1 range instead of just chars
+ DiscordRPC.join_secret = "j_" + my_secret
+ DiscordRPC.spectate_secret = "s_" + my_secret
+ DiscordRPC.is_public_party = true
+ DiscordRPC.instanced = true #required for spectate
+ #DiscordRPC.start_timestamp = int(Time.get_unix_time_from_system())
+ DiscordRPC.register_command("C:\\Users\\yanni\\Desktop\\demo\\DiscordRPC.exe")
+ #DiscordRPC.register_steam(1389990)
+ DiscordRPC.refresh()
var user_request: Dictionary;
@@ -44,13 +44,13 @@ func _on_activity_join_request(user_requesting) -> void:
user_request = user_requesting
func _on_activity_join(secret) -> void:
- if(DiscordSDK.join_secret != secret):
- DiscordSDK.current_party_size = clamp(int(secret) + 1, 0, DiscordSDK.max_party_size)
- DiscordSDK.party_id = secret.replace("j_","mylobbycanbeeverything_")
- DiscordSDK.match_secret = secret.replace("j_","m_")
- DiscordSDK.join_secret = secret
- DiscordSDK.spectate_secret = secret.replace("j_","s_")
- DiscordSDK.refresh()
+ if(DiscordRPC.join_secret != secret):
+ DiscordRPC.current_party_size = clamp(int(secret) + 1, 0, DiscordRPC.max_party_size)
+ DiscordRPC.party_id = secret.replace("j_","mylobbycanbeeverything_")
+ DiscordRPC.match_secret = secret.replace("j_","m_")
+ DiscordRPC.join_secret = secret
+ DiscordRPC.spectate_secret = secret.replace("j_","s_")
+ DiscordRPC.refresh()
func _on_activity_spectate(secret) -> void:
print(secret)
diff --git a/project/main.tscn b/project/main.tscn
index 662b902..fb1cfb8 100644
--- a/project/main.tscn
+++ b/project/main.tscn
@@ -2,7 +2,7 @@
[ext_resource type="Script" path="res://main.gd" id="1_kl8ri"]
[ext_resource type="Texture2D" uid="uid://b3qm246m7pnsx" path="res://assets/Logo_V2.png" id="2_gd222"]
-[ext_resource type="Script" path="res://addons/discord-sdk-gd/nodes/debug.gd" id="6_ujijw"]
+[ext_resource type="Script" path="res://addons/discord-rpc-gd/nodes/debug.gd" id="6_ujijw"]
[node name="Node" type="Node"]
script = ExtResource("1_kl8ri")
@@ -23,7 +23,7 @@ position = Vector2(789, 330.5)
scale = Vector2(0.408203, 0.408203)
texture = ExtResource("2_gd222")
-[node name="DiscordSDK Test" type="RichTextLabel" parent="."]
+[node name="DiscordRPC Test" type="RichTextLabel" parent="."]
anchors_preset = -1
anchor_left = 0.293
anchor_top = 0.59
@@ -38,7 +38,7 @@ grow_vertical = 2
size_flags_horizontal = 4
size_flags_vertical = 4
bbcode_enabled = true
-text = "[center][font s=60]DiscordSDK Test"
+text = "[center][font s=60]DiscordRPC Test"
-[node name="DiscordSDKDebug" type="Node" parent="."]
+[node name="DiscordRPCDebug" type="Node" parent="."]
script = ExtResource("6_ujijw")
diff --git a/project/project.godot b/project/project.godot
index 9649c03..05a1491 100644
--- a/project/project.godot
+++ b/project/project.godot
@@ -10,18 +10,18 @@ config_version=5
[application]
-config/name="GDExtension DiscordSDK Test Project"
+config/name="GDExtension DiscordRPC Test Project"
config/tags=PackedStringArray("vaporvee")
run/main_scene="res://main.tscn"
config/features=PackedStringArray("4.2")
boot_splash/bg_color=Color(0.25098, 0.305882, 0.929412, 1)
-boot_splash/image="res://assets/Banner_v1.png"
+boot_splash/image="res://assets/discordgodot_cover.png"
boot_splash/fullsize=false
config/icon="res://assets/Logo_V2.png"
[autoload]
-DiscordSDKLoader="*res://addons/discord-sdk-gd/nodes/discord_autoload.gd"
+DiscordRPCLoader="*res://addons/discord-rpc-gd/nodes/discord_autoload.gd"
[display]
@@ -33,7 +33,7 @@ project/assembly_name="GDExtension Test Project"
[editor_plugins]
-enabled=PackedStringArray("res://addons/discord-sdk-gd/plugin.cfg")
+enabled=PackedStringArray("res://addons/discord-rpc-gd/plugin.cfg")
[filesystem]
diff --git a/release.py b/release.py
index 2855525..b03bc50 100644
--- a/release.py
+++ b/release.py
@@ -2,21 +2,21 @@ import os
import shutil
from distutils.dir_util import copy_tree
-win_folder_path = "project/addons/discord-sdk-gd/bin/windows"
+win_folder_path = "project/addons/discord-rpc-gd/bin/windows"
matching_files = [file for file in os.listdir(win_folder_path) if file.endswith(("TMP", "exp", "lib"))]
for file in matching_files:
file_path = os.path.join(win_folder_path, file)
os.remove(file_path)
-if os.path.exists("release/ADDON-Discord-SDK-Godot/addons"):
- shutil.rmtree("release/ADDON-Discord-SDK-Godot/addons", ignore_errors=True)
+if os.path.exists("release/ADDON-Discord-RPC-Godot/addons"):
+ shutil.rmtree("release/ADDON-Discord-RPC-Godot/addons", ignore_errors=True)
-copy_tree("project/addons/", "release/temp/ADDON-Discord-SDK-Godot/addons")
+copy_tree("project/addons/", "release/temp/ADDON-Discord-RPC-Godot/addons")
-open("release/temp/ADDON-Discord-SDK-Godot/addons/discord-sdk-gd/bin/.gdignore", "a").close()
+open("release/temp/ADDON-Discord-RPC-Godot/addons/discord-RPC-gd/bin/.gdignore", "a").close()
-shutil.make_archive('release/ADDON-Discord-SDK-Godot', 'zip', 'release/temp/')
+shutil.make_archive('release/ADDON-Discord-RPC-Godot', 'zip', 'release/temp/')
shutil.rmtree("release/temp/")
# Export Demos
@@ -34,4 +34,4 @@ shutil.make_archive('release/Demo-Export', 'zip', temp_dir)
shutil.rmtree(temp_dir)
-print("ADDON-Discord-SDK-Godot.zip and Demo-Export.zip have been created successfully.")
+print("ADDON-Discord-RPC-Godot.zip and Demo-Export.zip have been created successfully.")
diff --git a/src/discordgodot.cpp b/src/discordgodot.cpp
index 7cfc042..c229499 100644
--- a/src/discordgodot.cpp
+++ b/src/discordgodot.cpp
@@ -3,27 +3,27 @@
#include
#include
-#define BIND_METHOD(method, ...) godot::ClassDB::bind_method(D_METHOD(#method, ##__VA_ARGS__), &DiscordSDK::method)
+#define BIND_METHOD(method, ...) godot::ClassDB::bind_method(D_METHOD(#method, ##__VA_ARGS__), &DiscordRPC::method)
#define BIND_SET_GET(property_name, variant_type) \
- godot::ClassDB::bind_method(D_METHOD("get_" #property_name), &DiscordSDK::get_##property_name); \
- godot::ClassDB::bind_method(D_METHOD("set_" #property_name, #variant_type), &DiscordSDK::set_##property_name); \
+ godot::ClassDB::bind_method(D_METHOD("get_" #property_name), &DiscordRPC::get_##property_name); \
+ godot::ClassDB::bind_method(D_METHOD("set_" #property_name, #variant_type), &DiscordRPC::set_##property_name); \
godot::ClassDB::add_property(get_class_static(), PropertyInfo(variant_type, #property_name), "set_" #property_name, "get_" #property_name)
#define BIND_SIGNAL(signal_name, ...) godot::ClassDB::add_signal(get_class_static(), MethodInfo(#signal_name, ##__VA_ARGS__))
#define SET_GET(variable, setter, ...) /*getter isn't mandatory for this project*/ \
- decltype(DiscordSDK::variable) DiscordSDK::get_##variable() { return variable; } \
- void DiscordSDK::set_##variable(decltype(DiscordSDK::variable) value) \
+ decltype(DiscordRPC::variable) DiscordRPC::get_##variable() { return variable; } \
+ void DiscordRPC::set_##variable(decltype(DiscordRPC::variable) value) \
{ \
variable = value; \
setter; \
}
-DiscordSDK *DiscordSDK::singleton = nullptr;
+DiscordRPC *DiscordRPC::singleton = nullptr;
discord::Core *core{};
discord::Result result;
discord::Activity activity{};
discord::User user{};
-void DiscordSDK::_bind_methods()
+void DiscordRPC::_bind_methods()
{
BIND_SET_GET(app_id, Variant::INT);
BIND_SET_GET(state, Variant::STRING);
@@ -51,7 +51,7 @@ void DiscordSDK::_bind_methods()
BIND_METHOD(debug);
BIND_METHOD(run_callbacks);
BIND_METHOD(refresh);
- ClassDB::bind_method(D_METHOD("clear", "reset_values"), &DiscordSDK::clear, DEFVAL(false));
+ ClassDB::bind_method(D_METHOD("clear", "reset_values"), &DiscordRPC::clear, DEFVAL(false));
BIND_METHOD(unclear);
BIND_METHOD(register_command, "command");
BIND_METHOD(register_steam, "steam_id");
@@ -85,13 +85,13 @@ SET_GET(spectate_secret, activity.GetSecrets().SetSpectate(value.utf8().get_data
SET_GET(instanced, activity.SetInstance(value))
SET_GET(is_public_party, activity.GetParty().SetPrivacy(static_cast(value)))
-DiscordSDK::DiscordSDK()
+DiscordRPC::DiscordRPC()
{
ERR_FAIL_COND(singleton != nullptr);
singleton = this;
}
-DiscordSDK::~DiscordSDK()
+DiscordRPC::~DiscordRPC()
{
app_id = 0;
delete core; // couldn't use destructor because it would not compile on linux
@@ -100,17 +100,17 @@ DiscordSDK::~DiscordSDK()
singleton = nullptr;
}
-DiscordSDK *DiscordSDK::get_singleton()
+DiscordRPC *DiscordRPC::get_singleton()
{
return singleton;
}
-void DiscordSDK::run_callbacks()
+void DiscordRPC::run_callbacks()
{
if (result == discord::Result::Ok && app_id > 0)
::core->RunCallbacks();
}
-void DiscordSDK::debug()
+void DiscordRPC::debug()
{
result = discord::Core::Create(1080224638845591692, DiscordCreateFlags_NoRequireDiscord, &core);
activity.SetState("Test from Godot!");
@@ -128,7 +128,7 @@ void DiscordSDK::debug()
UtilityFunctions::push_warning("Discord Activity couldn't be updated. It could be that Discord isn't running!");
}
-void DiscordSDK::set_app_id(int64_t value)
+void DiscordRPC::set_app_id(int64_t value)
{
app_id = value;
if (app_id > 0)
@@ -143,34 +143,34 @@ void DiscordSDK::set_app_id(int64_t value)
core->UserManager().GetCurrentUser(&user); });
// signals
core->ActivityManager().OnActivityJoin.Connect([](const char *secret)
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("activity_join", secret); });
core->ActivityManager().OnActivitySpectate.Connect([](const char *secret)
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("activity_spectate", secret); });
core->ActivityManager().OnActivityJoinRequest.Connect([this](discord::User const &user)
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("activity_join_request", user2dict(user)); });
core->OverlayManager().OnToggle.Connect([](bool is_locked)
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("overlay_toggle", is_locked); });
core->RelationshipManager().OnRefresh.Connect([&]()
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("relationships_init"); });
core->RelationshipManager().OnRelationshipUpdate.Connect([&](discord::Relationship const &relationship)
- { DiscordSDK::get_singleton()
+ { DiscordRPC::get_singleton()
->emit_signal("updated_relationship", relationship2dict(relationship)); });
}
}
}
-int64_t DiscordSDK::get_app_id()
+int64_t DiscordRPC::get_app_id()
{
if (app_id != 0)
return app_id;
return old_app_id;
}
-void DiscordSDK::refresh()
+void DiscordRPC::refresh()
{
if (get_is_discord_working())
{
@@ -182,7 +182,7 @@ void DiscordSDK::refresh()
UtilityFunctions::push_warning("Discord Activity couldn't be updated. It could be that Discord isn't running!");
}
-void DiscordSDK::clear(bool reset_values = false)
+void DiscordRPC::clear(bool reset_values = false)
{
if (get_is_discord_working())
{
@@ -216,7 +216,7 @@ void DiscordSDK::clear(bool reset_values = false)
}
}
-void DiscordSDK::unclear()
+void DiscordRPC::unclear()
{
if (old_app_id > 0)
{
@@ -228,69 +228,69 @@ void DiscordSDK::unclear()
UtilityFunctions::push_warning("Discord Activity couldn't be uncleared. Maybe it didn't get cleared before?");
}
-bool DiscordSDK::get_is_overlay_enabled()
+bool DiscordRPC::get_is_overlay_enabled()
{
bool ie;
if (get_is_discord_working())
core->OverlayManager().IsEnabled(&ie);
return ie;
}
-bool DiscordSDK::get_is_overlay_locked()
+bool DiscordRPC::get_is_overlay_locked()
{
bool il;
if (get_is_discord_working())
core->OverlayManager().IsLocked(&il);
return il;
}
-void DiscordSDK::set_is_overlay_locked(bool value)
+void DiscordRPC::set_is_overlay_locked(bool value)
{
is_overlay_locked = value;
if (get_is_discord_working())
core->OverlayManager().SetLocked(value, {});
}
-void DiscordSDK::open_invite_overlay(bool is_spectate)
+void DiscordRPC::open_invite_overlay(bool is_spectate)
{
if (get_is_discord_working())
core->OverlayManager().OpenActivityInvite(static_cast(is_spectate + 1), {});
}
-void DiscordSDK::open_server_invite_overlay(String invite_code)
+void DiscordRPC::open_server_invite_overlay(String invite_code)
{
if (get_is_discord_working())
core->OverlayManager().OpenGuildInvite(invite_code.utf8().get_data(), {});
}
-void DiscordSDK::open_voice_settings()
+void DiscordRPC::open_voice_settings()
{
if (get_is_discord_working())
core->OverlayManager().OpenVoiceSettings({});
}
-void DiscordSDK::accept_join_request(int64_t user_id)
+void DiscordRPC::accept_join_request(int64_t user_id)
{
if (get_is_discord_working())
core->ActivityManager().SendRequestReply(user_id, static_cast(1), {});
}
-void DiscordSDK::send_invite(int64_t user_id, bool is_spectate = false, String message_content = "")
+void DiscordRPC::send_invite(int64_t user_id, bool is_spectate = false, String message_content = "")
{
if (get_is_discord_working())
core->ActivityManager().SendInvite(user_id, static_cast(is_spectate + 1), message_content.utf8().get_data(), {});
}
-void DiscordSDK::accept_invite(int64_t user_id)
+void DiscordRPC::accept_invite(int64_t user_id)
{
if (get_is_discord_working())
core->ActivityManager().AcceptInvite(user_id, {});
}
-void DiscordSDK::register_command(String value)
+void DiscordRPC::register_command(String value)
{
if (get_is_discord_working())
core->ActivityManager().RegisterCommand(value.utf8().get_data());
}
-void DiscordSDK::register_steam(int32_t value)
+void DiscordRPC::register_steam(int32_t value)
{
if (get_is_discord_working())
core->ActivityManager().RegisterSteam(value);
}
-Dictionary DiscordSDK::get_current_user()
+Dictionary DiscordRPC::get_current_user()
{
Dictionary userdict;
if (get_is_discord_working())
@@ -302,7 +302,7 @@ Dictionary DiscordSDK::get_current_user()
return userdict;
}
-Dictionary DiscordSDK::get_relationship(int64_t user_id)
+Dictionary DiscordRPC::get_relationship(int64_t user_id)
{
if (get_is_discord_working())
{
@@ -314,7 +314,7 @@ Dictionary DiscordSDK::get_relationship(int64_t user_id)
return dict;
}
-Array DiscordSDK::get_all_relationships()
+Array DiscordRPC::get_all_relationships()
{
Array all_relationships;
core->RelationshipManager().Filter(
@@ -331,12 +331,12 @@ Array DiscordSDK::get_all_relationships()
return all_relationships;
}
-int DiscordSDK::get_result_int()
+int DiscordRPC::get_result_int()
{
return static_cast(result);
}
-Dictionary DiscordSDK::user2dict(discord::User user)
+Dictionary DiscordRPC::user2dict(discord::User user)
{
Dictionary userdict;
userdict["avatar"] = user.GetAvatar(); // can be empty when user has no avatar
@@ -352,7 +352,7 @@ Dictionary DiscordSDK::user2dict(discord::User user)
return userdict;
}
-Dictionary DiscordSDK::relationship2dict(discord::Relationship relationship)
+Dictionary DiscordRPC::relationship2dict(discord::Relationship relationship)
{
Dictionary dict_relationship;
Dictionary presence;
@@ -424,7 +424,7 @@ Dictionary DiscordSDK::relationship2dict(discord::Relationship relationship)
return dict_relationship;
}
-bool DiscordSDK::get_is_discord_working()
+bool DiscordRPC::get_is_discord_working()
{
return result == discord::Result::Ok && app_id > 0;
}
\ No newline at end of file
diff --git a/src/discordgodot.h b/src/discordgodot.h
index a0db287..c34995e 100644
--- a/src/discordgodot.h
+++ b/src/discordgodot.h
@@ -13,21 +13,21 @@
using namespace godot;
-class DiscordSDK : public Object
+class DiscordRPC : public Object
{
- GDCLASS(DiscordSDK, Object);
+ GDCLASS(DiscordRPC, Object);
- static DiscordSDK *singleton;
+ static DiscordRPC *singleton;
protected:
static void _bind_methods();
public:
- static DiscordSDK *
+ static DiscordRPC *
get_singleton();
- DiscordSDK();
- ~DiscordSDK();
+ DiscordRPC();
+ ~DiscordRPC();
// INTERBNAL
int64_t old_app_id;
diff --git a/src/lib/discord_game_sdk/bin/discord_game_sdk.bundle b/src/lib/discord_game_sdk/bin/discord_game_sdk.bundle
new file mode 100644
index 0000000..3402426
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/discord_game_sdk.bundle differ
diff --git a/src/lib/discord_game_sdk/bin/discord_game_sdk.dll b/src/lib/discord_game_sdk/bin/discord_game_sdk.dll
new file mode 100644
index 0000000..be946ea
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/discord_game_sdk.dll differ
diff --git a/src/lib/discord_game_sdk/bin/discord_game_sdk.dylib b/src/lib/discord_game_sdk/bin/discord_game_sdk.dylib
new file mode 100644
index 0000000..3402426
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/discord_game_sdk.dylib differ
diff --git a/src/lib/discord_game_sdk/bin/discord_game_sdk_aarch64.dylib b/src/lib/discord_game_sdk/bin/discord_game_sdk_aarch64.dylib
new file mode 100644
index 0000000..8f08606
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/discord_game_sdk_aarch64.dylib differ
diff --git a/src/lib/discord_game_sdk/bin/discord_game_sdk_x86.dll b/src/lib/discord_game_sdk/bin/discord_game_sdk_x86.dll
new file mode 100644
index 0000000..45b9bb1
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/discord_game_sdk_x86.dll differ
diff --git a/src/lib/discord_game_sdk/bin/libdiscord_game_sdk.so b/src/lib/discord_game_sdk/bin/libdiscord_game_sdk.so
new file mode 100644
index 0000000..9dacf94
Binary files /dev/null and b/src/lib/discord_game_sdk/bin/libdiscord_game_sdk.so differ
diff --git a/src/lib/discord_game_sdk/cpp/achievement_manager.cpp b/src/lib/discord_game_sdk/cpp/achievement_manager.cpp
new file mode 100644
index 0000000..43a6d4c
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/achievement_manager.cpp
@@ -0,0 +1,99 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "achievement_manager.h"
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+class AchievementEvents final {
+public:
+ static void DISCORD_CALLBACK OnUserAchievementUpdate(void* callbackData,
+ DiscordUserAchievement* userAchievement)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->AchievementManager();
+ module.OnUserAchievementUpdate(*reinterpret_cast(userAchievement));
+ }
+};
+
+IDiscordAchievementEvents AchievementManager::events_{
+ &AchievementEvents::OnUserAchievementUpdate,
+};
+
+void AchievementManager::SetUserAchievement(Snowflake achievementId,
+ std::uint8_t percentComplete,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->set_user_achievement(
+ internal_, achievementId, percentComplete, cb.release(), wrapper);
+}
+
+void AchievementManager::FetchUserAchievements(std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->fetch_user_achievements(internal_, cb.release(), wrapper);
+}
+
+void AchievementManager::CountUserAchievements(std::int32_t* count)
+{
+ if (!count) {
+ return;
+ }
+
+ internal_->count_user_achievements(internal_, reinterpret_cast(count));
+}
+
+Result AchievementManager::GetUserAchievement(Snowflake userAchievementId,
+ UserAchievement* userAchievement)
+{
+ if (!userAchievement) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_user_achievement(
+ internal_, userAchievementId, reinterpret_cast(userAchievement));
+ return static_cast(result);
+}
+
+Result AchievementManager::GetUserAchievementAt(std::int32_t index,
+ UserAchievement* userAchievement)
+{
+ if (!userAchievement) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_user_achievement_at(
+ internal_, index, reinterpret_cast(userAchievement));
+ return static_cast(result);
+}
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/achievement_manager.h b/src/lib/discord_game_sdk/cpp/achievement_manager.h
new file mode 100644
index 0000000..1f58c8e
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/achievement_manager.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class AchievementManager final {
+public:
+ ~AchievementManager() = default;
+
+ void SetUserAchievement(Snowflake achievementId,
+ std::uint8_t percentComplete,
+ std::function callback);
+ void FetchUserAchievements(std::function callback);
+ void CountUserAchievements(std::int32_t* count);
+ Result GetUserAchievement(Snowflake userAchievementId, UserAchievement* userAchievement);
+ Result GetUserAchievementAt(std::int32_t index, UserAchievement* userAchievement);
+
+ Event OnUserAchievementUpdate;
+
+private:
+ friend class Core;
+
+ AchievementManager() = default;
+ AchievementManager(AchievementManager const& rhs) = delete;
+ AchievementManager& operator=(AchievementManager const& rhs) = delete;
+ AchievementManager(AchievementManager&& rhs) = delete;
+ AchievementManager& operator=(AchievementManager&& rhs) = delete;
+
+ IDiscordAchievementManager* internal_;
+ static IDiscordAchievementEvents events_;
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/activity_manager.cpp b/src/lib/discord_game_sdk/cpp/activity_manager.cpp
new file mode 100644
index 0000000..3c20074
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/activity_manager.cpp
@@ -0,0 +1,177 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "activity_manager.h"
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+class ActivityEvents final {
+public:
+ static void DISCORD_CALLBACK OnActivityJoin(void* callbackData, char const* secret)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->ActivityManager();
+ module.OnActivityJoin(static_cast(secret));
+ }
+
+ static void DISCORD_CALLBACK OnActivitySpectate(void* callbackData, char const* secret)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->ActivityManager();
+ module.OnActivitySpectate(static_cast(secret));
+ }
+
+ static void DISCORD_CALLBACK OnActivityJoinRequest(void* callbackData, DiscordUser* user)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->ActivityManager();
+ module.OnActivityJoinRequest(*reinterpret_cast(user));
+ }
+
+ static void DISCORD_CALLBACK OnActivityInvite(void* callbackData,
+ EDiscordActivityActionType type,
+ DiscordUser* user,
+ DiscordActivity* activity)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->ActivityManager();
+ module.OnActivityInvite(static_cast(type),
+ *reinterpret_cast(user),
+ *reinterpret_cast(activity));
+ }
+};
+
+IDiscordActivityEvents ActivityManager::events_{
+ &ActivityEvents::OnActivityJoin,
+ &ActivityEvents::OnActivitySpectate,
+ &ActivityEvents::OnActivityJoinRequest,
+ &ActivityEvents::OnActivityInvite,
+};
+
+Result ActivityManager::RegisterCommand(char const* command)
+{
+ auto result = internal_->register_command(internal_, const_cast(command));
+ return static_cast(result);
+}
+
+Result ActivityManager::RegisterSteam(std::uint32_t steamId)
+{
+ auto result = internal_->register_steam(internal_, steamId);
+ return static_cast(result);
+}
+
+void ActivityManager::UpdateActivity(Activity const& activity, std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->update_activity(internal_,
+ reinterpret_cast(const_cast(&activity)),
+ cb.release(),
+ wrapper);
+}
+
+void ActivityManager::ClearActivity(std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->clear_activity(internal_, cb.release(), wrapper);
+}
+
+void ActivityManager::SendRequestReply(UserId userId,
+ ActivityJoinRequestReply reply,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->send_request_reply(internal_,
+ userId,
+ static_cast(reply),
+ cb.release(),
+ wrapper);
+}
+
+void ActivityManager::SendInvite(UserId userId,
+ ActivityActionType type,
+ char const* content,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->send_invite(internal_,
+ userId,
+ static_cast(type),
+ const_cast(content),
+ cb.release(),
+ wrapper);
+}
+
+void ActivityManager::AcceptInvite(UserId userId, std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->accept_invite(internal_, userId, cb.release(), wrapper);
+}
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/activity_manager.h b/src/lib/discord_game_sdk/cpp/activity_manager.h
new file mode 100644
index 0000000..c107be2
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/activity_manager.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ActivityManager final {
+public:
+ ~ActivityManager() = default;
+
+ Result RegisterCommand(char const* command);
+ Result RegisterSteam(std::uint32_t steamId);
+ void UpdateActivity(Activity const& activity, std::function callback);
+ void ClearActivity(std::function callback);
+ void SendRequestReply(UserId userId,
+ ActivityJoinRequestReply reply,
+ std::function callback);
+ void SendInvite(UserId userId,
+ ActivityActionType type,
+ char const* content,
+ std::function callback);
+ void AcceptInvite(UserId userId, std::function callback);
+
+ Event OnActivityJoin;
+ Event OnActivitySpectate;
+ Event OnActivityJoinRequest;
+ Event OnActivityInvite;
+
+private:
+ friend class Core;
+
+ ActivityManager() = default;
+ ActivityManager(ActivityManager const& rhs) = delete;
+ ActivityManager& operator=(ActivityManager const& rhs) = delete;
+ ActivityManager(ActivityManager&& rhs) = delete;
+ ActivityManager& operator=(ActivityManager&& rhs) = delete;
+
+ IDiscordActivityManager* internal_;
+ static IDiscordActivityEvents events_;
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/application_manager.cpp b/src/lib/discord_game_sdk/cpp/application_manager.cpp
new file mode 100644
index 0000000..0e05f3f
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/application_manager.cpp
@@ -0,0 +1,78 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "application_manager.h"
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+void ApplicationManager::ValidateOrExit(std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->validate_or_exit(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetCurrentLocale(char locale[128])
+{
+ if (!locale) {
+ return;
+ }
+
+ internal_->get_current_locale(internal_, reinterpret_cast(locale));
+}
+
+void ApplicationManager::GetCurrentBranch(char branch[4096])
+{
+ if (!branch) {
+ return;
+ }
+
+ internal_->get_current_branch(internal_, reinterpret_cast(branch));
+}
+
+void ApplicationManager::GetOAuth2Token(std::function callback)
+{
+ static auto wrapper =
+ [](void* callbackData, EDiscordResult result, DiscordOAuth2Token* oauth2Token) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), *reinterpret_cast(oauth2Token));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->get_oauth2_token(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetTicket(std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result, char const* data) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), static_cast(data));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->get_ticket(internal_, cb.release(), wrapper);
+}
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/application_manager.h b/src/lib/discord_game_sdk/cpp/application_manager.h
new file mode 100644
index 0000000..ab0e856
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/application_manager.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ApplicationManager final {
+public:
+ ~ApplicationManager() = default;
+
+ void ValidateOrExit(std::function callback);
+ void GetCurrentLocale(char locale[128]);
+ void GetCurrentBranch(char branch[4096]);
+ void GetOAuth2Token(std::function callback);
+ void GetTicket(std::function callback);
+
+private:
+ friend class Core;
+
+ ApplicationManager() = default;
+ ApplicationManager(ApplicationManager const& rhs) = delete;
+ ApplicationManager& operator=(ApplicationManager const& rhs) = delete;
+ ApplicationManager(ApplicationManager&& rhs) = delete;
+ ApplicationManager& operator=(ApplicationManager&& rhs) = delete;
+
+ IDiscordApplicationManager* internal_;
+ static IDiscordApplicationEvents events_;
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/core.cpp b/src/lib/discord_game_sdk/cpp/core.cpp
new file mode 100644
index 0000000..110c9ef
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/core.cpp
@@ -0,0 +1,182 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+Result Core::Create(ClientId clientId, std::uint64_t flags, Core** instance)
+{
+ if (!instance) {
+ return Result::InternalError;
+ }
+
+ (*instance) = new Core();
+ DiscordCreateParams params{};
+ DiscordCreateParamsSetDefault(¶ms);
+ params.client_id = clientId;
+ params.flags = flags;
+ params.events = nullptr;
+ params.event_data = *instance;
+ params.user_events = &UserManager::events_;
+ params.activity_events = &ActivityManager::events_;
+ params.relationship_events = &RelationshipManager::events_;
+ params.lobby_events = &LobbyManager::events_;
+ params.network_events = &NetworkManager::events_;
+ params.overlay_events = &OverlayManager::events_;
+ params.store_events = &StoreManager::events_;
+ params.voice_events = &VoiceManager::events_;
+ params.achievement_events = &AchievementManager::events_;
+ auto result = DiscordCreate(DISCORD_VERSION, ¶ms, &((*instance)->internal_));
+ if (result != DiscordResult_Ok || !(*instance)->internal_) {
+ delete (*instance);
+ (*instance) = nullptr;
+ }
+
+ return static_cast(result);
+}
+
+Core::~Core()
+{
+ if (internal_) {
+ internal_->destroy(internal_);
+ internal_ = nullptr;
+ }
+}
+
+Result Core::RunCallbacks()
+{
+ auto result = internal_->run_callbacks(internal_);
+ return static_cast(result);
+}
+
+void Core::SetLogHook(LogLevel minLevel, std::function hook)
+{
+ setLogHook_.DisconnectAll();
+ setLogHook_.Connect(std::move(hook));
+ static auto wrapper =
+ [](void* callbackData, EDiscordLogLevel level, char const* message) -> void {
+ auto cb(reinterpret_cast(callbackData));
+ if (!cb) {
+ return;
+ }
+ (*cb)(static_cast(level), static_cast(message));
+ };
+
+ internal_->set_log_hook(
+ internal_, static_cast(minLevel), &setLogHook_, wrapper);
+}
+
+discord::ApplicationManager& Core::ApplicationManager()
+{
+ if (!applicationManager_.internal_) {
+ applicationManager_.internal_ = internal_->get_application_manager(internal_);
+ }
+
+ return applicationManager_;
+}
+
+discord::UserManager& Core::UserManager()
+{
+ if (!userManager_.internal_) {
+ userManager_.internal_ = internal_->get_user_manager(internal_);
+ }
+
+ return userManager_;
+}
+
+discord::ImageManager& Core::ImageManager()
+{
+ if (!imageManager_.internal_) {
+ imageManager_.internal_ = internal_->get_image_manager(internal_);
+ }
+
+ return imageManager_;
+}
+
+discord::ActivityManager& Core::ActivityManager()
+{
+ if (!activityManager_.internal_) {
+ activityManager_.internal_ = internal_->get_activity_manager(internal_);
+ }
+
+ return activityManager_;
+}
+
+discord::RelationshipManager& Core::RelationshipManager()
+{
+ if (!relationshipManager_.internal_) {
+ relationshipManager_.internal_ = internal_->get_relationship_manager(internal_);
+ }
+
+ return relationshipManager_;
+}
+
+discord::LobbyManager& Core::LobbyManager()
+{
+ if (!lobbyManager_.internal_) {
+ lobbyManager_.internal_ = internal_->get_lobby_manager(internal_);
+ }
+
+ return lobbyManager_;
+}
+
+discord::NetworkManager& Core::NetworkManager()
+{
+ if (!networkManager_.internal_) {
+ networkManager_.internal_ = internal_->get_network_manager(internal_);
+ }
+
+ return networkManager_;
+}
+
+discord::OverlayManager& Core::OverlayManager()
+{
+ if (!overlayManager_.internal_) {
+ overlayManager_.internal_ = internal_->get_overlay_manager(internal_);
+ }
+
+ return overlayManager_;
+}
+
+discord::StorageManager& Core::StorageManager()
+{
+ if (!storageManager_.internal_) {
+ storageManager_.internal_ = internal_->get_storage_manager(internal_);
+ }
+
+ return storageManager_;
+}
+
+discord::StoreManager& Core::StoreManager()
+{
+ if (!storeManager_.internal_) {
+ storeManager_.internal_ = internal_->get_store_manager(internal_);
+ }
+
+ return storeManager_;
+}
+
+discord::VoiceManager& Core::VoiceManager()
+{
+ if (!voiceManager_.internal_) {
+ voiceManager_.internal_ = internal_->get_voice_manager(internal_);
+ }
+
+ return voiceManager_;
+}
+
+discord::AchievementManager& Core::AchievementManager()
+{
+ if (!achievementManager_.internal_) {
+ achievementManager_.internal_ = internal_->get_achievement_manager(internal_);
+ }
+
+ return achievementManager_;
+}
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/core.h b/src/lib/discord_game_sdk/cpp/core.h
new file mode 100644
index 0000000..8af6fca
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/core.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "types.h"
+#include "application_manager.h"
+#include "user_manager.h"
+#include "image_manager.h"
+#include "activity_manager.h"
+#include "relationship_manager.h"
+#include "lobby_manager.h"
+#include "network_manager.h"
+#include "overlay_manager.h"
+#include "storage_manager.h"
+#include "store_manager.h"
+#include "voice_manager.h"
+#include "achievement_manager.h"
+
+namespace discord {
+
+class Core final {
+public:
+ static Result Create(ClientId clientId, std::uint64_t flags, Core** instance);
+
+ ~Core();
+
+ Result RunCallbacks();
+ void SetLogHook(LogLevel minLevel, std::function hook);
+
+ discord::ApplicationManager& ApplicationManager();
+ discord::UserManager& UserManager();
+ discord::ImageManager& ImageManager();
+ discord::ActivityManager& ActivityManager();
+ discord::RelationshipManager& RelationshipManager();
+ discord::LobbyManager& LobbyManager();
+ discord::NetworkManager& NetworkManager();
+ discord::OverlayManager& OverlayManager();
+ discord::StorageManager& StorageManager();
+ discord::StoreManager& StoreManager();
+ discord::VoiceManager& VoiceManager();
+ discord::AchievementManager& AchievementManager();
+
+private:
+ Core() = default;
+ Core(Core const& rhs) = delete;
+ Core& operator=(Core const& rhs) = delete;
+ Core(Core&& rhs) = delete;
+ Core& operator=(Core&& rhs) = delete;
+
+ IDiscordCore* internal_;
+ Event setLogHook_;
+ discord::ApplicationManager applicationManager_;
+ discord::UserManager userManager_;
+ discord::ImageManager imageManager_;
+ discord::ActivityManager activityManager_;
+ discord::RelationshipManager relationshipManager_;
+ discord::LobbyManager lobbyManager_;
+ discord::NetworkManager networkManager_;
+ discord::OverlayManager overlayManager_;
+ discord::StorageManager storageManager_;
+ discord::StoreManager storeManager_;
+ discord::VoiceManager voiceManager_;
+ discord::AchievementManager achievementManager_;
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/discord.h b/src/lib/discord_game_sdk/cpp/discord.h
new file mode 100644
index 0000000..c991212
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/discord.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "types.h"
+#include "core.h"
+#include "application_manager.h"
+#include "user_manager.h"
+#include "image_manager.h"
+#include "activity_manager.h"
+#include "relationship_manager.h"
+#include "lobby_manager.h"
+#include "network_manager.h"
+#include "overlay_manager.h"
+#include "storage_manager.h"
+#include "store_manager.h"
+#include "voice_manager.h"
+#include "achievement_manager.h"
diff --git a/src/lib/discord_game_sdk/cpp/event.h b/src/lib/discord_game_sdk/cpp/event.h
new file mode 100644
index 0000000..610887d
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/event.h
@@ -0,0 +1,59 @@
+#pragma once
+
+#include
+#include
+
+namespace discord {
+
+template
+class Event final {
+public:
+ using Token = int;
+
+ Event() { slots_.reserve(4); }
+
+ Event(Event const&) = default;
+ Event(Event&&) = default;
+ ~Event() = default;
+
+ Event& operator=(Event const&) = default;
+ Event& operator=(Event&&) = default;
+
+ template
+ Token Connect(EventHandler slot)
+ {
+ slots_.emplace_back(Slot{nextToken_, std::move(slot)});
+ return nextToken_++;
+ }
+
+ void Disconnect(Token token)
+ {
+ for (auto& slot : slots_) {
+ if (slot.token == token) {
+ slot = slots_.back();
+ slots_.pop_back();
+ break;
+ }
+ }
+ }
+
+ void DisconnectAll() { slots_ = {}; }
+
+ void operator()(Args... args)
+ {
+ for (auto const& slot : slots_) {
+ slot.fn(std::forward(args)...);
+ }
+ }
+
+private:
+ struct Slot {
+ Token token;
+ std::function fn;
+ };
+
+ Token nextToken_{};
+ std::vector slots_{};
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/ffi.h b/src/lib/discord_game_sdk/cpp/ffi.h
new file mode 100644
index 0000000..4a21057
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/ffi.h
@@ -0,0 +1,1113 @@
+#ifndef _DISCORD_GAME_SDK_H_
+#define _DISCORD_GAME_SDK_H_
+
+#ifdef _WIN32
+#include
+#include
+#endif
+
+#ifdef _WIN32
+#ifdef _WIN64
+#define DISCORD_API
+#else
+#define DISCORD_API __stdcall
+#endif
+#else
+#define DISCORD_API
+#endif
+
+#define DISCORD_CALLBACK DISCORD_API
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include
+#include
+#ifndef __cplusplus
+#include
+#endif
+
+#define DISCORD_VERSION 3
+#define DISCORD_APPLICATION_MANAGER_VERSION 1
+#define DISCORD_USER_MANAGER_VERSION 1
+#define DISCORD_IMAGE_MANAGER_VERSION 1
+#define DISCORD_ACTIVITY_MANAGER_VERSION 1
+#define DISCORD_RELATIONSHIP_MANAGER_VERSION 1
+#define DISCORD_LOBBY_MANAGER_VERSION 1
+#define DISCORD_NETWORK_MANAGER_VERSION 1
+#define DISCORD_OVERLAY_MANAGER_VERSION 2
+#define DISCORD_STORAGE_MANAGER_VERSION 1
+#define DISCORD_STORE_MANAGER_VERSION 1
+#define DISCORD_VOICE_MANAGER_VERSION 1
+#define DISCORD_ACHIEVEMENT_MANAGER_VERSION 1
+
+enum EDiscordResult {
+ DiscordResult_Ok = 0,
+ DiscordResult_ServiceUnavailable = 1,
+ DiscordResult_InvalidVersion = 2,
+ DiscordResult_LockFailed = 3,
+ DiscordResult_InternalError = 4,
+ DiscordResult_InvalidPayload = 5,
+ DiscordResult_InvalidCommand = 6,
+ DiscordResult_InvalidPermissions = 7,
+ DiscordResult_NotFetched = 8,
+ DiscordResult_NotFound = 9,
+ DiscordResult_Conflict = 10,
+ DiscordResult_InvalidSecret = 11,
+ DiscordResult_InvalidJoinSecret = 12,
+ DiscordResult_NoEligibleActivity = 13,
+ DiscordResult_InvalidInvite = 14,
+ DiscordResult_NotAuthenticated = 15,
+ DiscordResult_InvalidAccessToken = 16,
+ DiscordResult_ApplicationMismatch = 17,
+ DiscordResult_InvalidDataUrl = 18,
+ DiscordResult_InvalidBase64 = 19,
+ DiscordResult_NotFiltered = 20,
+ DiscordResult_LobbyFull = 21,
+ DiscordResult_InvalidLobbySecret = 22,
+ DiscordResult_InvalidFilename = 23,
+ DiscordResult_InvalidFileSize = 24,
+ DiscordResult_InvalidEntitlement = 25,
+ DiscordResult_NotInstalled = 26,
+ DiscordResult_NotRunning = 27,
+ DiscordResult_InsufficientBuffer = 28,
+ DiscordResult_PurchaseCanceled = 29,
+ DiscordResult_InvalidGuild = 30,
+ DiscordResult_InvalidEvent = 31,
+ DiscordResult_InvalidChannel = 32,
+ DiscordResult_InvalidOrigin = 33,
+ DiscordResult_RateLimited = 34,
+ DiscordResult_OAuth2Error = 35,
+ DiscordResult_SelectChannelTimeout = 36,
+ DiscordResult_GetGuildTimeout = 37,
+ DiscordResult_SelectVoiceForceRequired = 38,
+ DiscordResult_CaptureShortcutAlreadyListening = 39,
+ DiscordResult_UnauthorizedForAchievement = 40,
+ DiscordResult_InvalidGiftCode = 41,
+ DiscordResult_PurchaseError = 42,
+ DiscordResult_TransactionAborted = 43,
+ DiscordResult_DrawingInitFailed = 44,
+};
+
+enum EDiscordCreateFlags {
+ DiscordCreateFlags_Default = 0,
+ DiscordCreateFlags_NoRequireDiscord = 1,
+};
+
+enum EDiscordLogLevel {
+ DiscordLogLevel_Error = 1,
+ DiscordLogLevel_Warn,
+ DiscordLogLevel_Info,
+ DiscordLogLevel_Debug,
+};
+
+enum EDiscordUserFlag {
+ DiscordUserFlag_Partner = 2,
+ DiscordUserFlag_HypeSquadEvents = 4,
+ DiscordUserFlag_HypeSquadHouse1 = 64,
+ DiscordUserFlag_HypeSquadHouse2 = 128,
+ DiscordUserFlag_HypeSquadHouse3 = 256,
+};
+
+enum EDiscordPremiumType {
+ DiscordPremiumType_None = 0,
+ DiscordPremiumType_Tier1 = 1,
+ DiscordPremiumType_Tier2 = 2,
+};
+
+enum EDiscordImageType {
+ DiscordImageType_User,
+};
+
+enum EDiscordActivityPartyPrivacy {
+ DiscordActivityPartyPrivacy_Private = 0,
+ DiscordActivityPartyPrivacy_Public = 1,
+};
+
+enum EDiscordActivityType {
+ DiscordActivityType_Playing,
+ DiscordActivityType_Streaming,
+ DiscordActivityType_Listening,
+ DiscordActivityType_Watching,
+};
+
+enum EDiscordActivityActionType {
+ DiscordActivityActionType_Join = 1,
+ DiscordActivityActionType_Spectate,
+};
+
+enum EDiscordActivitySupportedPlatformFlags {
+ DiscordActivitySupportedPlatformFlags_Desktop = 1,
+ DiscordActivitySupportedPlatformFlags_Android = 2,
+ DiscordActivitySupportedPlatformFlags_iOS = 4,
+};
+
+enum EDiscordActivityJoinRequestReply {
+ DiscordActivityJoinRequestReply_No,
+ DiscordActivityJoinRequestReply_Yes,
+ DiscordActivityJoinRequestReply_Ignore,
+};
+
+enum EDiscordStatus {
+ DiscordStatus_Offline = 0,
+ DiscordStatus_Online = 1,
+ DiscordStatus_Idle = 2,
+ DiscordStatus_DoNotDisturb = 3,
+};
+
+enum EDiscordRelationshipType {
+ DiscordRelationshipType_None,
+ DiscordRelationshipType_Friend,
+ DiscordRelationshipType_Blocked,
+ DiscordRelationshipType_PendingIncoming,
+ DiscordRelationshipType_PendingOutgoing,
+ DiscordRelationshipType_Implicit,
+};
+
+enum EDiscordLobbyType {
+ DiscordLobbyType_Private = 1,
+ DiscordLobbyType_Public,
+};
+
+enum EDiscordLobbySearchComparison {
+ DiscordLobbySearchComparison_LessThanOrEqual = -2,
+ DiscordLobbySearchComparison_LessThan,
+ DiscordLobbySearchComparison_Equal,
+ DiscordLobbySearchComparison_GreaterThan,
+ DiscordLobbySearchComparison_GreaterThanOrEqual,
+ DiscordLobbySearchComparison_NotEqual,
+};
+
+enum EDiscordLobbySearchCast {
+ DiscordLobbySearchCast_String = 1,
+ DiscordLobbySearchCast_Number,
+};
+
+enum EDiscordLobbySearchDistance {
+ DiscordLobbySearchDistance_Local,
+ DiscordLobbySearchDistance_Default,
+ DiscordLobbySearchDistance_Extended,
+ DiscordLobbySearchDistance_Global,
+};
+
+enum EDiscordKeyVariant {
+ DiscordKeyVariant_Normal,
+ DiscordKeyVariant_Right,
+ DiscordKeyVariant_Left,
+};
+
+enum EDiscordMouseButton {
+ DiscordMouseButton_Left,
+ DiscordMouseButton_Middle,
+ DiscordMouseButton_Right,
+};
+
+enum EDiscordEntitlementType {
+ DiscordEntitlementType_Purchase = 1,
+ DiscordEntitlementType_PremiumSubscription,
+ DiscordEntitlementType_DeveloperGift,
+ DiscordEntitlementType_TestModePurchase,
+ DiscordEntitlementType_FreePurchase,
+ DiscordEntitlementType_UserGift,
+ DiscordEntitlementType_PremiumPurchase,
+};
+
+enum EDiscordSkuType {
+ DiscordSkuType_Application = 1,
+ DiscordSkuType_DLC,
+ DiscordSkuType_Consumable,
+ DiscordSkuType_Bundle,
+};
+
+enum EDiscordInputModeType {
+ DiscordInputModeType_VoiceActivity = 0,
+ DiscordInputModeType_PushToTalk,
+};
+
+typedef int64_t DiscordClientId;
+typedef int32_t DiscordVersion;
+typedef int64_t DiscordSnowflake;
+typedef int64_t DiscordTimestamp;
+typedef DiscordSnowflake DiscordUserId;
+typedef char DiscordLocale[128];
+typedef char DiscordBranch[4096];
+typedef DiscordSnowflake DiscordLobbyId;
+typedef char DiscordLobbySecret[128];
+typedef char DiscordMetadataKey[256];
+typedef char DiscordMetadataValue[4096];
+typedef uint64_t DiscordNetworkPeerId;
+typedef uint8_t DiscordNetworkChannelId;
+#ifdef __APPLE__
+typedef void IDXGISwapChain;
+#endif
+#ifdef __linux__
+typedef void IDXGISwapChain;
+#endif
+#ifdef __APPLE__
+typedef void MSG;
+#endif
+#ifdef __linux__
+typedef void MSG;
+#endif
+typedef char DiscordPath[4096];
+typedef char DiscordDateTime[64];
+
+struct DiscordUser {
+ DiscordUserId id;
+ char username[256];
+ char discriminator[8];
+ char avatar[128];
+ bool bot;
+};
+
+struct DiscordOAuth2Token {
+ char access_token[128];
+ char scopes[1024];
+ DiscordTimestamp expires;
+};
+
+struct DiscordImageHandle {
+ enum EDiscordImageType type;
+ int64_t id;
+ uint32_t size;
+};
+
+struct DiscordImageDimensions {
+ uint32_t width;
+ uint32_t height;
+};
+
+struct DiscordActivityTimestamps {
+ DiscordTimestamp start;
+ DiscordTimestamp end;
+};
+
+struct DiscordActivityAssets {
+ char large_image[128];
+ char large_text[128];
+ char small_image[128];
+ char small_text[128];
+};
+
+struct DiscordPartySize {
+ int32_t current_size;
+ int32_t max_size;
+};
+
+struct DiscordActivityParty {
+ char id[128];
+ struct DiscordPartySize size;
+ enum EDiscordActivityPartyPrivacy privacy;
+};
+
+struct DiscordActivitySecrets {
+ char match[128];
+ char join[128];
+ char spectate[128];
+};
+
+struct DiscordActivity {
+ enum EDiscordActivityType type;
+ int64_t application_id;
+ char name[128];
+ char state[128];
+ char details[128];
+ struct DiscordActivityTimestamps timestamps;
+ struct DiscordActivityAssets assets;
+ struct DiscordActivityParty party;
+ struct DiscordActivitySecrets secrets;
+ bool instance;
+ uint32_t supported_platforms;
+};
+
+struct DiscordPresence {
+ enum EDiscordStatus status;
+ struct DiscordActivity activity;
+};
+
+struct DiscordRelationship {
+ enum EDiscordRelationshipType type;
+ struct DiscordUser user;
+ struct DiscordPresence presence;
+};
+
+struct DiscordLobby {
+ DiscordLobbyId id;
+ enum EDiscordLobbyType type;
+ DiscordUserId owner_id;
+ DiscordLobbySecret secret;
+ uint32_t capacity;
+ bool locked;
+};
+
+struct DiscordImeUnderline {
+ int32_t from;
+ int32_t to;
+ uint32_t color;
+ uint32_t background_color;
+ bool thick;
+};
+
+struct DiscordRect {
+ int32_t left;
+ int32_t top;
+ int32_t right;
+ int32_t bottom;
+};
+
+struct DiscordFileStat {
+ char filename[260];
+ uint64_t size;
+ uint64_t last_modified;
+};
+
+struct DiscordEntitlement {
+ DiscordSnowflake id;
+ enum EDiscordEntitlementType type;
+ DiscordSnowflake sku_id;
+};
+
+struct DiscordSkuPrice {
+ uint32_t amount;
+ char currency[16];
+};
+
+struct DiscordSku {
+ DiscordSnowflake id;
+ enum EDiscordSkuType type;
+ char name[256];
+ struct DiscordSkuPrice price;
+};
+
+struct DiscordInputMode {
+ enum EDiscordInputModeType type;
+ char shortcut[256];
+};
+
+struct DiscordUserAchievement {
+ DiscordSnowflake user_id;
+ DiscordSnowflake achievement_id;
+ uint8_t percent_complete;
+ DiscordDateTime unlocked_at;
+};
+
+struct IDiscordLobbyTransaction {
+ enum EDiscordResult(DISCORD_API* set_type)(struct IDiscordLobbyTransaction* lobby_transaction,
+ enum EDiscordLobbyType type);
+ enum EDiscordResult(DISCORD_API* set_owner)(struct IDiscordLobbyTransaction* lobby_transaction,
+ DiscordUserId owner_id);
+ enum EDiscordResult(DISCORD_API* set_capacity)(
+ struct IDiscordLobbyTransaction* lobby_transaction,
+ uint32_t capacity);
+ enum EDiscordResult(DISCORD_API* set_metadata)(
+ struct IDiscordLobbyTransaction* lobby_transaction,
+ DiscordMetadataKey key,
+ DiscordMetadataValue value);
+ enum EDiscordResult(DISCORD_API* delete_metadata)(
+ struct IDiscordLobbyTransaction* lobby_transaction,
+ DiscordMetadataKey key);
+ enum EDiscordResult(DISCORD_API* set_locked)(struct IDiscordLobbyTransaction* lobby_transaction,
+ bool locked);
+};
+
+struct IDiscordLobbyMemberTransaction {
+ enum EDiscordResult(DISCORD_API* set_metadata)(
+ struct IDiscordLobbyMemberTransaction* lobby_member_transaction,
+ DiscordMetadataKey key,
+ DiscordMetadataValue value);
+ enum EDiscordResult(DISCORD_API* delete_metadata)(
+ struct IDiscordLobbyMemberTransaction* lobby_member_transaction,
+ DiscordMetadataKey key);
+};
+
+struct IDiscordLobbySearchQuery {
+ enum EDiscordResult(DISCORD_API* filter)(struct IDiscordLobbySearchQuery* lobby_search_query,
+ DiscordMetadataKey key,
+ enum EDiscordLobbySearchComparison comparison,
+ enum EDiscordLobbySearchCast cast,
+ DiscordMetadataValue value);
+ enum EDiscordResult(DISCORD_API* sort)(struct IDiscordLobbySearchQuery* lobby_search_query,
+ DiscordMetadataKey key,
+ enum EDiscordLobbySearchCast cast,
+ DiscordMetadataValue value);
+ enum EDiscordResult(DISCORD_API* limit)(struct IDiscordLobbySearchQuery* lobby_search_query,
+ uint32_t limit);
+ enum EDiscordResult(DISCORD_API* distance)(struct IDiscordLobbySearchQuery* lobby_search_query,
+ enum EDiscordLobbySearchDistance distance);
+};
+
+typedef void* IDiscordApplicationEvents;
+
+struct IDiscordApplicationManager {
+ void(DISCORD_API* validate_or_exit)(struct IDiscordApplicationManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* get_current_locale)(struct IDiscordApplicationManager* manager,
+ DiscordLocale* locale);
+ void(DISCORD_API* get_current_branch)(struct IDiscordApplicationManager* manager,
+ DiscordBranch* branch);
+ void(DISCORD_API* get_oauth2_token)(
+ struct IDiscordApplicationManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordOAuth2Token* oauth2_token));
+ void(DISCORD_API* get_ticket)(struct IDiscordApplicationManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ const char* data));
+};
+
+struct IDiscordUserEvents {
+ void(DISCORD_API* on_current_user_update)(void* event_data);
+};
+
+struct IDiscordUserManager {
+ enum EDiscordResult(DISCORD_API* get_current_user)(struct IDiscordUserManager* manager,
+ struct DiscordUser* current_user);
+ void(DISCORD_API* get_user)(struct IDiscordUserManager* manager,
+ DiscordUserId user_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordUser* user));
+ enum EDiscordResult(DISCORD_API* get_current_user_premium_type)(
+ struct IDiscordUserManager* manager,
+ enum EDiscordPremiumType* premium_type);
+ enum EDiscordResult(DISCORD_API* current_user_has_flag)(struct IDiscordUserManager* manager,
+ enum EDiscordUserFlag flag,
+ bool* has_flag);
+};
+
+typedef void* IDiscordImageEvents;
+
+struct IDiscordImageManager {
+ void(DISCORD_API* fetch)(struct IDiscordImageManager* manager,
+ struct DiscordImageHandle handle,
+ bool refresh,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordImageHandle handle_result));
+ enum EDiscordResult(DISCORD_API* get_dimensions)(struct IDiscordImageManager* manager,
+ struct DiscordImageHandle handle,
+ struct DiscordImageDimensions* dimensions);
+ enum EDiscordResult(DISCORD_API* get_data)(struct IDiscordImageManager* manager,
+ struct DiscordImageHandle handle,
+ uint8_t* data,
+ uint32_t data_length);
+};
+
+struct IDiscordActivityEvents {
+ void(DISCORD_API* on_activity_join)(void* event_data, const char* secret);
+ void(DISCORD_API* on_activity_spectate)(void* event_data, const char* secret);
+ void(DISCORD_API* on_activity_join_request)(void* event_data, struct DiscordUser* user);
+ void(DISCORD_API* on_activity_invite)(void* event_data,
+ enum EDiscordActivityActionType type,
+ struct DiscordUser* user,
+ struct DiscordActivity* activity);
+};
+
+struct IDiscordActivityManager {
+ enum EDiscordResult(DISCORD_API* register_command)(struct IDiscordActivityManager* manager,
+ const char* command);
+ enum EDiscordResult(DISCORD_API* register_steam)(struct IDiscordActivityManager* manager,
+ uint32_t steam_id);
+ void(DISCORD_API* update_activity)(struct IDiscordActivityManager* manager,
+ struct DiscordActivity* activity,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* clear_activity)(struct IDiscordActivityManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* send_request_reply)(struct IDiscordActivityManager* manager,
+ DiscordUserId user_id,
+ enum EDiscordActivityJoinRequestReply reply,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* send_invite)(struct IDiscordActivityManager* manager,
+ DiscordUserId user_id,
+ enum EDiscordActivityActionType type,
+ const char* content,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* accept_invite)(struct IDiscordActivityManager* manager,
+ DiscordUserId user_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+};
+
+struct IDiscordRelationshipEvents {
+ void(DISCORD_API* on_refresh)(void* event_data);
+ void(DISCORD_API* on_relationship_update)(void* event_data,
+ struct DiscordRelationship* relationship);
+};
+
+struct IDiscordRelationshipManager {
+ void(DISCORD_API* filter)(struct IDiscordRelationshipManager* manager,
+ void* filter_data,
+ bool(DISCORD_API* filter)(void* filter_data,
+ struct DiscordRelationship* relationship));
+ enum EDiscordResult(DISCORD_API* count)(struct IDiscordRelationshipManager* manager,
+ int32_t* count);
+ enum EDiscordResult(DISCORD_API* get)(struct IDiscordRelationshipManager* manager,
+ DiscordUserId user_id,
+ struct DiscordRelationship* relationship);
+ enum EDiscordResult(DISCORD_API* get_at)(struct IDiscordRelationshipManager* manager,
+ uint32_t index,
+ struct DiscordRelationship* relationship);
+};
+
+struct IDiscordLobbyEvents {
+ void(DISCORD_API* on_lobby_update)(void* event_data, int64_t lobby_id);
+ void(DISCORD_API* on_lobby_delete)(void* event_data, int64_t lobby_id, uint32_t reason);
+ void(DISCORD_API* on_member_connect)(void* event_data, int64_t lobby_id, int64_t user_id);
+ void(DISCORD_API* on_member_update)(void* event_data, int64_t lobby_id, int64_t user_id);
+ void(DISCORD_API* on_member_disconnect)(void* event_data, int64_t lobby_id, int64_t user_id);
+ void(DISCORD_API* on_lobby_message)(void* event_data,
+ int64_t lobby_id,
+ int64_t user_id,
+ uint8_t* data,
+ uint32_t data_length);
+ void(DISCORD_API* on_speaking)(void* event_data,
+ int64_t lobby_id,
+ int64_t user_id,
+ bool speaking);
+ void(DISCORD_API* on_network_message)(void* event_data,
+ int64_t lobby_id,
+ int64_t user_id,
+ uint8_t channel_id,
+ uint8_t* data,
+ uint32_t data_length);
+};
+
+struct IDiscordLobbyManager {
+ enum EDiscordResult(DISCORD_API* get_lobby_create_transaction)(
+ struct IDiscordLobbyManager* manager,
+ struct IDiscordLobbyTransaction** transaction);
+ enum EDiscordResult(DISCORD_API* get_lobby_update_transaction)(
+ struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ struct IDiscordLobbyTransaction** transaction);
+ enum EDiscordResult(DISCORD_API* get_member_update_transaction)(
+ struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ struct IDiscordLobbyMemberTransaction** transaction);
+ void(DISCORD_API* create_lobby)(struct IDiscordLobbyManager* manager,
+ struct IDiscordLobbyTransaction* transaction,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordLobby* lobby));
+ void(DISCORD_API* update_lobby)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ struct IDiscordLobbyTransaction* transaction,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* delete_lobby)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* connect_lobby)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordLobbySecret secret,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordLobby* lobby));
+ void(DISCORD_API* connect_lobby_with_activity_secret)(
+ struct IDiscordLobbyManager* manager,
+ DiscordLobbySecret activity_secret,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ struct DiscordLobby* lobby));
+ void(DISCORD_API* disconnect_lobby)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* get_lobby)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ struct DiscordLobby* lobby);
+ enum EDiscordResult(DISCORD_API* get_lobby_activity_secret)(
+ struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordLobbySecret* secret);
+ enum EDiscordResult(DISCORD_API* get_lobby_metadata_value)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordMetadataKey key,
+ DiscordMetadataValue* value);
+ enum EDiscordResult(DISCORD_API* get_lobby_metadata_key)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ int32_t index,
+ DiscordMetadataKey* key);
+ enum EDiscordResult(DISCORD_API* lobby_metadata_count)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ int32_t* count);
+ enum EDiscordResult(DISCORD_API* member_count)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ int32_t* count);
+ enum EDiscordResult(DISCORD_API* get_member_user_id)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ int32_t index,
+ DiscordUserId* user_id);
+ enum EDiscordResult(DISCORD_API* get_member_user)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ struct DiscordUser* user);
+ enum EDiscordResult(DISCORD_API* get_member_metadata_value)(
+ struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ DiscordMetadataKey key,
+ DiscordMetadataValue* value);
+ enum EDiscordResult(DISCORD_API* get_member_metadata_key)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ int32_t index,
+ DiscordMetadataKey* key);
+ enum EDiscordResult(DISCORD_API* member_metadata_count)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ int32_t* count);
+ void(DISCORD_API* update_member)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ struct IDiscordLobbyMemberTransaction* transaction,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* send_lobby_message)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ uint8_t* data,
+ uint32_t data_length,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* get_search_query)(struct IDiscordLobbyManager* manager,
+ struct IDiscordLobbySearchQuery** query);
+ void(DISCORD_API* search)(struct IDiscordLobbyManager* manager,
+ struct IDiscordLobbySearchQuery* query,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* lobby_count)(struct IDiscordLobbyManager* manager, int32_t* count);
+ enum EDiscordResult(DISCORD_API* get_lobby_id)(struct IDiscordLobbyManager* manager,
+ int32_t index,
+ DiscordLobbyId* lobby_id);
+ void(DISCORD_API* connect_voice)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* disconnect_voice)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* connect_network)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id);
+ enum EDiscordResult(DISCORD_API* disconnect_network)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id);
+ enum EDiscordResult(DISCORD_API* flush_network)(struct IDiscordLobbyManager* manager);
+ enum EDiscordResult(DISCORD_API* open_network_channel)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ uint8_t channel_id,
+ bool reliable);
+ enum EDiscordResult(DISCORD_API* send_network_message)(struct IDiscordLobbyManager* manager,
+ DiscordLobbyId lobby_id,
+ DiscordUserId user_id,
+ uint8_t channel_id,
+ uint8_t* data,
+ uint32_t data_length);
+};
+
+struct IDiscordNetworkEvents {
+ void(DISCORD_API* on_message)(void* event_data,
+ DiscordNetworkPeerId peer_id,
+ DiscordNetworkChannelId channel_id,
+ uint8_t* data,
+ uint32_t data_length);
+ void(DISCORD_API* on_route_update)(void* event_data, const char* route_data);
+};
+
+struct IDiscordNetworkManager {
+ /**
+ * Get the local peer ID for this process.
+ */
+ void(DISCORD_API* get_peer_id)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId* peer_id);
+ /**
+ * Send pending network messages.
+ */
+ enum EDiscordResult(DISCORD_API* flush)(struct IDiscordNetworkManager* manager);
+ /**
+ * Open a connection to a remote peer.
+ */
+ enum EDiscordResult(DISCORD_API* open_peer)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id,
+ const char* route_data);
+ /**
+ * Update the route data for a connected peer.
+ */
+ enum EDiscordResult(DISCORD_API* update_peer)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id,
+ const char* route_data);
+ /**
+ * Close the connection to a remote peer.
+ */
+ enum EDiscordResult(DISCORD_API* close_peer)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id);
+ /**
+ * Open a message channel to a connected peer.
+ */
+ enum EDiscordResult(DISCORD_API* open_channel)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id,
+ DiscordNetworkChannelId channel_id,
+ bool reliable);
+ /**
+ * Close a message channel to a connected peer.
+ */
+ enum EDiscordResult(DISCORD_API* close_channel)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id,
+ DiscordNetworkChannelId channel_id);
+ /**
+ * Send a message to a connected peer over an opened message channel.
+ */
+ enum EDiscordResult(DISCORD_API* send_message)(struct IDiscordNetworkManager* manager,
+ DiscordNetworkPeerId peer_id,
+ DiscordNetworkChannelId channel_id,
+ uint8_t* data,
+ uint32_t data_length);
+};
+
+struct IDiscordOverlayEvents {
+ void(DISCORD_API* on_toggle)(void* event_data, bool locked);
+};
+
+struct IDiscordOverlayManager {
+ void(DISCORD_API* is_enabled)(struct IDiscordOverlayManager* manager, bool* enabled);
+ void(DISCORD_API* is_locked)(struct IDiscordOverlayManager* manager, bool* locked);
+ void(DISCORD_API* set_locked)(struct IDiscordOverlayManager* manager,
+ bool locked,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* open_activity_invite)(
+ struct IDiscordOverlayManager* manager,
+ enum EDiscordActivityActionType type,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data, enum EDiscordResult result));
+ void(DISCORD_API* open_guild_invite)(struct IDiscordOverlayManager* manager,
+ const char* code,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* open_voice_settings)(struct IDiscordOverlayManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* init_drawing_dxgi)(struct IDiscordOverlayManager* manager,
+ IDXGISwapChain* swapchain,
+ bool use_message_forwarding);
+ void(DISCORD_API* on_present)(struct IDiscordOverlayManager* manager);
+ void(DISCORD_API* forward_message)(struct IDiscordOverlayManager* manager, MSG* message);
+ void(DISCORD_API* key_event)(struct IDiscordOverlayManager* manager,
+ bool down,
+ const char* key_code,
+ enum EDiscordKeyVariant variant);
+ void(DISCORD_API* char_event)(struct IDiscordOverlayManager* manager, const char* character);
+ void(DISCORD_API* mouse_button_event)(struct IDiscordOverlayManager* manager,
+ uint8_t down,
+ int32_t click_count,
+ enum EDiscordMouseButton which,
+ int32_t x,
+ int32_t y);
+ void(DISCORD_API* mouse_motion_event)(struct IDiscordOverlayManager* manager,
+ int32_t x,
+ int32_t y);
+ void(DISCORD_API* ime_commit_text)(struct IDiscordOverlayManager* manager, const char* text);
+ void(DISCORD_API* ime_set_composition)(struct IDiscordOverlayManager* manager,
+ const char* text,
+ struct DiscordImeUnderline* underlines,
+ uint32_t underlines_length,
+ int32_t from,
+ int32_t to);
+ void(DISCORD_API* ime_cancel_composition)(struct IDiscordOverlayManager* manager);
+ void(DISCORD_API* set_ime_composition_range_callback)(
+ struct IDiscordOverlayManager* manager,
+ void* on_ime_composition_range_changed_data,
+ void(DISCORD_API* on_ime_composition_range_changed)(
+ void* on_ime_composition_range_changed_data,
+ int32_t from,
+ int32_t to,
+ struct DiscordRect* bounds,
+ uint32_t bounds_length));
+ void(DISCORD_API* set_ime_selection_bounds_callback)(
+ struct IDiscordOverlayManager* manager,
+ void* on_ime_selection_bounds_changed_data,
+ void(DISCORD_API* on_ime_selection_bounds_changed)(void* on_ime_selection_bounds_changed_data,
+ struct DiscordRect anchor,
+ struct DiscordRect focus,
+ bool is_anchor_first));
+ bool(DISCORD_API* is_point_inside_click_zone)(struct IDiscordOverlayManager* manager,
+ int32_t x,
+ int32_t y);
+};
+
+typedef void* IDiscordStorageEvents;
+
+struct IDiscordStorageManager {
+ enum EDiscordResult(DISCORD_API* read)(struct IDiscordStorageManager* manager,
+ const char* name,
+ uint8_t* data,
+ uint32_t data_length,
+ uint32_t* read);
+ void(DISCORD_API* read_async)(struct IDiscordStorageManager* manager,
+ const char* name,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ uint8_t* data,
+ uint32_t data_length));
+ void(DISCORD_API* read_async_partial)(struct IDiscordStorageManager* manager,
+ const char* name,
+ uint64_t offset,
+ uint64_t length,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result,
+ uint8_t* data,
+ uint32_t data_length));
+ enum EDiscordResult(DISCORD_API* write)(struct IDiscordStorageManager* manager,
+ const char* name,
+ uint8_t* data,
+ uint32_t data_length);
+ void(DISCORD_API* write_async)(struct IDiscordStorageManager* manager,
+ const char* name,
+ uint8_t* data,
+ uint32_t data_length,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* delete_)(struct IDiscordStorageManager* manager,
+ const char* name);
+ enum EDiscordResult(DISCORD_API* exists)(struct IDiscordStorageManager* manager,
+ const char* name,
+ bool* exists);
+ void(DISCORD_API* count)(struct IDiscordStorageManager* manager, int32_t* count);
+ enum EDiscordResult(DISCORD_API* stat)(struct IDiscordStorageManager* manager,
+ const char* name,
+ struct DiscordFileStat* stat);
+ enum EDiscordResult(DISCORD_API* stat_at)(struct IDiscordStorageManager* manager,
+ int32_t index,
+ struct DiscordFileStat* stat);
+ enum EDiscordResult(DISCORD_API* get_path)(struct IDiscordStorageManager* manager,
+ DiscordPath* path);
+};
+
+struct IDiscordStoreEvents {
+ void(DISCORD_API* on_entitlement_create)(void* event_data,
+ struct DiscordEntitlement* entitlement);
+ void(DISCORD_API* on_entitlement_delete)(void* event_data,
+ struct DiscordEntitlement* entitlement);
+};
+
+struct IDiscordStoreManager {
+ void(DISCORD_API* fetch_skus)(struct IDiscordStoreManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* count_skus)(struct IDiscordStoreManager* manager, int32_t* count);
+ enum EDiscordResult(DISCORD_API* get_sku)(struct IDiscordStoreManager* manager,
+ DiscordSnowflake sku_id,
+ struct DiscordSku* sku);
+ enum EDiscordResult(DISCORD_API* get_sku_at)(struct IDiscordStoreManager* manager,
+ int32_t index,
+ struct DiscordSku* sku);
+ void(DISCORD_API* fetch_entitlements)(struct IDiscordStoreManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ void(DISCORD_API* count_entitlements)(struct IDiscordStoreManager* manager, int32_t* count);
+ enum EDiscordResult(DISCORD_API* get_entitlement)(struct IDiscordStoreManager* manager,
+ DiscordSnowflake entitlement_id,
+ struct DiscordEntitlement* entitlement);
+ enum EDiscordResult(DISCORD_API* get_entitlement_at)(struct IDiscordStoreManager* manager,
+ int32_t index,
+ struct DiscordEntitlement* entitlement);
+ enum EDiscordResult(DISCORD_API* has_sku_entitlement)(struct IDiscordStoreManager* manager,
+ DiscordSnowflake sku_id,
+ bool* has_entitlement);
+ void(DISCORD_API* start_purchase)(struct IDiscordStoreManager* manager,
+ DiscordSnowflake sku_id,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+};
+
+struct IDiscordVoiceEvents {
+ void(DISCORD_API* on_settings_update)(void* event_data);
+};
+
+struct IDiscordVoiceManager {
+ enum EDiscordResult(DISCORD_API* get_input_mode)(struct IDiscordVoiceManager* manager,
+ struct DiscordInputMode* input_mode);
+ void(DISCORD_API* set_input_mode)(struct IDiscordVoiceManager* manager,
+ struct DiscordInputMode input_mode,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data,
+ enum EDiscordResult result));
+ enum EDiscordResult(DISCORD_API* is_self_mute)(struct IDiscordVoiceManager* manager,
+ bool* mute);
+ enum EDiscordResult(DISCORD_API* set_self_mute)(struct IDiscordVoiceManager* manager,
+ bool mute);
+ enum EDiscordResult(DISCORD_API* is_self_deaf)(struct IDiscordVoiceManager* manager,
+ bool* deaf);
+ enum EDiscordResult(DISCORD_API* set_self_deaf)(struct IDiscordVoiceManager* manager,
+ bool deaf);
+ enum EDiscordResult(DISCORD_API* is_local_mute)(struct IDiscordVoiceManager* manager,
+ DiscordSnowflake user_id,
+ bool* mute);
+ enum EDiscordResult(DISCORD_API* set_local_mute)(struct IDiscordVoiceManager* manager,
+ DiscordSnowflake user_id,
+ bool mute);
+ enum EDiscordResult(DISCORD_API* get_local_volume)(struct IDiscordVoiceManager* manager,
+ DiscordSnowflake user_id,
+ uint8_t* volume);
+ enum EDiscordResult(DISCORD_API* set_local_volume)(struct IDiscordVoiceManager* manager,
+ DiscordSnowflake user_id,
+ uint8_t volume);
+};
+
+struct IDiscordAchievementEvents {
+ void(DISCORD_API* on_user_achievement_update)(void* event_data,
+ struct DiscordUserAchievement* user_achievement);
+};
+
+struct IDiscordAchievementManager {
+ void(DISCORD_API* set_user_achievement)(
+ struct IDiscordAchievementManager* manager,
+ DiscordSnowflake achievement_id,
+ uint8_t percent_complete,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data, enum EDiscordResult result));
+ void(DISCORD_API* fetch_user_achievements)(
+ struct IDiscordAchievementManager* manager,
+ void* callback_data,
+ void(DISCORD_API* callback)(void* callback_data, enum EDiscordResult result));
+ void(DISCORD_API* count_user_achievements)(struct IDiscordAchievementManager* manager,
+ int32_t* count);
+ enum EDiscordResult(DISCORD_API* get_user_achievement)(
+ struct IDiscordAchievementManager* manager,
+ DiscordSnowflake user_achievement_id,
+ struct DiscordUserAchievement* user_achievement);
+ enum EDiscordResult(DISCORD_API* get_user_achievement_at)(
+ struct IDiscordAchievementManager* manager,
+ int32_t index,
+ struct DiscordUserAchievement* user_achievement);
+};
+
+typedef void* IDiscordCoreEvents;
+
+struct IDiscordCore {
+ void(DISCORD_API* destroy)(struct IDiscordCore* core);
+ enum EDiscordResult(DISCORD_API* run_callbacks)(struct IDiscordCore* core);
+ void(DISCORD_API* set_log_hook)(struct IDiscordCore* core,
+ enum EDiscordLogLevel min_level,
+ void* hook_data,
+ void(DISCORD_API* hook)(void* hook_data,
+ enum EDiscordLogLevel level,
+ const char* message));
+ struct IDiscordApplicationManager*(DISCORD_API* get_application_manager)(
+ struct IDiscordCore* core);
+ struct IDiscordUserManager*(DISCORD_API* get_user_manager)(struct IDiscordCore* core);
+ struct IDiscordImageManager*(DISCORD_API* get_image_manager)(struct IDiscordCore* core);
+ struct IDiscordActivityManager*(DISCORD_API* get_activity_manager)(struct IDiscordCore* core);
+ struct IDiscordRelationshipManager*(DISCORD_API* get_relationship_manager)(
+ struct IDiscordCore* core);
+ struct IDiscordLobbyManager*(DISCORD_API* get_lobby_manager)(struct IDiscordCore* core);
+ struct IDiscordNetworkManager*(DISCORD_API* get_network_manager)(struct IDiscordCore* core);
+ struct IDiscordOverlayManager*(DISCORD_API* get_overlay_manager)(struct IDiscordCore* core);
+ struct IDiscordStorageManager*(DISCORD_API* get_storage_manager)(struct IDiscordCore* core);
+ struct IDiscordStoreManager*(DISCORD_API* get_store_manager)(struct IDiscordCore* core);
+ struct IDiscordVoiceManager*(DISCORD_API* get_voice_manager)(struct IDiscordCore* core);
+ struct IDiscordAchievementManager*(DISCORD_API* get_achievement_manager)(
+ struct IDiscordCore* core);
+};
+
+struct DiscordCreateParams {
+ DiscordClientId client_id;
+ uint64_t flags;
+ IDiscordCoreEvents* events;
+ void* event_data;
+ IDiscordApplicationEvents* application_events;
+ DiscordVersion application_version;
+ struct IDiscordUserEvents* user_events;
+ DiscordVersion user_version;
+ IDiscordImageEvents* image_events;
+ DiscordVersion image_version;
+ struct IDiscordActivityEvents* activity_events;
+ DiscordVersion activity_version;
+ struct IDiscordRelationshipEvents* relationship_events;
+ DiscordVersion relationship_version;
+ struct IDiscordLobbyEvents* lobby_events;
+ DiscordVersion lobby_version;
+ struct IDiscordNetworkEvents* network_events;
+ DiscordVersion network_version;
+ struct IDiscordOverlayEvents* overlay_events;
+ DiscordVersion overlay_version;
+ IDiscordStorageEvents* storage_events;
+ DiscordVersion storage_version;
+ struct IDiscordStoreEvents* store_events;
+ DiscordVersion store_version;
+ struct IDiscordVoiceEvents* voice_events;
+ DiscordVersion voice_version;
+ struct IDiscordAchievementEvents* achievement_events;
+ DiscordVersion achievement_version;
+};
+
+#ifdef __cplusplus
+inline
+#else
+static
+#endif
+ void
+ DiscordCreateParamsSetDefault(struct DiscordCreateParams* params)
+{
+ memset(params, 0, sizeof(struct DiscordCreateParams));
+ params->application_version = DISCORD_APPLICATION_MANAGER_VERSION;
+ params->user_version = DISCORD_USER_MANAGER_VERSION;
+ params->image_version = DISCORD_IMAGE_MANAGER_VERSION;
+ params->activity_version = DISCORD_ACTIVITY_MANAGER_VERSION;
+ params->relationship_version = DISCORD_RELATIONSHIP_MANAGER_VERSION;
+ params->lobby_version = DISCORD_LOBBY_MANAGER_VERSION;
+ params->network_version = DISCORD_NETWORK_MANAGER_VERSION;
+ params->overlay_version = DISCORD_OVERLAY_MANAGER_VERSION;
+ params->storage_version = DISCORD_STORAGE_MANAGER_VERSION;
+ params->store_version = DISCORD_STORE_MANAGER_VERSION;
+ params->voice_version = DISCORD_VOICE_MANAGER_VERSION;
+ params->achievement_version = DISCORD_ACHIEVEMENT_MANAGER_VERSION;
+}
+
+enum EDiscordResult DISCORD_API DiscordCreate(DiscordVersion version,
+ struct DiscordCreateParams* params,
+ struct IDiscordCore** result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lib/discord_game_sdk/cpp/image_manager.cpp b/src/lib/discord_game_sdk/cpp/image_manager.cpp
new file mode 100644
index 0000000..03b1db4
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/image_manager.cpp
@@ -0,0 +1,57 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "image_manager.h"
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+void ImageManager::Fetch(ImageHandle handle,
+ bool refresh,
+ std::function callback)
+{
+ static auto wrapper =
+ [](void* callbackData, EDiscordResult result, DiscordImageHandle handleResult) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), *reinterpret_cast(&handleResult));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->fetch(internal_,
+ *reinterpret_cast(&handle),
+ (refresh ? 1 : 0),
+ cb.release(),
+ wrapper);
+}
+
+Result ImageManager::GetDimensions(ImageHandle handle, ImageDimensions* dimensions)
+{
+ if (!dimensions) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_dimensions(internal_,
+ *reinterpret_cast(&handle),
+ reinterpret_cast(dimensions));
+ return static_cast(result);
+}
+
+Result ImageManager::GetData(ImageHandle handle, std::uint8_t* data, std::uint32_t dataLength)
+{
+ auto result = internal_->get_data(internal_,
+ *reinterpret_cast(&handle),
+ reinterpret_cast(data),
+ dataLength);
+ return static_cast(result);
+}
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/image_manager.h b/src/lib/discord_game_sdk/cpp/image_manager.h
new file mode 100644
index 0000000..b096b17
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/image_manager.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ImageManager final {
+public:
+ ~ImageManager() = default;
+
+ void Fetch(ImageHandle handle, bool refresh, std::function callback);
+ Result GetDimensions(ImageHandle handle, ImageDimensions* dimensions);
+ Result GetData(ImageHandle handle, std::uint8_t* data, std::uint32_t dataLength);
+
+private:
+ friend class Core;
+
+ ImageManager() = default;
+ ImageManager(ImageManager const& rhs) = delete;
+ ImageManager& operator=(ImageManager const& rhs) = delete;
+ ImageManager(ImageManager&& rhs) = delete;
+ ImageManager& operator=(ImageManager&& rhs) = delete;
+
+ IDiscordImageManager* internal_;
+ static IDiscordImageEvents events_;
+};
+
+} // namespace discord
diff --git a/src/lib/discord_game_sdk/cpp/lobby_manager.cpp b/src/lib/discord_game_sdk/cpp/lobby_manager.cpp
new file mode 100644
index 0000000..3a95b1a
--- /dev/null
+++ b/src/lib/discord_game_sdk/cpp/lobby_manager.cpp
@@ -0,0 +1,554 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "lobby_manager.h"
+
+#include "core.h"
+
+#include
+#include
+
+namespace discord {
+
+class LobbyEvents final {
+public:
+ static void DISCORD_CALLBACK OnLobbyUpdate(void* callbackData, int64_t lobbyId)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnLobbyUpdate(lobbyId);
+ }
+
+ static void DISCORD_CALLBACK OnLobbyDelete(void* callbackData, int64_t lobbyId, uint32_t reason)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnLobbyDelete(lobbyId, reason);
+ }
+
+ static void DISCORD_CALLBACK OnMemberConnect(void* callbackData,
+ int64_t lobbyId,
+ int64_t userId)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnMemberConnect(lobbyId, userId);
+ }
+
+ static void DISCORD_CALLBACK OnMemberUpdate(void* callbackData, int64_t lobbyId, int64_t userId)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnMemberUpdate(lobbyId, userId);
+ }
+
+ static void DISCORD_CALLBACK OnMemberDisconnect(void* callbackData,
+ int64_t lobbyId,
+ int64_t userId)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnMemberDisconnect(lobbyId, userId);
+ }
+
+ static void DISCORD_CALLBACK OnLobbyMessage(void* callbackData,
+ int64_t lobbyId,
+ int64_t userId,
+ uint8_t* data,
+ uint32_t dataLength)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnLobbyMessage(lobbyId, userId, data, dataLength);
+ }
+
+ static void DISCORD_CALLBACK OnSpeaking(void* callbackData,
+ int64_t lobbyId,
+ int64_t userId,
+ bool speaking)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnSpeaking(lobbyId, userId, (speaking != 0));
+ }
+
+ static void DISCORD_CALLBACK OnNetworkMessage(void* callbackData,
+ int64_t lobbyId,
+ int64_t userId,
+ uint8_t channelId,
+ uint8_t* data,
+ uint32_t dataLength)
+ {
+ auto* core = reinterpret_cast(callbackData);
+ if (!core) {
+ return;
+ }
+
+ auto& module = core->LobbyManager();
+ module.OnNetworkMessage(lobbyId, userId, channelId, data, dataLength);
+ }
+};
+
+IDiscordLobbyEvents LobbyManager::events_{
+ &LobbyEvents::OnLobbyUpdate,
+ &LobbyEvents::OnLobbyDelete,
+ &LobbyEvents::OnMemberConnect,
+ &LobbyEvents::OnMemberUpdate,
+ &LobbyEvents::OnMemberDisconnect,
+ &LobbyEvents::OnLobbyMessage,
+ &LobbyEvents::OnSpeaking,
+ &LobbyEvents::OnNetworkMessage,
+};
+
+Result LobbyManager::GetLobbyCreateTransaction(LobbyTransaction* transaction)
+{
+ if (!transaction) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_lobby_create_transaction(internal_, transaction->Receive());
+ return static_cast(result);
+}
+
+Result LobbyManager::GetLobbyUpdateTransaction(LobbyId lobbyId, LobbyTransaction* transaction)
+{
+ if (!transaction) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->get_lobby_update_transaction(internal_, lobbyId, transaction->Receive());
+ return static_cast(result);
+}
+
+Result LobbyManager::GetMemberUpdateTransaction(LobbyId lobbyId,
+ UserId userId,
+ LobbyMemberTransaction* transaction)
+{
+ if (!transaction) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->get_member_update_transaction(internal_, lobbyId, userId, transaction->Receive());
+ return static_cast(result);
+}
+
+void LobbyManager::CreateLobby(LobbyTransaction const& transaction,
+ std::function callback)
+{
+ static auto wrapper =
+ [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), *reinterpret_cast(lobby));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->create_lobby(
+ internal_, const_cast(transaction).Internal(), cb.release(), wrapper);
+}
+
+void LobbyManager::UpdateLobby(LobbyId lobbyId,
+ LobbyTransaction const& transaction,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->update_lobby(internal_,
+ lobbyId,
+ const_cast(transaction).Internal(),
+ cb.release(),
+ wrapper);
+}
+
+void LobbyManager::DeleteLobby(LobbyId lobbyId, std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->delete_lobby(internal_, lobbyId, cb.release(), wrapper);
+}
+
+void LobbyManager::ConnectLobby(LobbyId lobbyId,
+ LobbySecret secret,
+ std::function callback)
+{
+ static auto wrapper =
+ [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), *reinterpret_cast(lobby));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->connect_lobby(internal_, lobbyId, const_cast(secret), cb.release(), wrapper);
+}
+
+void LobbyManager::ConnectLobbyWithActivitySecret(
+ LobbySecret activitySecret,
+ std::function callback)
+{
+ static auto wrapper =
+ [](void* callbackData, EDiscordResult result, DiscordLobby* lobby) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result), *reinterpret_cast(lobby));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->connect_lobby_with_activity_secret(
+ internal_, const_cast(activitySecret), cb.release(), wrapper);
+}
+
+void LobbyManager::DisconnectLobby(LobbyId lobbyId, std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->disconnect_lobby(internal_, lobbyId, cb.release(), wrapper);
+}
+
+Result LobbyManager::GetLobby(LobbyId lobbyId, Lobby* lobby)
+{
+ if (!lobby) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_lobby(internal_, lobbyId, reinterpret_cast(lobby));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetLobbyActivitySecret(LobbyId lobbyId, char secret[128])
+{
+ if (!secret) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_lobby_activity_secret(
+ internal_, lobbyId, reinterpret_cast(secret));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetLobbyMetadataValue(LobbyId lobbyId, MetadataKey key, char value[4096])
+{
+ if (!value) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_lobby_metadata_value(
+ internal_, lobbyId, const_cast(key), reinterpret_cast(value));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetLobbyMetadataKey(LobbyId lobbyId, std::int32_t index, char key[256])
+{
+ if (!key) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_lobby_metadata_key(
+ internal_, lobbyId, index, reinterpret_cast(key));
+ return static_cast(result);
+}
+
+Result LobbyManager::LobbyMetadataCount(LobbyId lobbyId, std::int32_t* count)
+{
+ if (!count) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->lobby_metadata_count(internal_, lobbyId, reinterpret_cast(count));
+ return static_cast(result);
+}
+
+Result LobbyManager::MemberCount(LobbyId lobbyId, std::int32_t* count)
+{
+ if (!count) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->member_count(internal_, lobbyId, reinterpret_cast(count));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetMemberUserId(LobbyId lobbyId, std::int32_t index, UserId* userId)
+{
+ if (!userId) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->get_member_user_id(internal_, lobbyId, index, reinterpret_cast(userId));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetMemberUser(LobbyId lobbyId, UserId userId, User* user)
+{
+ if (!user) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->get_member_user(internal_, lobbyId, userId, reinterpret_cast(user));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetMemberMetadataValue(LobbyId lobbyId,
+ UserId userId,
+ MetadataKey key,
+ char value[4096])
+{
+ if (!value) {
+ return Result::InternalError;
+ }
+
+ auto result =
+ internal_->get_member_metadata_value(internal_,
+ lobbyId,
+ userId,
+ const_cast(key),
+ reinterpret_cast(value));
+ return static_cast(result);
+}
+
+Result LobbyManager::GetMemberMetadataKey(LobbyId lobbyId,
+ UserId userId,
+ std::int32_t index,
+ char key[256])
+{
+ if (!key) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_member_metadata_key(
+ internal_, lobbyId, userId, index, reinterpret_cast(key));
+ return static_cast(result);
+}
+
+Result LobbyManager::MemberMetadataCount(LobbyId lobbyId, UserId userId, std::int32_t* count)
+{
+ if (!count) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->member_metadata_count(
+ internal_, lobbyId, userId, reinterpret_cast(count));
+ return static_cast(result);
+}
+
+void LobbyManager::UpdateMember(LobbyId lobbyId,
+ UserId userId,
+ LobbyMemberTransaction const& transaction,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->update_member(internal_,
+ lobbyId,
+ userId,
+ const_cast(transaction).Internal(),
+ cb.release(),
+ wrapper);
+}
+
+void LobbyManager::SendLobbyMessage(LobbyId lobbyId,
+ std::uint8_t* data,
+ std::uint32_t dataLength,
+ std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr> cb(
+ reinterpret_cast*>(callbackData));
+ if (!cb || !(*cb)) {
+ return;
+ }
+ (*cb)(static_cast(result));
+ };
+ std::unique_ptr> cb{};
+ cb.reset(new std::function(std::move(callback)));
+ internal_->send_lobby_message(
+ internal_, lobbyId, reinterpret_cast(data), dataLength, cb.release(), wrapper);
+}
+
+Result LobbyManager::GetSearchQuery(LobbySearchQuery* query)
+{
+ if (!query) {
+ return Result::InternalError;
+ }
+
+ auto result = internal_->get_search_query(internal_, query->Receive());
+ return static_cast(result);
+}
+
+void LobbyManager::Search(LobbySearchQuery const& query, std::function callback)
+{
+ static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+ std::unique_ptr 
-**Discord Game SDK support for GDScript in Godot Engine 4.2. with the easiest code pattern!**
+