mirror of
https://github.com/copyrighttxt/watrbx-game-engine.git
synced 2026-09-04 20:57:49 +00:00
715 lines
23 KiB
C++
715 lines
23 KiB
C++
/* Copyright 2003-2006 ROBLOX Corporation, All Rights Reserved */
|
|
|
|
#pragma once
|
|
|
|
#include "gui/GUI.h"
|
|
#include "V8DataModel/DataModelJob.h"
|
|
#include "V8DataModel/PhysicsInstructions.h"
|
|
#include "V8DataModel/GuiBuilder.h"
|
|
#include "v8datamodel/Game.h"
|
|
#include "V8DataModel/InputObject.h"
|
|
#include "V8Tree/Instance.h"
|
|
#include "V8Tree/Service.h"
|
|
#include "Util/GameMode.h"
|
|
#include "Util/Runstateowner.h"
|
|
#include "Util/InsertMode.h"
|
|
#include "Util/Region2.h"
|
|
#include "Util/IMetric.h"
|
|
#include "Util/HeapValue.h"
|
|
#include "Security/FuzzyTokens.h"
|
|
#include <boost/array.hpp>
|
|
#include <boost/optional.hpp>
|
|
#include <boost/unordered_set.hpp>
|
|
|
|
class XmlElement;
|
|
|
|
namespace RBX {
|
|
|
|
class Fonts;
|
|
class GuiRoot;
|
|
class GuiItem;
|
|
class ContentProvider;
|
|
class Hopper;
|
|
class PlayerHopper;
|
|
class StarterPackService;
|
|
class StarterGuiService;
|
|
class StarterPlayerService;
|
|
class CoreGuiService;
|
|
class Workspace;
|
|
class Adorn;
|
|
class Region2;
|
|
class UserInputService;
|
|
class ContextActionService;
|
|
class GuiObject;
|
|
|
|
extern const char *const sDataModel;
|
|
|
|
static inline void robloxScriptModifiedCheck(RBX::Security::Permissions perm)
|
|
{
|
|
#ifndef RBX_STUDIO_BUILD
|
|
RBX::Security::Context::current().requirePermission(RBX::Security::RobloxScript);
|
|
if (perm != RBX::Security::RobloxScript)
|
|
{
|
|
throw std::runtime_error("");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
class DataModel
|
|
: public IMetric
|
|
, public IDataState
|
|
, public VerbContainer
|
|
, public Diagnostics::Countable<DataModel>
|
|
, public DataModelArbiter
|
|
, public DescribedNonCreatable<DataModel, ServiceProvider, sDataModel>
|
|
{
|
|
public:
|
|
|
|
enum CreatorType
|
|
{
|
|
CREATOR_USER = 0,
|
|
CREATOR_GROUP = 1
|
|
};
|
|
//genre == GENRE_ALL || (allowedGenres & (1 << (genre-1))) != 0;
|
|
enum Genre
|
|
{
|
|
GENRE_ALL = 0,
|
|
GENRE_TOWN_AND_CITY = 1,
|
|
GENRE_FANTASY = 2,
|
|
GENRE_SCI_FI = 3,
|
|
GENRE_NINJA = 4,
|
|
GENRE_SCARY = 5,
|
|
GENRE_PIRATE = 6,
|
|
GENRE_ADVENTURE = 7,
|
|
GENRE_SPORTS = 8,
|
|
GENRE_FUNNY = 9,
|
|
GENRE_WILD_WEST = 10,
|
|
GENRE_WAR = 11,
|
|
GENRE_SKATE_PARK = 12,
|
|
GENRE_TUTORIAL = 13,
|
|
};
|
|
enum GearGenreSetting
|
|
{
|
|
GEAR_GENRE_ALL = 0,
|
|
GEAR_GENRE_MATCH = 1,
|
|
};
|
|
|
|
//(allowedGearTypes & (1 << gearType)) != 0;
|
|
enum GearType
|
|
{
|
|
GEAR_TYPE_MELEE_WEAPONS = 0,
|
|
GEAR_TYPE_RANGED_WEAPONS = 1,
|
|
GEAR_TYPE_EXPLOSIVES = 2,
|
|
GEAR_TYPE_POWER_UPS = 3,
|
|
GEAR_TYPE_NAVIGATION_ENHANCERS = 4,
|
|
GEAR_TYPE_MUSICAL_INSTRUMENTS = 5,
|
|
GEAR_TYPE_SOCIAL_ITEMS = 6,
|
|
GEAR_TYPE_BUILDING_TOOLS = 7,
|
|
GEAR_TYPE_PERSONAL_TRANSPORT = 8,
|
|
};
|
|
|
|
enum RequestShutdownResult
|
|
{
|
|
CLOSE_NOT_HANDLED = 0,
|
|
CLOSE_REQUEST_HANDLED = 1,
|
|
CLOSE_LOCAL_SAVE = 2,
|
|
CLOSE_NO_SAVE_NEEDED = 3,
|
|
};
|
|
|
|
void postCreate();
|
|
|
|
static rbx::atomic<int> count;
|
|
std::auto_ptr<RBX::Verb> lockVerb;
|
|
|
|
rbx::signal<void()> screenshotSignal;
|
|
rbx::signal<void(const std::string &)> screenshotReadySignal;
|
|
rbx::signal<void(bool)> screenshotUploadSignal;
|
|
|
|
rbx::signal<void(bool)> graphicsQualityShortcutSignal;
|
|
|
|
rbx::signal<void()> allowedGearTypeChanged;
|
|
rbx::signal<void(const shared_ptr<InputObject>& event)> InputObjectProcessed;
|
|
|
|
rbx::signal<void()> workspaceLoadedSignal;
|
|
rbx::signal<void()> gameLoadedSignal;
|
|
|
|
Genre getGenre() const { return genre; }
|
|
void setGenre(Genre genre);
|
|
|
|
GearGenreSetting getGearGenreSetting() const { return gearGenreSetting; }
|
|
void setGear(GearGenreSetting gearGenreSetting, int allowedGearTypes);
|
|
|
|
void setVIPServerId(std::string value);
|
|
std::string getVIPServerId() const;
|
|
void setVIPServerOwnerId(int value);
|
|
int getVIPServerOwnerId() const;
|
|
|
|
void setRenderGuisActive(bool value) { renderGuisActive = value; }
|
|
|
|
bool isGearTypeAllowed(GearType gearType);
|
|
|
|
static void setLoaderFunction(boost::function<void(RBX::DataModel*)> loader) { loaderFunc = loader; }
|
|
|
|
void loadPlugins();
|
|
|
|
struct MouseStats
|
|
{
|
|
RunningAverageTimeInterval<> osMouseMove;
|
|
RunningAverageTimeInterval<> mouseMove;
|
|
|
|
MouseStats()
|
|
:osMouseMove(0.5)
|
|
,mouseMove(0.5)
|
|
{
|
|
}
|
|
};
|
|
MouseStats mouseStats;
|
|
|
|
bool getSharedSuppressNavKeys() const { return (game ? game->getSuppressNavKeys() : suppressNavKeys); }
|
|
void setGame(RBX::Game* newGame) { game = newGame; }
|
|
|
|
bool getIsShuttingDown() { return isShuttingDown; }
|
|
void setIsShuttingDown(bool value) { isShuttingDown = value; }
|
|
|
|
private:
|
|
typedef DescribedNonCreatable<DataModel, ServiceProvider, sDataModel> Super;
|
|
|
|
ThrottlingHelper savePlaceThrottle;
|
|
|
|
// TODO: turn some of these into non-essential Services? Or at least, see if we can
|
|
// get rid of the direct references here...
|
|
|
|
shared_ptr<CoreGuiService> coreGuiService;
|
|
shared_ptr<ContextActionService> contextActionService;
|
|
|
|
shared_ptr<StarterPackService> starterPackService;
|
|
shared_ptr<StarterGuiService> starterGuiService;
|
|
shared_ptr<StarterPlayerService> starterPlayerService;
|
|
shared_ptr<RunService> runService;
|
|
shared_ptr<UserInputService> userInputService;
|
|
shared_ptr<Workspace> workspace;
|
|
|
|
shared_ptr<GuiRoot> guiRoot;
|
|
|
|
bool forceArrowCursor;
|
|
virtual GuiResponse processAccelerators(const shared_ptr<InputObject>& event);
|
|
virtual GuiResponse processCameraCommands(const shared_ptr<InputObject>& event);
|
|
|
|
std::string uiMessage; // short term hack - will improve
|
|
int drawId; // flag to debug extra draws
|
|
IMetric* tempMetric; // for output in ctrl-F1 message - only used during render call
|
|
IMetric* networkMetric; // for output in ctrl-F1 message - only used during render call
|
|
|
|
volatile bool dirty; // For IDataState
|
|
bool isInitialized; // Block gui events when closing - per crash reports on 12/05/07
|
|
bool isContentLoaded;
|
|
volatile bool isShuttingDown;
|
|
|
|
boost::mutex hackFlagSetMutex;
|
|
boost::unordered_set<unsigned int> hackFlagSet;
|
|
|
|
PhysicsInstructions physicsInstructions;
|
|
|
|
int numPartInstances;
|
|
int numInstances;
|
|
int shutdownRequestedCount;
|
|
int physicsStepID;
|
|
int totalWorldSteps;
|
|
bool isGameLoaded;
|
|
|
|
bool forceR15;
|
|
bool canRequestUniverseInfo;
|
|
bool universeDataRequested;
|
|
void requestGameStartInfo();
|
|
|
|
bool isPersonalServer;
|
|
|
|
bool networkStatsWindowsOn;
|
|
|
|
bool renderGuisActive;
|
|
|
|
RBX::Game* game;
|
|
|
|
Time dataModelInitTime;
|
|
|
|
TextureProxyBaseRef renderCursor;
|
|
|
|
void initializeContents(bool startHeartbeat);
|
|
|
|
void doDataModelStep(float timeInterval);
|
|
bool updatePhysicsInstructions(Network::GameMode gameMode);
|
|
bool onlyJobsLeftForThisArbiterAreGenericJobs();
|
|
|
|
static boost::function<void(RBX::DataModel*)> loaderFunc;
|
|
|
|
bool areCoreScriptsLoaded;
|
|
|
|
std::auto_ptr<std::istream> loadAssetIdIntoStream(int assetID);
|
|
public:
|
|
static bool BlockingDataModelShutdown;
|
|
|
|
static unsigned int perfStats; // another bitmask used to record detected hacks
|
|
|
|
std::string jobId;
|
|
|
|
static unsigned int sendStats; // legacy bitmask used to record detected hacks
|
|
|
|
std::string getJobId() const { return jobId; };
|
|
|
|
Time getDataModelInitTime() const { return dataModelInitTime; }
|
|
|
|
static std::string hash; // set to the hash of the client exe
|
|
|
|
//-----------------------------------
|
|
// Concurrency violation detection
|
|
// TODO: Merge with readwrite_concurrency_catcher class
|
|
class scoped_write_request
|
|
{
|
|
DataModel* const dataModel;
|
|
public:
|
|
// Place this code around tasks that write to a DataModel
|
|
scoped_write_request(Instance* context);
|
|
~scoped_write_request();
|
|
};
|
|
class scoped_read_request
|
|
{
|
|
DataModel* const dataModel;
|
|
public:
|
|
// Place this code around tasks that read a DataModel
|
|
scoped_read_request(Instance* context);
|
|
~scoped_read_request();
|
|
};
|
|
class scoped_write_transfer
|
|
{
|
|
DataModel* const dataModel;
|
|
unsigned int oldWritingThread;
|
|
public:
|
|
// Place this code around tasks that write to a DataModel and expect some other task to hold the write lock for them
|
|
scoped_write_transfer(Instance* context);
|
|
~scoped_write_transfer();
|
|
};
|
|
friend class scoped_write_request;
|
|
friend class scoped_read_request;
|
|
volatile long write_requested;
|
|
volatile long read_requested;
|
|
volatile DWORD writeRequestingThread;
|
|
|
|
bool currentThreadHasWriteLock() const;
|
|
static bool currentThreadHasWriteLock(Instance* context);
|
|
|
|
void setNetworkStatsWindowsOn(bool val) { networkStatsWindowsOn = val; }
|
|
|
|
friend class Game;
|
|
|
|
//
|
|
//-----------------------------------
|
|
|
|
// It is important for addHackFlag to be inlined for security reasons.
|
|
// If this function is not inlined, it provides a single point of attack.
|
|
// Also inlining the code (along with VMProtect) provides more obscurity.
|
|
#ifdef WIN32
|
|
__forceinline
|
|
#else
|
|
inline
|
|
#endif
|
|
void addHackFlag(unsigned int flag) {
|
|
boost::mutex::scoped_lock l(hackFlagSetMutex);
|
|
hackFlagSet.insert(flag);
|
|
sendStats |= flag;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
__forceinline
|
|
#else
|
|
inline
|
|
#endif
|
|
void removeHackFlag(unsigned int flag) {
|
|
boost::mutex::scoped_lock l(hackFlagSetMutex);
|
|
hackFlagSet.erase(flag);
|
|
sendStats &= ~flag;
|
|
}
|
|
|
|
#ifdef WIN32
|
|
__forceinline
|
|
#else
|
|
inline
|
|
#endif
|
|
bool isHackFlagSet(unsigned int flag) {
|
|
boost::mutex::scoped_lock l(hackFlagSetMutex);
|
|
return hackFlagSet.find(flag) != hackFlagSet.end() || (sendStats & flag);
|
|
}
|
|
|
|
unsigned int allHackFlagsOredTogether();
|
|
|
|
weak_ptr<GuiObject> getMouseOverInteractable() const { return mouseOverInteractable; }
|
|
bool getMouseOverGui() const { return mouseOverGui; }
|
|
void processWorkspaceEvent(const shared_ptr<InputObject>& event);
|
|
|
|
bool isClosed() const { return !isInitialized; }
|
|
void setSuppressNavKeys(bool value) { suppressNavKeys = value; }
|
|
|
|
static bool throttleAt30Fps; // for debugging/benchmarking - default is false;
|
|
|
|
// This event is fired anytime anything in the DataModel changes
|
|
rbx::signal<void(shared_ptr<Instance>, const Reflection::PropertyDescriptor*)> itemChangedSignal;
|
|
|
|
void clearContents(bool resettingSimulation);
|
|
|
|
void setInitialScreenSize(RBX::Vector2 newScreenSize);
|
|
|
|
// submits a task to be executed in a thread-safe manner
|
|
typedef boost::function<void(DataModel*)> Task;
|
|
void submitTask(Task task, DataModelJob::TaskType taskType);
|
|
shared_ptr<const Reflection::ValueArray> getJobsInfo();
|
|
|
|
void setCreatorID(int creatorID, CreatorType creatorType);
|
|
int getCreatorID() const { return creatorID; }
|
|
CreatorType getCreatorType() const { return creatorType; }
|
|
|
|
int getPlaceID() const { return placeID; }
|
|
int getPlaceIDOrZeroInStudio();
|
|
void setPlaceID(int placeID, bool robloxPlace);
|
|
|
|
void setGameInstanceID(std::string gameInstanceID) { this->gameInstanceID = gameInstanceID; }
|
|
std::string getGameInstanceID() { return this->gameInstanceID; }
|
|
|
|
int getUniverseId() { return universeId; }
|
|
void setUniverseId(int uId);
|
|
|
|
bool isStudio() const { return runningInStudio; }
|
|
void setIsStudio(bool runningInStudio);
|
|
|
|
bool isRunMode() const { return isStudioRunMode; }
|
|
void setIsRunMode(bool value);
|
|
|
|
int getPlaceVersion() const { return placeVersion; }
|
|
void setPlaceVersion(int placeVersion);
|
|
|
|
bool getIsPersonalServer() const { return isPersonalServer; }
|
|
void setIsPersonalServer(bool value) { isPersonalServer = value; }
|
|
|
|
bool getIsGameLoaded() { return isGameLoaded; }
|
|
void setIsGameLoaded(bool value)
|
|
{
|
|
isGameLoaded = value;
|
|
if(isGameLoaded)
|
|
gameLoadedSignal();
|
|
}
|
|
void gameLoaded();
|
|
|
|
bool getForceR15() const { return forceR15; }
|
|
void setForceR15(bool v);
|
|
boost::promise<void> universeDataLoaded;
|
|
bool getUniverseDataRequested() const { return universeDataRequested; }
|
|
void clearUniverseDataRequested() { universeDataRequested = false; }
|
|
void setCanRequestUniverseInfo(bool value);
|
|
|
|
void loadCoreScripts(const std::string &altStarterScript = "");
|
|
|
|
|
|
int getNumPartInstances() const { return numPartInstances; }
|
|
int getNumInstance() const { return numInstances; }
|
|
|
|
void checkFetchExperimentalFeatures();
|
|
|
|
bool canSaveLocal() const;
|
|
void saveToRoblox(boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
void completeShutdown(bool saveLocal);
|
|
boost::function<bool()> requestShutdownCallback;
|
|
|
|
typedef boost::function<void(Reflection::AsyncCallbackDescriptor::ResumeFunction, Reflection::AsyncCallbackDescriptor::ErrorFunction)> CloseCallback;
|
|
CloseCallback onCloseCallback;
|
|
void onCloseCallbackChanged(const CloseCallback&);
|
|
|
|
//Returns true if the shutdown is being handled by Lua, false to use the System Level Prompts
|
|
RequestShutdownResult requestShutdown(bool useLuaShutdownForSave=true);
|
|
|
|
// for perf stats reporting:
|
|
// width of window to measure. Set to zero to turn off and release memory.
|
|
void setJobsExtendedStatsWindow(double seconds);
|
|
shared_ptr<const Reflection::ValueArray> getJobsExtendedStats();
|
|
double getJobTimePeakFraction(std::string jobname, double greaterThan);
|
|
double getJobIntervalPeakFraction(std::string jobname, double greaterThan);
|
|
|
|
class GenericJob;
|
|
|
|
class LegacyLock : boost::noncopyable
|
|
{
|
|
struct Implementation;
|
|
boost::scoped_ptr<Implementation> const implementation;
|
|
public:
|
|
static int mainThreadId;
|
|
|
|
class Impersonator : boost::noncopyable
|
|
{
|
|
// Use this class to override a Lock. This must only be used
|
|
// when you know that a different thread is delegating the lock
|
|
// to you.
|
|
// TODO: For added safety we could write a stack-based Delegator
|
|
// object that would be constructed at the source thread. The
|
|
// Delegator would issue a token to be used by the thread that
|
|
// uses the Impersonator
|
|
public:
|
|
Impersonator(shared_ptr<DataModel> dataModel, DataModelJob::TaskType taskType);
|
|
~Impersonator();
|
|
private:
|
|
DataModel::GenericJob* previousJob;
|
|
};
|
|
LegacyLock(shared_ptr<DataModel> dataModel, DataModelJob::TaskType taskType);
|
|
LegacyLock(DataModel* dataModel, DataModelJob::TaskType taskType);
|
|
~LegacyLock();
|
|
|
|
static bool hasLegacyLock(DataModel* dataModel);
|
|
};
|
|
|
|
// Please call these to construct and release a datamodel
|
|
static shared_ptr<DataModel> createDataModel(bool startHeartbeat, RBX::Verb* lockVerb, bool shouldShowLoadingScreen);
|
|
|
|
static void closeDataModel(shared_ptr<DataModel> dataModel);
|
|
|
|
~DataModel();
|
|
DataModel(RBX::Verb* lockVerb);
|
|
static DataModel* get(Instance* context) ;
|
|
static const DataModel* get(const Instance* context) ;
|
|
|
|
void loadGame(int assetID);
|
|
void loadWorld(int assetID);
|
|
|
|
void loadContent(ContentId contentId);
|
|
void processAfterLoad();
|
|
rbx::signal<void()> saveFinishedSignal;
|
|
|
|
|
|
class SerializationException : public std::runtime_error
|
|
{
|
|
public:
|
|
|
|
SerializationException(const std::string& response)
|
|
: std::runtime_error(response) {}
|
|
};
|
|
|
|
void save(ContentId contentId);
|
|
static bool canSave(const RBX::Instance* instance);
|
|
|
|
bool getRemoteBuildMode();
|
|
void setRemoteBuildMode(bool remoteBuildMode);
|
|
|
|
void setServerSaveUrl(std::string url);
|
|
void serverSave();
|
|
|
|
bool serverSavePlace(const SaveFilter saveFilter, boost::function<void(bool)> resumeFunction = NULL, boost::function<void(std::string)> errorFunction = NULL);
|
|
shared_ptr<std::stringstream> serializeDataModel(const Instance::SaveFilter saveFilter = Instance::SAVE_ALL);
|
|
|
|
virtual void savePlaceAsync(const SaveFilter saveFilter, boost::function<void(bool)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
void httpGetAsync(std::string url, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
void httpPostAsync(std::string url, std::string data, std::string optionalContentType, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
std::string httpGet(std::string url, bool synchronous);
|
|
std::string httpPost(std::string url, std::string data, bool synchronous, std::string optionalContentType);
|
|
|
|
void reportMeasurement(std::string id, std::string key1, std::string value1, std::string key2, std::string value2);
|
|
void luaReportGoogleAnalytics(std::string category, std::string action, std::string label, int value);
|
|
|
|
void close();
|
|
|
|
#if defined(RBX_STUDIO_BUILD) || defined(RBX_RCC_SECURITY) || defined(RBX_TEST_BUILD)
|
|
shared_ptr<const Instances> fetchAsset(ContentId contentId);
|
|
#endif
|
|
|
|
void raiseClose();
|
|
|
|
static void TakeScreenshotTask(weak_ptr<RBX::DataModel> weakDataModel);
|
|
static void ScreenshotReadyTask(weak_ptr<RBX::DataModel> weakDataModel, const std::string &filename);
|
|
|
|
// true: finished, false: started
|
|
static void ScreenshotUploadTask(weak_ptr<RBX::DataModel> weakDataModel, bool finished);
|
|
|
|
static void ShowMessage(weak_ptr<RBX::DataModel> weakDataModel, int slot, const std::string &message, double duration);
|
|
|
|
void setScreenshotSEOInfo(std::string str);
|
|
void setVideoSEOInfo(std::string str);
|
|
std::string getScreenshotSEOInfo();
|
|
std::string getVideoSEOInfo() { return videoSEOInfo; }
|
|
bool isScreenshotSEOInfoSet() { return screenshotSEOInfo != ""; }
|
|
bool isVideoSEOInfoSet() { return videoSEOInfo != ""; }
|
|
|
|
void addCustomStat(std::string name, std::string value);
|
|
void removeCustomStat(std::string str);
|
|
void writeStatsSettings();
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Command Processing
|
|
int numChatOptions() {return 4;} // To Do - make this some kind of dynamic loading
|
|
|
|
void startCoreScripts(bool buildInGameGui, const std::string &altStarterScript = "");
|
|
|
|
void setGuiTargetInstance(shared_ptr<Instance> newTargetInstance) {guiTargetInstance = newTargetInstance;}
|
|
|
|
bool processInputObject(shared_ptr<InputObject> event);
|
|
GuiRoot* getGuiRoot() {return guiRoot.get();}
|
|
|
|
void setForceArrowCursor(bool value) { forceArrowCursor = value;}
|
|
|
|
///////////////////////////////////////////////////////////////////////
|
|
// IDataState
|
|
virtual void setDirty(bool dirty) { this->dirty = dirty; }
|
|
|
|
// Thread-safe:
|
|
virtual bool isDirty() const { return dirty; }
|
|
|
|
virtual std::string arbiterName() { return this->getName(); }
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Workspace Stuff / Running Stuff
|
|
//
|
|
Workspace* getWorkspace() const {return workspace.get();}
|
|
|
|
float physicsStep(float timeInterval, double dt, double dutyDt, int numThreads);
|
|
void renderStep(float timeIntervalSeconds);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// DataModelArbiter
|
|
//
|
|
/*implement*/ int getNumPlayers() const;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// timing state
|
|
//
|
|
double getGameTime() const; // i.e. game time
|
|
double getSmoothFps() const;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMetric
|
|
//
|
|
//
|
|
/*override*/ virtual std::string getMetric(const std::string& metric) const;
|
|
/*override*/ virtual double getMetricValue(const std::string& metric) const;
|
|
|
|
std::string getUpdatedMessageBoxText();
|
|
void setNetworkMetric(IMetric* metric);
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Rendering
|
|
//
|
|
virtual void renderPass2d(Adorn* adorn, IMetric* graphicsMetric);
|
|
void renderPass3dAdorn(Adorn* adorn);
|
|
void setUiMessage(std::string message);
|
|
void clearUiMessage();
|
|
void setUiMessageBrickCount();
|
|
void toggleToolsOff();
|
|
|
|
virtual void renderMouse(Adorn* adorn);
|
|
ContentId getRenderMouseCursor();
|
|
|
|
void computeGuiInset(Adorn* adorn);
|
|
void renderPlayerGui(Adorn* adorn);
|
|
void renderGuiRoot(Adorn* adorn);
|
|
static void HttpHelper(std::string* response, std::exception* exception, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
|
|
GuiBuilder getGuiBuilder() { return guiBuilder; }
|
|
|
|
TaskScheduler::Arbiter* getSyncronizationArbiter();
|
|
|
|
bool uploadPlace(const std::string& uploadUrl, const SaveFilter saveFilter, boost::function<void()> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
GuiResponse processPlayerGui(const shared_ptr<InputObject>& event);
|
|
|
|
static void processHttpRequestResponseOnLock(DataModel *dataModel, std::string* response, std::exception* exception, boost::function<void(shared_ptr<std::string>,shared_ptr<std::exception> exception)> onLockAcquired);
|
|
|
|
protected:
|
|
static void doDataModelSetup(shared_ptr<DataModel> dataModel, bool startHeartbeat, bool shouldShowLoadingScreen);
|
|
|
|
void internalSave(ContentId contentId);
|
|
void internalSaveAsync(ContentId contentId, boost::function<void(bool)> resumeFunction);
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Instance overrides
|
|
/*override*/ bool askAddChild(const Instance* instance) const;
|
|
/*override*/ void onChildAdded(Instance* child);
|
|
|
|
/*override*/ void onChildChanged(Instance* instance, const PropertyChanged& event);
|
|
/*override*/ void onDescendantAdded(Instance* instance);
|
|
/*override*/ void onDescendantRemoving(const shared_ptr<Instance>& instance);
|
|
void onRunTransition(RunTransition event);
|
|
|
|
bool processEvent(const shared_ptr<InputObject>& event);
|
|
GuiResponse processProfilerEvent(const shared_ptr<InputObject>& event);
|
|
|
|
weak_ptr<Instance> guiTargetInstance;
|
|
bool mouseOverGui;
|
|
weak_ptr<GuiObject> mouseOverInteractable;
|
|
|
|
bool getSuppressNavKeys() const { return suppressNavKeys; }
|
|
private:
|
|
rbx::signals::scoped_connection unbindResourceSignal;
|
|
void onUnbindResourceSignal();
|
|
|
|
bool suppressNavKeys;
|
|
static std::string doHttpGet(const std::string& url);
|
|
static void doHttpGet(const std::string& url, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
static std::string doHttpPost(const std::string& url, const std::string& data, const std::string& contentType);
|
|
static void doHttpPost(const std::string& url, const std::string& data, const std::string& contentType, boost::function<void(std::string)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
|
|
static void doCloseDataModel(shared_ptr<DataModel> dataModel);
|
|
|
|
void AsyncUploadPlaceResponseHandler(std::string* response, std::exception* exception, boost::function<void()> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
bool uploadPlaceReturn(const bool succeeded, const std::string error, boost::function<void()> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
|
|
bool canRenderMouse();
|
|
|
|
GuiResponse processDevGamepadEvent(const shared_ptr<InputObject>& event);
|
|
GuiResponse processCoreGamepadEvent(const shared_ptr<InputObject>& event);
|
|
GuiResponse processGuiTarget(const shared_ptr<InputObject>& event);
|
|
|
|
typedef boost::array<shared_ptr<GenericJob>, DataModelJob::TaskTypeMax> GenericJobs;
|
|
RBX::mutex genericJobsLock;
|
|
GenericJobs genericJobs;
|
|
RBX::mutex debugLock;
|
|
shared_ptr<GenericJob> tryGetGenericJob(DataModelJob::TaskType type);
|
|
shared_ptr<GenericJob> getGenericJob(DataModelJob::TaskType type);
|
|
|
|
std::map<std::string,int> dataModelReportingData;
|
|
void traverseDataModelReporting(shared_ptr<Instance> child);
|
|
|
|
Instance* getLightingDeprecated() const;
|
|
static Reflection::RefPropDescriptor<DataModel, Instance> prop_lighting;
|
|
|
|
bool remoteBuildMode;
|
|
std::string serverSaveUrl;
|
|
|
|
std::string screenshotSEOInfo;
|
|
std::string videoSEOInfo;
|
|
HeapValue<int> placeID;
|
|
std::string gameInstanceID;
|
|
int universeId;
|
|
bool runningInStudio;
|
|
bool isStudioRunMode;
|
|
bool checkedExperimentalFeatures;
|
|
|
|
int placeVersion;
|
|
|
|
HeapValue<int> creatorID;
|
|
CreatorType creatorType;
|
|
|
|
Genre genre;
|
|
GearGenreSetting gearGenreSetting;
|
|
unsigned allowedGearTypes;
|
|
|
|
std::string vipServerId;
|
|
int vipServerOwnerId;
|
|
|
|
GuiBuilder guiBuilder;
|
|
};
|
|
|
|
} // namespace
|