archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-16 03:38:38 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Some functions added

Browse source
This commit is contained in:
Nekotekina 2015-01-30 20:19:11 +03:00
parent 6cab4d7100
commit bdd458d2ae
10 changed files with 2946 additions and 174 deletions
Download patch file Download diff file Expand all files Collapse all files

242
rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp
View file

@ -1,9 +1,213 @@
#include "stdafx.h" #include "stdafx.h"
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpBasic; extern psv_log_base sceNpBasic;
enum SceNpBasicFriendListEventType : s32
{
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendListEventType eventType, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<void> userdata)> SceNpBasicFriendListEventHandler;
enum SceNpBasicFriendOnlineStatusEventType : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicFriendOnlineStatus : s32
{
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
};
typedef vm::psv::ptr<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::psv::ptr<const SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::psv::ptr<void> userdata)> SceNpBasicFriendOnlineStatusEventHandler;
enum SceNpBasicBlockListEventType : s32
{
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
};
typedef vm::psv::ptr<void(SceNpBasicBlockListEventType eventType, vm::psv::ptr<const SceNpId> playerId, vm::psv::ptr<void> userdata)> SceNpBasicBlockListEventHandler;
enum SceNpBasicFriendGamePresenceEventType : s32
{
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
};
enum SceNpBasicInGamePresenceType
{
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
};
struct SceNpBasicInGamePresence
{
u32 sdkVersion;
SceNpBasicInGamePresenceType type;
char status[192];
u8 data[128];
u32 dataSize;
};
struct SceNpBasicGamePresence
{
u32 size;
char title[128];
SceNpBasicInGamePresence inGamePresence;
};
typedef vm::psv::ptr<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<const SceNpBasicGamePresence> presence, vm::psv::ptr<void> userdata)> SceNpBasicFriendGamePresenceEventHandler;
struct SceNpBasicInGameDataMessage
{
u8 data[128];
u32 dataSize;
};
typedef vm::psv::ptr<void(vm::psv::ptr<const SceNpId> from, vm::psv::ptr<const SceNpBasicInGameDataMessage> message, vm::psv::ptr<void> userdata)> SceNpBasicInGameDataMessageEventHandler;
struct SceNpBasicEventHandlers
{
u32 sdkVersion;
SceNpBasicFriendListEventHandler friendListEventHandler;
SceNpBasicFriendOnlineStatusEventHandler friendOnlineStatusEventHandler;
SceNpBasicBlockListEventHandler blockListEventHandler;
SceNpBasicFriendGamePresenceEventHandler friendGamePresenceEventHandler;
SceNpBasicInGameDataMessageEventHandler inGameDataMessageEventHandler;
};
struct SceNpBasicPlaySessionLogDescription
{
char text[512];
};
struct SceNpBasicPlaySessionLog
{
u64 date;
SceNpId withWhom;
SceNpCommunicationId commId;
char title[128];
SceNpBasicPlaySessionLogDescription description;
};
enum SceNpBasicPlaySessionLogType : s32
{
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
};
s32 sceNpBasicInit(vm::psv::ptr<void> opt)
{
throw __FUNCTION__;
}
s32 sceNpBasicTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceNpBasicUnregisterHandler(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpBasicCheckCallback()
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
{
throw __FUNCTION__;
}
s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
{
throw __FUNCTION__;
}
s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
{
throw __FUNCTION__;
}
s32 sceNpBasicUnsetInGamePresence()
{
throw __FUNCTION__;
}
s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
{
throw __FUNCTION__;
}
s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
{
throw __FUNCTION__;
}
s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name)
psv_log_base sceNpBasic("SceNpBasic", []() psv_log_base sceNpBasic("SceNpBasic", []()
@ -12,22 +216,22 @@ psv_log_base sceNpBasic("SceNpBasic", []()
sceNpBasic.on_unload = nullptr; sceNpBasic.on_unload = nullptr;
sceNpBasic.on_stop = nullptr; sceNpBasic.on_stop = nullptr;
//REG_FUNC(0xEFB91A99, sceNpBasicInit); REG_FUNC(0xEFB91A99, sceNpBasicInit);
//REG_FUNC(0x389BCB3B, sceNpBasicTerm); REG_FUNC(0x389BCB3B, sceNpBasicTerm);
//REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler); REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler);
//REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler); REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler);
//REG_FUNC(0x20146AEC, sceNpBasicCheckCallback); REG_FUNC(0x20146AEC, sceNpBasicCheckCallback);
//REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus); REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus);
//REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend); REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend);
//REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount); REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount);
//REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries); REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries);
//REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount); REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount);
//REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries); REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries);
//REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked); REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked);
//REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence); REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence);
//REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence); REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence);
//REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage); REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage);
//REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog); REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog);
//REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize); REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize);
//REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog); REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog);
}); });

79
rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp
View file

@ -2,7 +2,62 @@
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
extern psv_log_base sceNpCommon; #include "sceNpCommon.h"
s32 sceNpAuthInit()
{
throw __FUNCTION__;
}
s32 sceNpAuthTerm()
{
throw __FUNCTION__;
}
s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
{
throw __FUNCTION__;
}
s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
{
throw __FUNCTION__;
}
s32 sceNpAuthGetEntitlementById(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<const char> entId, vm::psv::ptr<SceNpEntitlement> ent)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2)
{
throw __FUNCTION__;
}
s32 sceNpCmpNpIdInOrder(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2, vm::psv::ptr<s32> order)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name)
@ -12,15 +67,15 @@ psv_log_base sceNpCommon("SceNpCommon", []()
sceNpCommon.on_unload = nullptr; sceNpCommon.on_unload = nullptr;
sceNpCommon.on_stop = nullptr; sceNpCommon.on_stop = nullptr;
//REG_FUNC(0x441D8B4E, sceNpAuthInit); REG_FUNC(0x441D8B4E, sceNpAuthInit);
//REG_FUNC(0x6093B689, sceNpAuthTerm); REG_FUNC(0x6093B689, sceNpAuthTerm);
//REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest); REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest);
//REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest); REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest);
//REG_FUNC(0xE2582575, sceNpAuthAbortRequest); REG_FUNC(0xE2582575, sceNpAuthAbortRequest);
//REG_FUNC(0x59608D1C, sceNpAuthGetTicket); REG_FUNC(0x59608D1C, sceNpAuthGetTicket);
//REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam); REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam);
//REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList); REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList);
//REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById); REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById);
//REG_FUNC(0xFB8D82E5, sceNpCmpNpId); REG_FUNC(0xFB8D82E5, sceNpCmpNpId);
//REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder); REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder);
}); });

154
rpcs3/Emu/ARMv7/Modules/sceNpCommon.h Normal file
View file

@ -0,0 +1,154 @@
#pragma once
enum SceNpServiceState : s32
{
SCE_NP_SERVICE_STATE_UNKNOWN = 0,
SCE_NP_SERVICE_STATE_SIGNED_OUT,
SCE_NP_SERVICE_STATE_SIGNED_IN,
SCE_NP_SERVICE_STATE_ONLINE
};
struct SceNpCommunicationId
{
char data[9];
char term;
u8 num;
char dummy;
};
struct SceNpCommunicationPassphrase
{
u8 data[128];
};
struct SceNpCommunicationSignature
{
u8 data[160];
};
struct SceNpCommunicationConfig
{
vm::psv::ptr<const SceNpCommunicationId> commId;
vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
};
struct SceNpCountryCode
{
char data[2];
char term;
char padding[1];
};
struct SceNpOnlineId
{
char data[16];
char term;
char dummy[3];
};
struct SceNpId
{
SceNpOnlineId handle;
u8 opt[8];
u8 reserved[8];
};
struct SceNpAvatarUrl
{
char data[127];
char term;
};
struct SceNpUserInformation
{
SceNpId userId;
SceNpAvatarUrl icon;
u8 reserved[52];
};
struct SceNpMyLanguages
{
s32 language1;
s32 language2;
s32 language3;
u8 padding[4];
};
struct SceNpAvatarImage
{
u8 data[200 * 1024];
u32 size;
u8 reserved[12];
};
enum SceNpAvatarSizeType : s32
{
SCE_NP_AVATAR_SIZE_LARGE,
SCE_NP_AVATAR_SIZE_MIDDLE,
SCE_NP_AVATAR_SIZE_SMALL
};
struct SceNpAboutMe
{
char data[64];
};
typedef s32 SceNpAuthRequestId;
typedef u64 SceNpTime;
struct SceNpDate
{
u16 year;
u8 month;
u8 day;
};
union SceNpTicketParam
{
s32 i32;
s64 i64;
u32 u32;
u64 u64;
SceNpDate date;
u8 data[256];
};
struct SceNpTicketVersion
{
u16 major;
u16 minor;
};
typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
struct SceNpAuthRequestParameter
{
u32 size;
SceNpTicketVersion version;
vm::psv::ptr<const char> serviceId;
vm::psv::ptr<const void> cookie;
u32 cookieSize;
vm::psv::ptr<const char> entitlementId;
u32 consumedCount;
SceNpAuthCallback ticketCb;
vm::psv::ptr<void> cbArg;
};
struct SceNpEntitlementId
{
u8 data[32];
};
struct SceNpEntitlement
{
SceNpEntitlementId id;
SceNpTime createdDate;
SceNpTime expireDate;
u32 type;
s32 remainingCount;
u32 consumedCount;
char padding[4];
};
extern psv_log_base sceNpCommon;

79
rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp
View file

@ -2,8 +2,67 @@
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpManager; extern psv_log_base sceNpManager;
struct SceNpOptParam
{
u32 optParamSize;
};
typedef vm::psv::ptr<void(SceNpServiceState state, vm::psv::ptr<void> userdata)> SceNpServiceStateCallback;
s32 sceNpInit(vm::psv::ptr<const SceNpCommunicationConfig> commConf, vm::psv::ptr<SceNpOptParam> opt)
{
throw __FUNCTION__;
}
s32 sceNpTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpCheckCallback()
{
throw __FUNCTION__;
}
s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
{
throw __FUNCTION__;
}
s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
{
throw __FUNCTION__;
}
s32 sceNpUnregisterServiceStateCallback()
{
throw __FUNCTION__;
}
s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
{
throw __FUNCTION__;
}
s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name)
psv_log_base sceNpManager("SceNpManager", []() psv_log_base sceNpManager("SceNpManager", []()
@ -12,14 +71,14 @@ psv_log_base sceNpManager("SceNpManager", []()
sceNpManager.on_unload = nullptr; sceNpManager.on_unload = nullptr;
sceNpManager.on_stop = nullptr; sceNpManager.on_stop = nullptr;
//REG_FUNC(0x04D9F484, sceNpInit); REG_FUNC(0x04D9F484, sceNpInit);
//REG_FUNC(0x19E40AE1, sceNpTerm); REG_FUNC(0x19E40AE1, sceNpTerm);
//REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId); REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId);
//REG_FUNC(0x54060DF6, sceNpGetServiceState); REG_FUNC(0x54060DF6, sceNpGetServiceState);
//REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback); REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback);
//REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback); REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback);
//REG_FUNC(0x3B0AE9A9, sceNpCheckCallback); REG_FUNC(0x3B0AE9A9, sceNpCheckCallback);
//REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion); REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion);
//REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag); REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag);
//REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag); REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag);
}); });

1360
rpcs3/Emu/ARMv7/Modules/sceNpMatching.cpp
View file

File diff suppressed because it is too large Load diff

387
rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp
View file

@ -2,8 +2,337 @@
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpScore; extern psv_log_base sceNpScore;
typedef u32 SceNpScoreBoardId;
typedef s64 SceNpScoreValue;
typedef u32 SceNpScoreRankNumber;
typedef s32 SceNpScorePcId;
struct SceNpScoreGameInfo
{
u32 infoSize;
u8 pad[4];
u8 data[192];
};
struct SceNpScoreComment
{
char utf8Comment[64];
};
struct SceNpScoreRankData
{
SceNpId npId;
u8 reserved[49];
u8 pad0[3];
SceNpScorePcId pcId;
SceNpScoreRankNumber serialRank;
SceNpScoreRankNumber rank;
SceNpScoreRankNumber highestRank;
s32 hasGameData;
u8 pad1[4];
SceNpScoreValue scoreValue;
u64 recordDate;
};
struct SceNpScorePlayerRankData
{
s32 hasData;
u8 pad0[4];
SceNpScoreRankData rankData;
};
struct SceNpScoreBoardInfo
{
u32 rankLimit;
u32 updateMode;
u32 sortMode;
u32 uploadNumLimit;
u32 uploadSizeLimit;
};
struct SceNpScoreNpIdPcId
{
SceNpId npId;
SceNpScorePcId pcId;
u8 pad[4];
};
s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpScoreCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpCommunicationPassphrase> passphrase, vm::psv::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
s32 sceNpScoreDeleteTitleCtx(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpScoreCreateRequest(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpScoreDeleteRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpScoreAbortRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, s32 sendTimeout, s32 recvTimeout)
{
throw __FUNCTION__;
}
s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScore(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameData(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameData(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRange(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdPcId(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordScoreAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
vm::psv::ptr<const SceNpScoreComment> scoreComment,
vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
vm::psv::ptr<const u64> compareDate,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreRecordGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreValue score,
u32 totalSize,
u32 sendSize,
vm::psv::ptr<const void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetGameDataAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<u32> totalSize,
u32 recvSize,
vm::psv::ptr<void> data,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpId> npIdArray,
u32 npIdArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByRangeAsync(
s32 reqId,
SceNpScoreBoardId boardId,
SceNpScoreRankNumber startSerialRank,
vm::psv::ptr<SceNpScoreRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreGetRankingByNpIdPcIdAsync(
s32 reqId,
SceNpScoreBoardId boardId,
vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
u32 idArraySize,
vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
u32 rankArraySize,
vm::psv::ptr<SceNpScoreComment> commentArray,
u32 commentArraySize,
vm::psv::ptr<SceNpScoreGameInfo> infoArray,
u32 infoArraySize,
u32 arrayNum,
vm::psv::ptr<u64> lastSortDate,
vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name)
psv_log_base sceNpScore("SceNpScore", []() psv_log_base sceNpScore("SceNpScore", []()
@ -12,33 +341,33 @@ psv_log_base sceNpScore("SceNpScore", []()
sceNpScore.on_unload = nullptr; sceNpScore.on_unload = nullptr;
sceNpScore.on_stop = nullptr; sceNpScore.on_stop = nullptr;
//REG_FUNC(0x0433069F, sceNpScoreInit); REG_FUNC(0x0433069F, sceNpScoreInit);
//REG_FUNC(0x2050F98F, sceNpScoreTerm); REG_FUNC(0x2050F98F, sceNpScoreTerm);
//REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx); REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx);
//REG_FUNC(0xD30D1993, sceNpScoreCreateRequest); REG_FUNC(0xD30D1993, sceNpScoreCreateRequest);
//REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx); REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx);
//REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest); REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest);
//REG_FUNC(0x320C0277, sceNpScoreRecordScore); REG_FUNC(0x320C0277, sceNpScoreRecordScore);
//REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync); REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync);
//REG_FUNC(0xC2862B67, sceNpScoreRecordGameData); REG_FUNC(0xC2862B67, sceNpScoreRecordGameData);
//REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync); REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync);
//REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData); REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData);
//REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync); REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync);
//REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange); REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange);
//REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync); REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync);
//REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId); REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId);
//REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync); REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync);
//REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId); REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId);
//REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync); REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync);
//REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest); REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest);
//REG_FUNC(0x31733BF3, sceNpScoreWaitAsync); REG_FUNC(0x31733BF3, sceNpScoreWaitAsync);
//REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync); REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync);
//REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo); REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo);
//REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync); REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync);
//REG_FUNC(0xA0C94D46, sceNpScoreCensorComment); REG_FUNC(0xA0C94D46, sceNpScoreCensorComment);
//REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync); REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync);
//REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment); REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment);
//REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync); REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync);
//REG_FUNC(0x5EF44841, sceNpScoreSetTimeout); REG_FUNC(0x5EF44841, sceNpScoreSetTimeout);
//REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId); REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId);
}); });

172
rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp
View file

@ -2,8 +2,140 @@
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "sceNpCommon.h"
extern psv_log_base sceNpUtility; extern psv_log_base sceNpUtility;
struct SceNpBandwidthTestResult
{
double uploadBps;
double downloadBps;
s32 result;
char padding[4];
};
s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupTerm(ARMv7Context&)
{
throw __FUNCTION__;
}
s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
{
throw __FUNCTION__;
}
s32 sceNpLookupDeleteTitleCtx(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpLookupCreateRequest(s32 titleCtxId)
{
throw __FUNCTION__;
}
s32 sceNpLookupDeleteRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpLookupAbortRequest(s32 reqId)
{
throw __FUNCTION__;
}
s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 connTimeout, u32 sendTimeout, u32 recvTimeout)
{
throw __FUNCTION__;
}
s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupPollAsync(s32 reqId, vm::psv::ptr<s32> result)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpId(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupUserProfile(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupUserProfileAsync(
s32 reqId,
s32 avatarSizeType,
vm::psv::ptr<const SceNpId> npId,
vm::psv::ptr<SceNpUserInformation> userInfo,
vm::psv::ptr<SceNpAboutMe> aboutMe,
vm::psv::ptr<SceNpMyLanguages> languages,
vm::psv::ptr<SceNpCountryCode> countryCode,
vm::psv::ptr<void> avatarImageData,
u32 avatarImageDataMaxSize,
vm::psv::ptr<u32> avatarImageDataSize,
vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImage(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestInitStart(s32 initPriority, s32 cpuAffinityMask)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestGetStatus()
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
{
throw __FUNCTION__;
}
s32 sceNpBandwidthTestAbort()
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name)
psv_log_base sceNpUtility("SceNpUtility", []() psv_log_base sceNpUtility("SceNpUtility", []()
@ -12,24 +144,24 @@ psv_log_base sceNpUtility("SceNpUtility", []()
sceNpUtility.on_unload = nullptr; sceNpUtility.on_unload = nullptr;
sceNpUtility.on_stop = nullptr; sceNpUtility.on_stop = nullptr;
//REG_FUNC(0x9246A673, sceNpLookupInit); REG_FUNC(0x9246A673, sceNpLookupInit);
//REG_FUNC(0x0158B61B, sceNpLookupTerm); REG_FUNC(0x0158B61B, sceNpLookupTerm);
//REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx); REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx);
//REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx); REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx);
//REG_FUNC(0x9E42E922, sceNpLookupCreateRequest); REG_FUNC(0x9E42E922, sceNpLookupCreateRequest);
//REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest); REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest);
//REG_FUNC(0x027587C4, sceNpLookupAbortRequest); REG_FUNC(0x027587C4, sceNpLookupAbortRequest);
//REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout); REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout);
//REG_FUNC(0xCF956F23, sceNpLookupWaitAsync); REG_FUNC(0xCF956F23, sceNpLookupWaitAsync);
//REG_FUNC(0xFCDBA234, sceNpLookupPollAsync); REG_FUNC(0xFCDBA234, sceNpLookupPollAsync);
//REG_FUNC(0xB1A14879, sceNpLookupNpId); REG_FUNC(0xB1A14879, sceNpLookupNpId);
//REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync); REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync);
//REG_FUNC(0x6A1BF429, sceNpLookupUserProfile); REG_FUNC(0x6A1BF429, sceNpLookupUserProfile);
//REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync); REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync);
//REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage); REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage);
//REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync); REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync);
//REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart); REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart);
//REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus); REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus);
//REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown); REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown);
//REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort); REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort);
}); });

643
rpcs3/Emu/ARMv7/Modules/sceUlt.cpp
View file

@ -2,8 +2,545 @@
#include "Emu/System.h" #include "Emu/System.h"
#include "Emu/ARMv7/PSVFuncList.h" #include "Emu/ARMv7/PSVFuncList.h"
#include "sceLibKernel.h"
extern psv_log_base sceUlt; extern psv_log_base sceUlt;
#define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " size")
struct _SceUltOptParamHeader
{
s64 reserved[2];
};
struct SceUltWaitingQueueResourcePoolOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltWaitingQueueResourcePoolOptParam, 128);
struct SceUltWaitingQueueResourcePool
{
u64 reserved[32];
};
CHECK_SIZE(SceUltWaitingQueueResourcePool, 256);
struct SceUltQueueDataResourcePoolOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltQueueDataResourcePoolOptParam, 128);
struct SceUltQueueDataResourcePool
{
u64 reserved[32];
};
CHECK_SIZE(SceUltQueueDataResourcePool, 256);
struct SceUltMutexOptParam
{
_SceUltOptParamHeader header;
u32 attribute;
u32 reserved_0;
u64 reserved[13];
};
CHECK_SIZE(SceUltMutexOptParam, 128);
struct SceUltMutex
{
u64 reserved[32];
};
CHECK_SIZE(SceUltMutex, 256);
struct SceUltConditionVariableOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltConditionVariableOptParam, 128);
struct SceUltConditionVariable
{
u64 reserved[32];
};
CHECK_SIZE(SceUltConditionVariable, 256);
struct SceUltQueueOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltQueueOptParam, 128);
struct SceUltQueue
{
u64 reserved[32];
};
CHECK_SIZE(SceUltQueue, 256);
struct SceUltReaderWriterLockOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltReaderWriterLockOptParam, 128);
struct SceUltReaderWriterLock
{
u64 reserved[32];
};
CHECK_SIZE(SceUltReaderWriterLock, 256);
struct SceUltSemaphoreOptParam
{
_SceUltOptParamHeader header;
u64 reserved[14];
};
CHECK_SIZE(SceUltSemaphoreOptParam, 128);
struct SceUltSemaphore
{
u64 reserved[32];
};
CHECK_SIZE(SceUltSemaphore, 256);
struct SceUltUlthreadRuntimeOptParam
{
_SceUltOptParamHeader header;
u32 oneShotThreadStackSize;
s32 workerThreadPriority;
u32 workerThreadCpuAffinityMask;
u32 workerThreadAttr;
vm::psv::ptr<const SceKernelThreadOptParam> workerThreadOptParam;
u64 reserved[11];
};
CHECK_SIZE(SceUltUlthreadRuntimeOptParam, 128);
struct SceUltUlthreadRuntime
{
u64 reserved[128];
};
CHECK_SIZE(SceUltUlthreadRuntime, 1024);
struct SceUltUlthreadOptParam
{
_SceUltOptParamHeader header;
u32 attribute;
u32 reserved_0;
u64 reserved[13];
};
CHECK_SIZE(SceUltUlthreadOptParam, 128);
struct SceUltUlthread
{
u64 reserved[32];
};
CHECK_SIZE(SceUltUlthread, 256);
typedef vm::psv::ptr<s32(u32 arg)> SceUltUlthreadEntry;
// Functions
s32 _sceUltWaitingQueueResourcePoolOptParamInitialize(vm::psv::ptr<SceUltWaitingQueueResourcePoolOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObjects)
{
throw __FUNCTION__;
}
s32 _sceUltWaitingQueueResourcePoolCreate(
vm::psv::ptr<SceUltWaitingQueueResourcePool> pool,
vm::psv::ptr<const char> name,
u32 numThreads,
u32 numSyncObjects,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltWaitingQueueResourcePoolOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltWaitingQueueResourcePoolDestroy(vm::psv::ptr<SceUltWaitingQueueResourcePool> pool)
{
throw __FUNCTION__;
}
s32 _sceUltQueueDataResourcePoolOptParamInitialize(vm::psv::ptr<SceUltQueueDataResourcePoolOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 numQueueObject)
{
throw __FUNCTION__;
}
s32 _sceUltQueueDataResourcePoolCreate(
vm::psv::ptr<SceUltQueueDataResourcePool> pool,
vm::psv::ptr<const char> name,
u32 numData,
u32 dataSize,
u32 numQueueObject,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltQueueDataResourcePoolOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltQueueDataResourcePoolDestroy(vm::psv::ptr<SceUltQueueDataResourcePool> pool)
{
throw __FUNCTION__;
}
u32 sceUltMutexGetStandaloneWorkAreaSize(u32 waitingQueueDepth, u32 numConditionVariable)
{
throw __FUNCTION__;
}
s32 _sceUltMutexOptParamInitialize(vm::psv::ptr<SceUltMutexOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltMutexCreate(
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltMutexOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltMutexCreateStandalone(
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const char> name,
u32 numConditionVariable,
u32 maxNumThreads,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltMutexOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltMutexLock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexTryLock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexUnlock(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 sceUltMutexDestroy(vm::psv::ptr<SceUltMutex> mutex)
{
throw __FUNCTION__;
}
s32 _sceUltConditionVariableOptParamInitialize(vm::psv::ptr<SceUltConditionVariableOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltConditionVariableCreate(
vm::psv::ptr<SceUltConditionVariable> conditionVariable,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltMutex> mutex,
vm::psv::ptr<const SceUltConditionVariableOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableSignal(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableSignalAll(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableWait(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 sceUltConditionVariableDestroy(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
{
throw __FUNCTION__;
}
s32 _sceUltQueueOptParamInitialize(vm::psv::ptr<SceUltQueueOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
u32 dataSize,
u32 waitingQueueLength)
{
throw __FUNCTION__;
}
s32 _sceUltQueueCreate(
vm::psv::ptr<SceUltQueue> queue,
vm::psv::ptr<const char> _name,
u32 dataSize,
vm::psv::ptr<SceUltWaitingQueueResourcePool> resourcePool,
vm::psv::ptr<SceUltQueueDataResourcePool> queueResourcePool,
vm::psv::ptr<const SceUltQueueOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltQueueCreateStandalone(
vm::psv::ptr<SceUltQueue> queue,
vm::psv::ptr<const char> name,
u32 queueDepth,
u32 dataSize,
u32 waitingQueueLength,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltQueueOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltQueuePush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueTryPush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueuePop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueTryPop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
{
throw __FUNCTION__;
}
s32 sceUltQueueDestroy(vm::psv::ptr<SceUltQueue> queue)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockOptParamInitialize(vm::psv::ptr<SceUltReaderWriterLockOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockCreate(
vm::psv::ptr<SceUltReaderWriterLock> rwlock,
vm::psv::ptr<const char> name,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltReaderWriterLockCreateStandalone(
vm::psv::ptr<SceUltReaderWriterLock> rwlock,
vm::psv::ptr<const char> name,
u32 waitingQueueDepth,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltReaderWriterLockGetStandaloneWorkAreaSize(u32 waitingQueueDepth)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockTryLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockUnlockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockTryLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockUnlockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 sceUltReaderWriterLockDestroy(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
{
throw __FUNCTION__;
}
s32 _sceUltSemaphoreOptParamInitialize(vm::psv::ptr<SceUltSemaphoreOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltSemaphoreCreate(
vm::psv::ptr<SceUltSemaphore> semaphore,
vm::psv::ptr<const char> name,
s32 numInitialResource,
vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
vm::psv::ptr<const SceUltSemaphoreOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreTryAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreRelease(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
{
throw __FUNCTION__;
}
s32 sceUltSemaphoreDestroy(vm::psv::ptr<SceUltSemaphore> semaphore)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadRuntimeOptParamInitialize(vm::psv::ptr<SceUltUlthreadRuntimeOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadRuntimeCreate(
vm::psv::ptr<SceUltUlthreadRuntime> runtime,
vm::psv::ptr<const char> name,
u32 numMaxUlthread,
u32 numWorkerThread,
vm::psv::ptr<void> workArea,
vm::psv::ptr<const SceUltUlthreadRuntimeOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadRuntimeDestroy(vm::psv::ptr<SceUltUlthreadRuntime> runtime)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadOptParamInitialize(vm::psv::ptr<SceUltUlthreadOptParam> optParam, u32 buildVersion)
{
throw __FUNCTION__;
}
s32 _sceUltUlthreadCreate(
vm::psv::ptr<SceUltUlthread> ulthread,
vm::psv::ptr<const char> name,
SceUltUlthreadEntry entry,
u32 arg,
vm::psv::ptr<void> context,
u32 sizeContext,
vm::psv::ptr<SceUltUlthreadRuntime> runtime,
vm::psv::ptr<const SceUltUlthreadOptParam> optParam,
u32 buildVersion)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadYield()
{
throw __FUNCTION__;
}
s32 sceUltUlthreadExit(s32 status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadTryJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
{
throw __FUNCTION__;
}
s32 sceUltUlthreadGetSelf(vm::psv::ptr<vm::psv::ptr<SceUltUlthread>> ulthread)
{
throw __FUNCTION__;
}
#define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name) #define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name)
psv_log_base sceUlt("SceUlt", []() psv_log_base sceUlt("SceUlt", []()
@ -12,57 +549,57 @@ psv_log_base sceUlt("SceUlt", []()
sceUlt.on_unload = nullptr; sceUlt.on_unload = nullptr;
sceUlt.on_stop = nullptr; sceUlt.on_stop = nullptr;
//REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize); REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize);
//REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize); REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize);
//REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate); REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate);
//REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy); REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy);
//REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize); REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize);
//REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize); REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize);
//REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate); REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate);
//REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy); REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy);
//REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize); REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize);
//REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate); REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate);
//REG_FUNC(0x001EAC8A, sceUltMutexLock); REG_FUNC(0x001EAC8A, sceUltMutexLock);
//REG_FUNC(0xE5936A69, sceUltMutexTryLock); REG_FUNC(0xE5936A69, sceUltMutexTryLock);
//REG_FUNC(0x897C9097, sceUltMutexUnlock); REG_FUNC(0x897C9097, sceUltMutexUnlock);
//REG_FUNC(0xEEBD9052, sceUltMutexDestroy); REG_FUNC(0xEEBD9052, sceUltMutexDestroy);
//REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize); REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize);
//REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate); REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate);
//REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal); REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal);
//REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll); REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll);
//REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait); REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait);
//REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy); REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy);
//REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize); REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize);
//REG_FUNC(0x14DA1BB4, _sceUltQueueCreate); REG_FUNC(0x14DA1BB4, _sceUltQueueCreate);
//REG_FUNC(0xA7E78FF9, sceUltQueuePush); REG_FUNC(0xA7E78FF9, sceUltQueuePush);
//REG_FUNC(0x6D356B29, sceUltQueueTryPush); REG_FUNC(0x6D356B29, sceUltQueueTryPush);
//REG_FUNC(0x1AD58A53, sceUltQueuePop); REG_FUNC(0x1AD58A53, sceUltQueuePop);
//REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop); REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop);
//REG_FUNC(0xF37862DE, sceUltQueueDestroy); REG_FUNC(0xF37862DE, sceUltQueueDestroy);
//REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize); REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize);
//REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate); REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate);
//REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead); REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead);
//REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead); REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead);
//REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead); REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead);
//REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite); REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite);
//REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite); REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite);
//REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite); REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite);
//REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy); REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy);
//REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize); REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize);
//REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate); REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate);
//REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire); REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire);
//REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire); REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire);
//REG_FUNC(0x65376E2D, sceUltSemaphoreRelease); REG_FUNC(0x65376E2D, sceUltSemaphoreRelease);
//REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy); REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy);
//REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize); REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize);
//REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize); REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize);
//REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate); REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate);
//REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy); REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy);
//REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize); REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize);
//REG_FUNC(0xB1290375, _sceUltUlthreadCreate); REG_FUNC(0xB1290375, _sceUltUlthreadCreate);
//REG_FUNC(0xCAD57BAD, sceUltUlthreadYield); REG_FUNC(0xCAD57BAD, sceUltUlthreadYield);
//REG_FUNC(0x1E401DF8, sceUltUlthreadExit); REG_FUNC(0x1E401DF8, sceUltUlthreadExit);
//REG_FUNC(0x63483381, sceUltUlthreadJoin); REG_FUNC(0x63483381, sceUltUlthreadJoin);
//REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin); REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin);
//REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf); REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf);
}); });

1
rpcs3/emucore.vcxproj
View file

@ -340,6 +340,7 @@
<ClInclude Include="Emu\ARMv7\Modules\sceIme.h" /> <ClInclude Include="Emu\ARMv7\Modules\sceIme.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" /> <ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceNet.h" /> <ClInclude Include="Emu\ARMv7\Modules\sceNet.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceSsl.h" /> <ClInclude Include="Emu\ARMv7\Modules\sceSsl.h" />
<ClInclude Include="Emu\ARMv7\Modules\sceTouch.h" /> <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h" />
<ClInclude Include="Emu\ARMv7\PSVFuncList.h" /> <ClInclude Include="Emu\ARMv7\PSVFuncList.h" />

3
rpcs3/emucore.vcxproj.filters
View file

@ -1501,5 +1501,8 @@
<ClInclude Include="Emu\ARMv7\Modules\sceTouch.h"> <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h">
<Filter>Emu\CPU\ARMv7\Modules</Filter> <Filter>Emu\CPU\ARMv7\Modules</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h">
<Filter>Emu\CPU\ARMv7\Modules</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>