mirrors/mkxp-z
1
0
Fork 0
mirror of https://github.com/mkxp-z/mkxp-z.git synced 2025-04-21 21:52:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove Discord support

Browse source 
I'm a moron. GPL, yo.
This commit is contained in:
Roza 2020-03-02 00:42:04 -05:00
parent 9deed44f77
commit da9b1eeb71
16 changed files with 2 additions and 680 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
binding/binding-mri.cpp
View file

@ -92,10 +92,6 @@ void fileIntBindingInit();
void MiniFFIBindingInit();
#endif
#ifdef HAVE_DISCORDSDK
void DiscordBindingInit();
#endif
#ifdef HAVE_STEAMWORKS
void CUSLBindingInit();
#endif
@ -146,10 +142,6 @@ static void mriBindingInit() {
MiniFFIBindingInit();
#endif
#ifdef HAVE_DISCORDSDK
DiscordBindingInit();
#endif
#ifdef HAVE_STEAMWORKS
CUSLBindingInit();
#endif

11
binding/binding-types.h
View file

@ -57,15 +57,4 @@ DECL_TYPE(MiniFFI);
#define MiniFFIType "MiniFFI"
#endif
#ifdef HAVE_DISCORDSDK
#if RAPI_FULL > 187
DECL_TYPE(DCActivity);
#else
#define DiscordActivityType "DCActivity"
#endif
#endif
#endif // BINDINGTYPES_H

280
binding/discord-binding.cpp
View file

@ -1,280 +0,0 @@
#include <discord_game_sdk.h>
#include "binding-types.h"
#include "binding-util.h"
#include "discordstate.h"
#include "sharedstate.h"
// NYI
void discordResultCb(void *callback_data, enum EDiscordResult result) {}
#if RAPI_FULL > 187
DEF_TYPE_CUSTOMFREE(DCActivity, free);
#else
DEF_ALLOCFUNC_CUSTOMFREE(DCActivity, free);
#endif
RB_METHOD(DiscordConnected) {
RB_UNUSED_PARAM;
// Checking to make sure callbacks have actually fired
return rb_bool_new(shState->discord().userId());
}
RB_METHOD(DiscordGetUsername) {
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userName().c_str());
}
RB_METHOD(DiscordGetDiscriminator) {
RB_UNUSED_PARAM;
return rb_str_new_cstr(shState->discord().userDiscrim().c_str());
}
RB_METHOD(DiscordGetUserId) {
RB_UNUSED_PARAM;
return LL2NUM(shState->discord().userId());
}
void bitmapInitProps(Bitmap *b, VALUE self);
RB_METHOD(DiscordGetUserAvatar) {
RB_UNUSED_PARAM;
int size = 32;
rb_get_args(argc, argv, "|i", &size RB_ARG_END);
Bitmap *result = shState->discord().userAvatar(size);
if (!result)
return RUBY_Qnil;
VALUE ret = wrapObject(result, BitmapType);
bitmapInitProps(result, ret);
return ret;
}
RB_METHOD(DiscordActivitySend) {
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
DiscordActivity *activity = getPrivateData<DiscordActivity>(self);
if (am)
am->update_activity(am, activity, 0, discordResultCb);
return Qnil;
}
RB_METHOD(DiscordActivityInitialize) {
RB_UNUSED_PARAM;
DiscordActivity *activity = ALLOC(DiscordActivity);
setPrivateData(self, activity);
memset(activity, 0, sizeof(DiscordActivity));
activity->type = DiscordActivityType_Playing;
if (rb_block_given_p()) {
rb_yield(self);
DiscordActivitySend(0, 0, self);
};
return self;
}
RB_METHOD(DiscordActivityInitializeCopy) {
RB_UNUSED_PARAM;
rb_check_argc(argc, 1);
VALUE origObj = argv[0];
if (!OBJ_INIT_COPY(self, origObj))
return self;
DiscordActivity *orig = getPrivateData<DiscordActivity>(origObj);
DiscordActivity *s = ALLOC(DiscordActivity);
memcpy(s, orig, sizeof(DiscordActivity));
setPrivateData(self, s);
return self;
}
RB_METHOD(DiscordActivityClear) {
RB_UNUSED_PARAM;
IDiscordActivityManager *am = shState->discord().activityManager();
if (am)
am->clear_activity(am, 0, discordResultCb);
return Qnil;
}
#define DEF_DCPROP_ACTPARTYSZ(n) \
RB_METHOD(DiscordActivityGetParty##n) { \
RB_UNUSED_PARAM; \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
return INT2NUM(p->party.size.n); \
} \
RB_METHOD(DiscordActivitySetParty##n) { \
RB_UNUSED_PARAM; \
int num; \
rb_get_args(argc, argv, "i", &num); \
DiscordActivity *p = getPrivateData<DiscordActivity>(self); \
p->party.size.n = num; \
return INT2NUM(num); \
}
DEF_DCPROP_ACTPARTYSZ(current_size);
DEF_DCPROP_ACTPARTYSZ(max_size);
#define DEF_DCPROP_S(basename, propname, maxsz) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_S_SUB(basename, subname, propname, maxsz) \
RB_METHOD(Discord##basename##Get##subname##_##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_str_new_cstr(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_UNUSED_PARAM; \
VALUE str; \
rb_scan_args(argc, argv, "1", &str); \
SafeStringValue(str); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
strncpy(p->subname.propname, RSTRING_PTR(str), maxsz); \
return str; \
}
#define DEF_DCPROP_I(basename, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_I_SUB(basename, subname, propname, convtype, cast) \
RB_METHOD(Discord##basename##Get##subname##_##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return convtype##2NUM(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##subname##_##propname) { \
RB_UNUSED_PARAM; \
VALUE num; \
rb_scan_args(argc, argv, "1", &num); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = (cast)NUM2##convtype(num); \
return num; \
}
#define DEF_DCPROP_B(basename, propname) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->propname = b; \
return rb_bool_new(b); \
}
#define DEF_DCPROP_B_SUB(basename, propname, subname) \
RB_METHOD(Discord##basename##Get##propname) { \
RB_UNUSED_PARAM; \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
return rb_bool_new(p->subname.propname); \
} \
RB_METHOD(Discord##basename##Set##propname) { \
RB_UNUSED_PARAM; \
bool b; \
rb_get_args(argc, argv, "b", &b RB_ARG_END); \
Discord##basename *p = getPrivateData<Discord##basename>(self); \
p->subname.propname = b; \
return rb_bool_new(b); \
}
DEF_DCPROP_S(Activity, state, 128);
DEF_DCPROP_S(Activity, details, 128);
DEF_DCPROP_S_SUB(Activity, assets, large_image, 128);
DEF_DCPROP_S_SUB(Activity, assets, large_text, 128);
DEF_DCPROP_S_SUB(Activity, assets, small_image, 128);
DEF_DCPROP_S_SUB(Activity, assets, small_text, 128);
DEF_DCPROP_S_SUB(Activity, party, id, 128);
DEF_DCPROP_I(Activity, type, INT, EDiscordActivityType);
DEF_DCPROP_I_SUB(Activity, timestamps, start, LL, DiscordTimestamp);
DEF_DCPROP_I_SUB(Activity, timestamps, end, LL, DiscordTimestamp);
DEF_DCPROP_B(Activity, instance);
#define BIND_DCPROP(basename, b, f) \
_rb_define_method(activityClass, b, Discord##basename##Get##f); \
_rb_define_method(activityClass, b "=", Discord##basename##Set##f);
void DiscordBindingInit() {
VALUE mod = rb_define_module("Discord");
_rb_define_module_function(mod, "connected?", DiscordConnected);
_rb_define_module_function(mod, "user_name", DiscordGetUsername);
_rb_define_module_function(mod, "user_discriminator",
DiscordGetDiscriminator);
_rb_define_module_function(mod, "user_id", DiscordGetUserId);
_rb_define_module_function(mod, "user_avatar", DiscordGetUserAvatar);
VALUE activityClass = rb_define_class_under(mod, "Activity", rb_cObject);
#if RAPI_FULL > 187
rb_define_alloc_func(activityClass, classAllocate<&DCActivityType>);
#else
rb_define_alloc_func(activityClass, DCActivityAllocate);
#endif
_rb_define_method(activityClass, "initialize", DiscordActivityInitialize);
_rb_define_method(activityClass, "initialize_copy",
DiscordActivityInitializeCopy);
rb_define_class_method(activityClass, "clear", DiscordActivityClear);
_rb_define_method(activityClass, "send", DiscordActivitySend);
BIND_DCPROP(Activity, "state", state);
BIND_DCPROP(Activity, "details", details);
BIND_DCPROP(Activity, "large_image", assets_large_image);
BIND_DCPROP(Activity, "large_text", assets_large_text);
BIND_DCPROP(Activity, "small_image", assets_small_image);
BIND_DCPROP(Activity, "small_text", assets_small_text);
BIND_DCPROP(Activity, "party_id", party_id);
BIND_DCPROP(Activity, "party_currentsize", Partycurrent_size);
BIND_DCPROP(Activity, "party_maxsize", Partymax_size);
BIND_DCPROP(Activity, "type", type);
BIND_DCPROP(Activity, "start_time", timestamps_start);
BIND_DCPROP(Activity, "end_time", timestamps_end);
BIND_DCPROP(Activity, "instance", instance);
}

4
binding/meson.build
View file

@ -37,10 +37,6 @@ binding_source = [files(
'tilemapvx-binding.cpp'
)]
if discord == true
binding_source += files('discord-binding.cpp')
endif
if steamworks == true
binding_source += files('cusl-binding.cpp')
endif

15
meson.build
View file

@ -26,21 +26,6 @@ win64 = (sizeof['void*'] != sizeof['long'])
# Ext libs
# ====================
# DISCORD
discord = false
discord_libpath = get_option('discord_sdk_path')
if discord_libpath != ''
discordlib = compilers['cpp'].find_library('discord_game_sdk', required: false, dirs: [discord_libpath+'/lib/x86', discord_libpath+'/lib/x86_64'])
if discordlib.found() == true
global_include_dirs += include_directories(discord_libpath+'/c')
global_args += ['-I@0@/c'.format(discord_libpath), '-DHAVE_DISCORDSDK']
global_dependencies += discordlib
discord = true
endif
endif
# STEAMWORKS
steamworks = false

3
meson_options.txt
View file

@ -18,7 +18,6 @@ option('workdir_current', type: 'boolean', value: false, description: 'Keep curr
option('static_executable', type: 'boolean', value: false, description: 'Build a static executable (Windows-only)')
option('independent_appimage', type: 'boolean', value: true, description: 'Set current directory to the original location of the AppImage when contained within one')
option('discord_sdk_path', type: 'string', value: '', description: 'Path to Discord GameSDK')
option('steamworks_path', type: 'string', value: '', description: 'Path to Steamworks SDK')
option('steamworks_path', type: 'string', value: '', description: 'Path to Steamshim')
option('steam_appid', type: 'string', value: '0', description: 'Steam application ID.')
option('appimagekit_path', type: 'string', value: '', description: 'Path to AppImageKit, used for building AppImages')

8
mkxp.json.sample
View file

@ -334,14 +334,6 @@
//
// "execName": "Game",
// The Discord Client ID for your application. If left undefined,
// mkxp-z's Client ID is used by default.
// Only has an effect if mkxp-z is built with Discord support.
//
// "discordClientId": 1234567890,
// The game's Steam AppID.
//
// If the ID was specified at build time, this setting is

1
nativefiledialog Submodule

@ -0,0 +1 @@
Subproject commit 67345b80ebb429ecc2aeda94c478b3bcc5f7888e

8
src/config.h
View file

@ -26,10 +26,6 @@
#include <string>
#include <vector>
#ifdef HAVE_DISCORDSDK
#include <discord_game_sdk.h>
#endif
struct Config {
int rgssVersion;
@ -87,10 +83,6 @@ struct Config {
bool useScriptNames;
#ifdef HAVE_DISCORDSDK
DiscordClientId discordClientId;
#endif
#ifdef HAVE_STEAMWORKS
unsigned int steamAppId;
#endif

11
src/config.mm
View file

@ -9,11 +9,6 @@
#import "sdl-util.h"
#import "util.h"
#ifdef HAVE_DISCORDSDK
#import "discordstate.h"
#import <discord_game_sdk.h>
#endif
OFString *prefPath(const char *org, const char *app) {
char *path = SDL_GetPrefPath(org, app);
if (!path)
@ -83,9 +78,6 @@ void Config::read(int argc, char *argv[]) {
@"customScript" : @"",
@"pathCache" : @true,
@"encryptedGraphics" : @false,
#ifdef HAVE_DISCORDSDK
@"discordClientId" : @DEFAULT_CLIENT_ID,
#endif
#ifdef HAVE_STEAMWORKS
@"steamAppId" : @0,
#endif
@ -189,9 +181,6 @@ void Config::read(int argc, char *argv[]) {
glVersion.major = 3;
glVersion.minor = 3;
}
#ifdef HAVE_DISCORDSDK
SET_OPT(discordClientId, longLongValue);
#endif
#ifdef HAVE_STEAMWORKS
SET_OPT(steamAppId, uInt32Value);
#endif

263
src/discordstate.cpp
View file

@ -1,263 +0,0 @@
#include <discord_game_sdk.h>
#include <time.h>
#include "eventthread.h"
#include "discordstate.h"
#include "exception.h"
#include "debugwriter.h"
#include "bitmap.h"
#include "config.h"
void defaultActivityCb(void *callback_data, enum EDiscordResult result)
{
}
struct Application {
struct IDiscordCore* core;
struct IDiscordImageManager* images;
struct IDiscordUserManager* users;
struct IDiscordActivityManager* activities;
DiscordUserId user_id;
};
struct DiscordStatePrivate
{
RGSSThreadData *threadData;
IDiscordCore *core;
Application app;
IDiscordActivityEvents activityEvents;
IDiscordUserEvents userEvents;
DiscordCreateParams params;
DiscordUser currentUser;
DiscordActivity defaultActivity;
bool discordInstalled;
bool connected;
bool userPresent;
long long startTime;
DiscordStatePrivate()
: discordInstalled(false),
connected(false),
userPresent(false),
startTime(time(0))
{};
~DiscordStatePrivate()
{
//if (core) core->destroy(core);
}
};
void onCurrentUserUpdateCb(void *event_data)
{
DiscordStatePrivate *p = (DiscordStatePrivate*)event_data;
p->app.users->get_current_user(p->app.users, &p->currentUser);
p->userPresent = true;
}
void onActivityJoinCb(void *event_data, const char *secret)
{
}
void onActivitySpectateCb(void *event_data, const char *secret)
{
}
void onActivityJoinRequestCb(void *event_data, struct DiscordUser *user)
{
}
void onActivityInviteRequestCb(void *event_data, enum EDiscordActivityActionType type, struct DiscordUser *user, struct DiscordActivity *activity)
{
}
void discordLogHook(void *hook_data, enum EDiscordLogLevel level, const char *message)
{
Debug() << "Discord:" << message;
}
int discordTryConnect(DiscordStatePrivate *p)
{
int rc = DiscordCreate(DISCORD_VERSION, &p->params, &p->core);
if (rc != DiscordResult_NotInstalled)
p->discordInstalled = true;
if (rc != DiscordResult_Ok)
return rc;
p->core->set_log_hook(p->core, DiscordLogLevel_Error, (void*)p, discordLogHook);
p->app.activities = p->core->get_activity_manager(p->core);
p->app.users = p->core->get_user_manager(p->core);
p->app.images = p->core->get_image_manager(p->core);
p->connected = true;
memset(&p->defaultActivity, 0, sizeof(DiscordActivity));
#ifndef MARIN
strncpy((char*)&p->defaultActivity.details, p->threadData->config.game.title.c_str(), 128);
p->defaultActivity.timestamps.start = p->startTime;
if (p->params.client_id == DEFAULT_CLIENT_ID)
{
strncpy((char*)&p->defaultActivity.assets.large_image, "default", 128);
strncpy((char*)&p->defaultActivity.assets.large_text, "mkxp-z", 128);
}
#else
p->defaultActivity.timestamps.start = p->startTime;
if (p->params.client_id == DEFAULT_CLIENT_ID)
{
strncpy((char*)&p->defaultActivity.assets.large_image, "default", 128);
strncpy((char*)&p->defaultActivity.assets.large_text, "MK", 128);
}
#endif
p->app.activities->update_activity(p->app.activities, &p->defaultActivity, 0, defaultActivityCb);
return rc;
}
DiscordState::DiscordState(RGSSThreadData *rtData)
{
p = new DiscordStatePrivate();
p->threadData = rtData;
memset(&p->app, 0, sizeof(Application));
DiscordCreateParamsSetDefault(&p->params);
memset(&p->activityEvents, 0, sizeof(IDiscordActivityEvents));
memset(&p->userEvents, 0, sizeof(IDiscordUserEvents));
p->params.client_id = rtData->config.discordClientId;
p->params.flags = DiscordCreateFlags_NoRequireDiscord;
p->params.event_data = (void*)p;
p->activityEvents.on_activity_join = onActivityJoinCb;
p->activityEvents.on_activity_spectate = onActivitySpectateCb;
p->activityEvents.on_activity_join_request = onActivityJoinRequestCb;
p->activityEvents.on_activity_invite = onActivityInviteRequestCb;
p->params.activity_events = &p->activityEvents;
p->userEvents.on_current_user_update = onCurrentUserUpdateCb;
p->params.user_events = &p->userEvents;
discordTryConnect(p);
}
DiscordState::~DiscordState()
{
delete p;
}
IDiscordActivityManager *DiscordState::activityManager()
{
return p->app.activities;
}
IDiscordUserManager *DiscordState::userManager()
{
return p->app.users;
}
IDiscordImageManager *DiscordState::imageManager()
{
return p->app.images;
}
int DiscordState::update()
{
if (!p->discordInstalled) return DiscordResult_NotInstalled;
if (p->connected)
{
int rc = p->core->run_callbacks(p->core);
if (rc == DiscordResult_NotRunning)
{
p->connected = false;
memset(&p->currentUser, 0, sizeof(DiscordUser));
memset(&p->app, 0, sizeof(Application));
p->userPresent = false;
return rc;
}
return rc;
}
if (time(0) % 5 != 0) return -1;
return discordTryConnect(p);
}
bool DiscordState::isConnected()
{
return (p->connected && p->userPresent);
}
std::string DiscordState::userName()
{
std::string ret; ret.clear();
if (p->userPresent) ret = p->currentUser.username;
return ret;
}
std::string DiscordState::userDiscrim()
{
std::string ret; ret.clear();
if (p->userPresent) ret = p->currentUser.discriminator;
return ret;
}
DiscordUserId DiscordState::userId()
{
return (p->userPresent) ? p->currentUser.id : 0;
}
typedef struct { DiscordStatePrivate *pri; Bitmap *bmp; } AvatarCbData;
Bitmap *DiscordState::getAvatar(DiscordUserId userId, int size)
{
size = clamp(size, 32, 256);
while ((size & (size-1)) != 0) {
size++;
}
if (!isConnected()) return 0;
AvatarCbData *cbData = new AvatarCbData;
Bitmap *ret = new Bitmap(size, size);
cbData->bmp = ret;
cbData->pri = p;
DiscordImageHandle handle{};
handle.id = userId;
handle.size = size;
p->app.images->fetch(p->app.images, handle, true, cbData,
[](void *callback_data, enum EDiscordResult result, struct DiscordImageHandle handle_result){
if (result == DiscordResult_Ok)
{
AvatarCbData *data = (AvatarCbData*)callback_data;
if (data->bmp->isDisposed()) return;
int sz = data->bmp->width()*data->bmp->height()*4;
uint8_t *buf = new uint8_t[sz];
data->pri->app.images->get_data(data->pri->app.images, handle_result, buf, sz);
data->bmp->replaceRaw(buf, sz);
delete[] buf;
delete data;
}
});
return ret;
}
Bitmap *DiscordState::userAvatar(int size)
{
return (p->userPresent) ? getAvatar(p->currentUser.id, size) : 0;
}

37
src/discordstate.h
View file

@ -1,37 +0,0 @@
#pragma once
#include <discord_game_sdk.h>
#include <string>
#include "bitmap.h"
#ifdef MARIN
#define DEFAULT_CLIENT_ID 624284820201013248
#else
#define DEFAULT_CLIENT_ID 618672572183347211
#endif
struct DiscordStatePrivate;
class DiscordState
{
public:
DiscordState(RGSSThreadData *rtData);
~DiscordState();
IDiscordActivityManager *activityManager();
IDiscordUserManager *userManager();
IDiscordImageManager *imageManager();
int update();
bool isConnected();
std::string userName();
std::string userDiscrim();
DiscordUserId userId();
Bitmap *getAvatar(DiscordUserId userId, int size);
Bitmap *userAvatar(int size);
private:
DiscordStatePrivate *p;
};

8
src/graphics.cpp
View file

@ -44,10 +44,6 @@
#include <SDL_timer.h>
#include <SDL_video.h>
#ifdef HAVE_DISCORDSDK
#include "discordstate.h"
#endif
#ifdef HAVE_STEAMWORKS
#include "steam/steam_api.h"
#endif
@ -590,10 +586,6 @@ void Graphics::update() {
p->checkShutDownReset();
p->checkSyncLock();
#ifdef HAVE_DISCORDSDK
shState->discord().update();
#endif
#ifdef HAVE_STEAMWORKS
if (SteamAPI_IsSteamRunning())
SteamAPI_RunCallbacks();

4
src/meson.build
View file

@ -106,8 +106,4 @@ if get_option('use_fakeapi') == true and miniffi == true
main_source += files('fake-api.mm')
endif
if discord == true
main_source += files('discordstate.cpp')
endif
global_sources += main_source

15
src/sharedstate.cpp
View file

@ -38,10 +38,6 @@
#include "exception.h"
#include "sharedmidistate.h"
#ifdef HAVE_DISCORDSDK
#include "discordstate.h"
#endif
#include <unistd.h>
#include <stdio.h>
#include <string>
@ -90,10 +86,6 @@ struct SharedStatePrivate
SharedFontState fontState;
Font *defaultFont;
#ifdef HAVE_DISCORDSDK
DiscordState discord;
#endif
TEX::ID globalTex;
int globalTexW, globalTexH;
bool globalTexDirty;
@ -114,9 +106,6 @@ struct SharedStatePrivate
rtData(*threadData),
config(threadData->config),
midiState(threadData->config),
#ifdef HAVE_DISCORDSDK
discord(threadData),
#endif
graphics(threadData),
input(*threadData),
audio(*threadData),
@ -246,10 +235,6 @@ GSATT(Quad&, gpQuad)
GSATT(SharedFontState&, fontState)
GSATT(SharedMidiState&, midiState)
#ifdef HAVE_DISCORDSDK
GSATT(DiscordState&, discord)
#endif
void SharedState::setBindingData(void *data)
{
p->bindingData = data;

6
src/sharedstate.h
View file

@ -46,9 +46,6 @@ class GLState;
class TexPool;
class Font;
class SharedFontState;
#ifdef HAVE_DISCORDSDK
class DiscordState;
#endif
struct GlobalIBO;
struct Config;
struct Vec2i;
@ -82,9 +79,6 @@ struct SharedState
SharedFontState &fontState() const;
Font &defaultFont() const;
#ifdef HAVE_DISCORDSDK
DiscordState &discord() const;
#endif
SharedMidiState &midiState() const;
sigc::signal<void> prepareDraw;