+Unity Runtime codeHEADmaster

1 files changed, 458 insertions, 0 deletions

diff --git a/Runtime/Misc/PlayerSettings.h b/Runtime/Misc/PlayerSettings.h
new file mode 100644
index 0000000..5e25d53
--- /dev/null
+++ b/Runtime/Misc/PlayerSettings.h
@@ -0,0 +1,458 @@
+#ifndef PROJECTSETTINGS_H
+#define PROJECTSETTINGS_H
+
+#include "Runtime/GameCode/Behaviour.h"
+#include "Runtime/BaseClasses/GameManager.h"
+#include "Runtime/Math/ColorSpaceConversion.h"
+#include "Runtime/Math/Rect.h"
+#include "Runtime/Camera/RenderLoops/RenderLoopEnums.h"
+#include "Runtime/Math/Vector2.h"
+
+#if UNITY_EDITOR
+#include "Editor/Src/EditorOnlyPlayerSettings.h"
+#endif
+
+class Texture2D;
+
+
+
+enum { kDisableResolutionDialog = 0, kShowResolutionDialog = 1, kShowResolutionDialogDefaultNone = 2 };
+
+enum ResolutionAspect
+{
+	kAspectOthers = 0,
+	kAspect4by3,
+	kAspect5by4,
+	kAspect16by10,
+	kAspect16by9,
+	kAspectCount
+};
+
+enum MacFullscreenMode
+{
+	kCaptureDisplay,
+	kFullscreenWindow,
+	kFullscreenWindowWithMenuBarAndDock,
+};
+
+struct AspectRatios
+{
+	DECLARE_SERIALIZE_NO_PPTR (AspectRatios)
+
+	bool	m_Ratios[kAspectCount];
+
+	AspectRatios () { Reset (); }
+
+	void Reset()
+	{
+		for (int i = 0; i < kAspectCount; ++i)
+			m_Ratios[i] = true;
+	}
+};
+
+class PlayerSettings : public GlobalGameManager
+{
+public:
+
+	DECLARE_OBJECT_SERIALIZE (PlayerSettings)
+	REGISTER_DERIVED_CLASS (PlayerSettings, GlobalGameManager)
+	PlayerSettings (MemLabelId label, ObjectCreationMode mode);
+	// ~PlayerSettings (); declared-by-macro
+
+	virtual void CheckConsistency ();
+	void AwakeFromLoad (AwakeFromLoadMode mode);
+
+	bool DoesSupportResolution (int width, int height) const;
+	void InitDefaultCursors ();
+
+	static void InitializeClass ();
+	static void PostInitializeClass ();
+	static void CleanupClass () {  }
+
+public:
+
+	UnityStr    companyName;
+	UnityStr    productName;
+	UnityStr    version;
+
+	PPtr<Texture2D> defaultCursor;
+	Vector2f cursorHotspot;
+
+	bool		androidProfiler;
+	int			defaultScreenOrientation; ///< enum { Portrait = 0, Portrait Upside Down = 1, Landscape Right = 2, Landscape Left = 3, Auto Rotation = 4 }
+	int			targetDevice; ///< enum { iPhone Only = 0, iPad Only = 1, iPhone + iPad = 2 }
+	int 		targetGlesGraphics; ///< enum { OpenGL ES 2.0 = 1, OpenGL ES 3.0 = 2 }
+	int         targetResolution; ///< enum { Native (default device resolution) = 0, Auto (Best Performance) = 3, Auto (Best Quality) = 4, 320p (iPhone) = 5, 640p (iPhone Retina Display) = 6, 768p (iPad) = 7 }
+	int			accelerometerFrequency; ///< enum { Disabled = 0, 15 Hz = 15, 30 Hz = 30, 60 Hz = 60, 100 Hz = 100 }
+
+	// General
+	int         defaultScreenWidth;
+	int         defaultScreenHeight;
+
+	int         defaultWebScreenWidth;
+	int         defaultWebScreenHeight;
+
+	int         displayResolutionDialog;///< enum { Disabled = 0, Enabled = 1, Hidden By Default = 2 }
+	AspectRatios	m_SupportedAspectRatios;
+
+	int		m_RenderingPath; 		///< enum { Vertex Lit=0, Forward=1, Deferred Lighting=2 } Rendering path to use.
+	int 	m_MobileRenderingPath;	///< enum { Vertex Lit=0, Forward=1, Deferred Lighting=2 } Rendering path to use on Mobiles.
+	int 	m_ActiveColorSpace; 	///< enum { Gamma, Linear }
+	bool 	m_MTRendering;
+	bool	m_MobileMTRendering;
+	bool 	m_UseDX11;
+
+	// TODO: unify probably with ios, though we will ne handle it specifically with EnumPopup or something on editor side
+	// TODO: if someone from editor team wants it - go ahead
+	// values are taken from android.R.attr docs
+	int			androidShowActivityIndicatorOnLoading; ///< enum { Don't Show=-1, Large=0, Inversed Large=1, Small=2, Inversed Small=3 }
+	int			iosShowActivityIndicatorOnLoading; ///< enum { Don't Show=-1, White Large=0, White=1, Gray=2 }
+
+	// auto-rotation handling. Expose bools on editor side
+	bool		uiAutoRotateToPortrait;
+	bool		uiAutoRotateToPortraitUpsideDown;
+	bool		uiAutoRotateToLandscapeRight;
+	bool		uiAutoRotateToLandscapeLeft;
+	bool		uiUseAnimatedAutoRotation;
+
+	bool		uiUse32BitDisplayBuffer;
+	bool		uiUse24BitDepthBuffer;
+
+	bool        defaultIsFullScreen;
+	bool        defaultIsNativeResolution;
+	bool		runInBackground;
+	bool		captureSingleScreen;
+
+	bool        overrideIPodMusic; ///< Force mixing behavior allowing iPod audio to play with FMOD even if the audio session doesn't usually permit this.
+	bool		prepareIOSForRecording; ///< If enabled, the AudioSession of iOS will be initialized in recording mode, thus avoiding delays when initializing the Microphone object.
+
+	bool		enableHWStatistics;
+
+	bool		usePlayerLog;
+	bool		stripPhysics;
+	bool		useMacAppStoreValidation;
+	int			macFullscreenMode; ///< enum {CaptureDisplay=0, FullscreenWindow=1, FullscreenWindowWithMenuBarAndDock=2}
+	bool        forceSingleInstance;
+	bool		resizableWindow;
+	bool		gpuSkinning;
+	bool		xboxPIXTextureCapture; // Xbox360
+	bool        xboxEnableAvatar; // Xbox360
+	bool		xboxEnableKinect; // Xbox360 Kinect
+	bool		xboxEnableKinectAutoTracking; // Xbox360 Kinect
+	UInt32		xboxSpeechDB;
+	bool		xboxEnableFitness;
+	bool		xboxEnableHeadOrientation;
+	bool		xboxEnableGuest;
+
+	int			wiiHio2Usage; ///< enum { None=-1, Profiler=0, Automation=1 } Wii Hio2 Usage.
+	int			wiiLoadingScreenRectPlacement; ///< enum {TopLeft = 0, TopCenter = 1, TopRight = 2, MiddleLeft = 3, MiddleCenter = 4, MiddlerRight = 5, BottomLeft = 6, BottomCenter = 7, BottomRight = 8} Placement.
+	ColorRGBAf  wiiLoadingScreenBackground;
+	int			wiiLoadingScreenPeriod;
+	UnityStr    wiiLoadingScreenFileName;
+	Rectf		wiiLoadingScreenRect;
+	int         firstStreamedLevelWithResources;
+
+	UnityStr    absoluteURL;// Web player
+	UnityStr    srcValue;// Web player
+
+	UnityStr    iPhoneBundleIdentifier;
+
+	UnityStr    AndroidLicensePublicKey;
+
+	#if UNITY_EDITOR
+	EditorOnlyPlayerSettings              m_EditorOnly;
+	EditorOnlyPlayerSettingsNotPersistent m_EditorOnlyNotPersistent;
+
+	////////@TODO: Move this into a seperate manager!
+	int         unityRebuildLibraryVersion;
+	int         unityForwardCompatibleVersion;
+	int         unityStandardAssetsVersion;
+	#endif
+
+public:
+
+	std::string GetCompanyName () const { return companyName; }
+	void SetCompanyName (std::string value) { companyName = value; SetDirty(); }
+
+	std::string GetProductName () const { return productName; }
+	void SetProductName (std::string value) { productName = value; SetDirty();}
+
+	int GetTargetDevice () const { return targetDevice; }
+	void SetTargetDevice (int value) { targetDevice = value; SetDirty();}
+
+	PPtr<Texture2D> GetDefaultCursor () const { return defaultCursor; }
+	void SetDefaultCursor (PPtr<Texture2D> value) { defaultCursor = value; SetDirty();}
+
+	Vector2f GetCursorHotspot () const { return cursorHotspot; }
+	void SetCursorHotspot (Vector2f value) { cursorHotspot = value; SetDirty();}
+
+	int GetTargetGlesGraphics () const { return targetGlesGraphics; }
+	void SetTargetGlesGraphics (int value) { targetGlesGraphics = value; SetDirty(); }
+
+	int GetTargetResolution () const { return targetResolution; }
+	void SetTargetResolution (int value) { targetResolution = value; SetDirty();}
+
+	int GetAccelerometerFrequency () const { return accelerometerFrequency; }
+	void SetAccelerometerFrequency (int value) { accelerometerFrequency = value; SetDirty();}
+
+	int GetDefaultScreenOrientation () const { return defaultScreenOrientation; }
+	void SetDefaultScreenOrientation (int value) { defaultScreenOrientation = value; SetDirty();}
+
+	bool GetUseAnimatedAutoRotation () const { return uiUseAnimatedAutoRotation; }
+	void SetUseAnimatedAutoRotation (bool value) { uiUseAnimatedAutoRotation = value; SetDirty();}
+
+	bool GetAutoRotationAllowed(int orientation) const;
+	void SetAutoRotationAllowed(int orientation, bool enabled);
+
+	bool GetUse32BitDisplayBuffer() const { return uiUse32BitDisplayBuffer; }
+	void SetUse32BitDisplayBuffer(bool use) { uiUse32BitDisplayBuffer = use; }
+
+	bool GetUse24BitDepthBuffer() const { return uiUse24BitDepthBuffer; }
+	void SetUse24BitDepthBuffer(bool use) { uiUse24BitDepthBuffer = use; }
+
+	int GetIOSShowActivityIndicatorOnLoading() const { return iosShowActivityIndicatorOnLoading; }
+	void SetIOSShowActivityIndicatorOnLoading(int mode) { iosShowActivityIndicatorOnLoading = mode; SetDirty();}
+	int GetAndroidShowActivityIndicatorOnLoading() const { return androidShowActivityIndicatorOnLoading; }
+	void SetAndroidShowActivityIndicatorOnLoading(int mode) { androidShowActivityIndicatorOnLoading = mode; SetDirty();}
+
+	int GetDefaultScreenWidth () const { return defaultScreenWidth; }
+	void SetDefaultScreenWidth (int value) { defaultScreenWidth = value; SetDirty();}
+
+	int GetDefaultScreenHeight () const { return defaultScreenHeight; }
+	void SetDefaultScreenHeight (int value) { defaultScreenHeight = value; SetDirty();}
+
+	int GetDefaultWebScreenWidth () const { return defaultWebScreenWidth; }
+	void SetDefaultWebScreenWidth (int value) { defaultWebScreenWidth = value; SetDirty();}
+
+	int GetDefaultWebScreenHeight () const { return defaultWebScreenHeight; }
+	void SetDefaultWebScreenHeight (int value) { this->defaultWebScreenHeight = value; SetDirty();}
+
+	int GetDisplayResolutionDialog () const { return displayResolutionDialog; }
+	void SetDisplayResolutionDialog (int value) { this->displayResolutionDialog = value; SetDirty();}
+
+	bool AspectRatioEnabled (int aspectRatio) const { return m_SupportedAspectRatios.m_Ratios [aspectRatio]; }
+	void SetAspectRatio (int aspectRatio, bool enabled) { m_SupportedAspectRatios.m_Ratios[aspectRatio] = enabled; SetDirty();}
+
+	bool GetDefaultIsFullScreen () const { return defaultIsFullScreen; }
+	void SetDefaultIsFullScreen (bool value) { defaultIsFullScreen = value; SetDirty(); }
+
+	bool GetDefaultIsNativeResolution () const { return defaultIsNativeResolution; }
+	void SetDefaultIsNativeResolution (bool value) { defaultIsNativeResolution = value; SetDirty(); }
+
+	bool GetRunInBackground () const { return runInBackground; }
+	void SetRunInBackground (bool value) { runInBackground = value; SetDirty(); }
+
+	bool GetStripPhysics () const { return stripPhysics; }
+	void SetStripPhysics (bool value) { stripPhysics = value; SetDirty(); }
+
+	bool GetUsePlayerLog () const { return usePlayerLog; }
+	void SetUsePlayerLog (bool value) { usePlayerLog = value; SetDirty(); }
+
+	bool GetEnableHWStatistics () const { return enableHWStatistics; }
+	void SetEnableHWStatistics (bool value) { enableHWStatistics = value; SetDirty(); }
+
+	bool GetUseMacAppStoreValidation () const { return useMacAppStoreValidation; }
+	void SetUseMacAppStoreValidation (bool value) { useMacAppStoreValidation = value; SetDirty(); }
+
+	int GetMacFullscreenMode () const { return macFullscreenMode; }
+	void SetMacFullscreenMode (int value) { macFullscreenMode = value; SetDirty(); }
+
+	bool GetForceSingleInstance () const { return forceSingleInstance; }
+	void SetForceSingleInstance (bool value) { forceSingleInstance = value; SetDirty(); }
+
+	bool GetResizableWindow () const { return resizableWindow; }
+	void SetResizableWindow (bool value) { resizableWindow = value; SetDirty(); }
+
+	bool GetGPUSkinning() const { return gpuSkinning; }
+	void SetGPUSkinning(bool value) { gpuSkinning = value; SetDirty(); }
+
+	bool GetXboxPIXTextureCapture() const { return xboxPIXTextureCapture; }
+	void SetXboxPIXTextureCapture(bool value) { xboxPIXTextureCapture = value; SetDirty(); }
+
+	bool GetXboxEnableAvatar() const { return xboxEnableAvatar; }
+	void SetXboxEnableAvatar(bool value) { xboxEnableAvatar = value; SetDirty(); }
+	bool GetXboxEnableGuest() const { return xboxEnableGuest; }
+	void SetXboxEnableGuest(bool value) { xboxEnableGuest = value; SetDirty(); }
+
+	bool GetXboxEnableKinect() const { return xboxEnableKinect; }
+	void SetXboxEnableKinect(bool value) { xboxEnableKinect = value; SetDirty(); }
+	bool GetXboxEnableKinectAutoTracking() const { return xboxEnableKinectAutoTracking; }
+	void SetXboxEnableKinectAutoTracking(bool value) { xboxEnableKinectAutoTracking = value; SetDirty(); }
+	UInt32 GetXboxSpeechDB() const { return xboxSpeechDB; }
+	void SetXboxSpeechDB(UInt32 value) { xboxSpeechDB = value; SetDirty(); }
+	bool GetXboxEnableFitness() const { return xboxEnableFitness; }
+	void SetXboxEnableFitness(bool value) { xboxEnableFitness = value; SetDirty(); }
+	bool GetXboxHeadOrientation() const { return xboxEnableHeadOrientation; }
+	void SetXboxHeadOrientation(bool value) { xboxEnableHeadOrientation = value; SetDirty(); }
+
+	bool GetCaptureSingleScreen () const { return captureSingleScreen; }
+	void SetCaptureSingleScreen (bool value) { captureSingleScreen = value; SetDirty(); }
+
+	int GetFirstStreamedLevelWithResources () const { return firstStreamedLevelWithResources; }
+	void SetFirstStreamedLevelWithResources (int value) { this->firstStreamedLevelWithResources = value; SetDirty(); }
+
+	void SetRenderingPath (RenderingPath rp) { m_RenderingPath = rp; SetDirty(); }
+	RenderingPath GetRenderingPath() const { return static_cast<RenderingPath>(m_RenderingPath); }
+
+	void SetMobileRenderingPath (RenderingPath rp) { m_MobileRenderingPath = rp; SetDirty(); }
+	RenderingPath GetMobileRenderingPath() const { return static_cast<RenderingPath>(m_MobileRenderingPath); }
+
+	RenderingPath	GetRenderingPathRuntime();
+	void			SetRenderingPathRuntime(RenderingPath rp);
+
+	void SetDesiredColorSpace (ColorSpace colorSpace) { m_ActiveColorSpace = colorSpace; SetDirty();}
+	ColorSpace GetDesiredColorSpace () const { return static_cast<ColorSpace> (m_ActiveColorSpace); }
+	ColorSpace GetValidatedColorSpace () const ;
+
+	void SetMTRendering (bool mtRendering) { m_MTRendering = mtRendering; SetDirty(); }
+	bool GetMTRendering () const { return m_MTRendering; }
+
+	void SetMobileMTRendering (bool mtRendering) { m_MobileMTRendering = mtRendering; SetDirty(); }
+	bool GetMobileMTRendering () const { return m_MobileMTRendering; }
+
+	bool GetMTRenderingRuntime();
+	void SetMTRenderingRuntime(bool mtRendering);
+
+
+	void SetUseDX11 (bool v) { m_UseDX11 = v; SetDirty(); }
+	bool GetUseDX11 () const { return m_UseDX11; }
+
+	std::string GetiPhoneBundleIdentifier () const { return iPhoneBundleIdentifier; }
+	void SetiPhoneBundleIdentifier (const std::string& value) { iPhoneBundleIdentifier = value; SetDirty();}
+
+	#if UNITY_EDITOR
+
+	int GetAPICompatibilityLevel () const { return m_EditorOnly.apiCompatibilityLevel; }
+	void SetAPICompatibilityLevel (int value) { m_EditorOnly.apiCompatibilityLevel = value; SetDirty();}
+
+	bool GetStripUnusedMeshComponents() const { return m_EditorOnly.stripUnusedMeshComponents; }
+	void SetStripUnusedMeshComponents (bool v) { m_EditorOnly.stripUnusedMeshComponents = v; SetDirty(); }
+
+	std::string GetAotOptions () const { return m_EditorOnly.aotOptions; }
+	void SetAotOptions (std::string value) { m_EditorOnly.aotOptions = value; SetDirty();}
+
+	std::string GetAndroidKeystoreName () const { return m_EditorOnly.AndroidKeystoreName; }
+	void SetAndroidKeystoreName (std::string value) { m_EditorOnly.AndroidKeystoreName = value; SetDirty();}
+
+	std::string GetAndroidKeystorePass () const { return m_EditorOnlyNotPersistent.AndroidKeystorePass; }
+	void SetAndroidKeystorePass (std::string value) { m_EditorOnlyNotPersistent.AndroidKeystorePass = value; SetDirty();}
+
+	std::string GetAndroidKeyaliasName () const { return m_EditorOnly.AndroidKeyaliasName; }
+	void SetAndroidKeyaliasName (std::string value) { m_EditorOnly.AndroidKeyaliasName = value; SetDirty();}
+
+	std::string GetAndroidKeyaliasPass () const { return m_EditorOnlyNotPersistent.AndroidKeyaliasPass; }
+	void SetAndroidKeyaliasPass (std::string value) { m_EditorOnlyNotPersistent.AndroidKeyaliasPass = value; SetDirty();}
+
+	bool GetAndroidLicenseVerification () const { return !AndroidLicensePublicKey.empty(); }
+
+	int GetUseAPKExpansionFiles () const { return m_EditorOnly.enableAndroidExpansionFiles; }
+	void SetUseAPKExpansionFiles (int value) { m_EditorOnly.enableAndroidExpansionFiles = value; SetDirty();}
+
+	std::string GetiPhoneBundleVersion () const { return m_EditorOnly.iPhoneBundleVersion; }
+	void SetiPhoneBundleVersion (std::string value) { m_EditorOnly.iPhoneBundleVersion = value; SetDirty();}
+
+	int GetiPhoneStrippingLevel () const { return m_EditorOnly.iPhoneStrippingLevel; }
+	void SetiPhoneStrippingLevel (int value) { m_EditorOnly.iPhoneStrippingLevel = value; SetDirty();}
+
+	int GetAndroidBundleVersionCode () const { return m_EditorOnly.AndroidBundleVersionCode; }
+	void SetAndroidBundleVersionCode (int value) { m_EditorOnly.AndroidBundleVersionCode = value; SetDirty();}
+
+	int GetAndroidMinSdkVersion () const { return m_EditorOnly.AndroidMinSdkVersion; }
+	void SetAndroidMinSdkVersion (int value) { m_EditorOnly.AndroidMinSdkVersion = value; SetDirty();}
+
+	int GetAndroidPreferredInstallLocation () const { return m_EditorOnly.AndroidPreferredInstallLocation; }
+	void SetAndroidPreferredInstallLocation (int value) { m_EditorOnly.AndroidPreferredInstallLocation = value; SetDirty();}
+
+	int GetForceAndroidInternetPermission () const { return m_EditorOnly.forceAndroidInternetPermission; }
+	void SetForceAndroidInternetPermission (int value) { m_EditorOnly.forceAndroidInternetPermission = value; SetDirty();}
+
+	int GetForceAndroidSDCardPermission () const { return m_EditorOnly.forceAndroidSDCardPermission; }
+	void SetForceAndroidSDCardPermission (int value) { m_EditorOnly.forceAndroidSDCardPermission = value; SetDirty();}
+
+	int GetCreateAndroidWallpaper () const { return m_EditorOnly.createAndroidWallpaper; }
+	void SetCreateAndroidWallpaper (int value) { m_EditorOnly.createAndroidWallpaper = value; SetDirty();}
+
+	int GetAndroidTargetDevice () const { return m_EditorOnly.AndroidTargetDevice; }
+	void SetAndroidTargetDevice (int value) { m_EditorOnly.AndroidTargetDevice = value; SetDirty();}
+
+	int GetAndroidSplashScreenScale () const { return m_EditorOnly.AndroidSplashScreenScale; }
+	void SetAndroidSplashScreenScale (int value) { m_EditorOnly.AndroidSplashScreenScale = value; SetDirty();}
+
+	std::string GetBlackBerryDeviceAddress () { return m_EditorOnly.blackberryDeviceAddress; }
+	void SetBlackBerryDeviceAddress (std::string value) { m_EditorOnly.blackberryDeviceAddress = value; SetDirty();}
+
+	std::string GetBlackBerryDevicePassword () { return m_EditorOnly.blackberryDevicePassword; }
+	void SetBlackBerryDevicePassword (std::string value) { m_EditorOnly.blackberryDevicePassword = value; SetDirty();}
+
+    std::string GetTizenProductDescription () { return m_EditorOnly.tizenProductDescription; }
+	void SetTizenProductDescription (std::string value) { m_EditorOnly.tizenProductDescription = value; SetDirty();}
+
+    std::string GetTizenProductURL () { return m_EditorOnly.tizenProductURL; }
+	void SetTizenProductURL (std::string value) { m_EditorOnly.tizenProductURL = value; SetDirty();}
+
+    std::string GetTizenCertificatePath () { return m_EditorOnly.tizenCertificatePath; }
+	void SetTizenCertificatePath (std::string value) { m_EditorOnly.tizenCertificatePath = value; SetDirty();}
+
+    std::string GetTizenCertificatePassword () { return m_EditorOnly.tizenCertificatePassword; }
+	void SetTizenCertificatePassword (std::string value) { m_EditorOnly.tizenCertificatePassword = value; SetDirty();}
+
+	int GetiPhoneScriptCallOptimization () const { return m_EditorOnly.iPhoneScriptCallOptimization; }
+	void SetiPhoneScriptCallOptimization (int value) { m_EditorOnly.iPhoneScriptCallOptimization = value; SetDirty();}
+
+	int GetiPhoneSdkVersion () const { return m_EditorOnly.iPhoneSdkVersion; }
+	void SetiPhoneSdkVersion (int value) { m_EditorOnly.iPhoneSdkVersion = value; SetDirty();}
+
+	int GetiPhoneTargetOSVersion () const { return m_EditorOnly.iPhoneTargetOSVersion; }
+	void SetiPhoneTargetOSVersion (int value) { m_EditorOnly.iPhoneTargetOSVersion = value; SetDirty();}
+
+	int GetUIPrerenderedIcon () const { return m_EditorOnly.uIPrerenderedIcon; }
+	void SetUIPrerenderedIcon (int value) { m_EditorOnly.uIPrerenderedIcon = value; SetDirty();}
+
+	int GetUIRequiresPersistentWiFi () const { return m_EditorOnly.uIRequiresPersistentWiFi; }
+	void SetUIRequiresPersistentWiFi (int value) { m_EditorOnly.uIRequiresPersistentWiFi = value; SetDirty();}
+
+	int GetUIStatusBarHidden () const { return m_EditorOnly.uIStatusBarHidden; }
+	void SetUIStatusBarHidden (int value) { m_EditorOnly.uIStatusBarHidden = value; SetDirty();}
+
+	int GetUIStatusBarStyle () const { return m_EditorOnly.uIStatusBarStyle; }
+	void SetUIStatusBarStyle (int value) { m_EditorOnly.uIStatusBarStyle = value; SetDirty();}
+
+	int GetUIExitOnSuspend () const { return m_EditorOnly.uIExitOnSuspend; }
+	void SetUIExitOnSuspend (int value) { m_EditorOnly.uIExitOnSuspend = value; SetDirty();}
+
+	PPtr <Texture2D> GetResolutionDialogBanner () const { return m_EditorOnly.resolutionDialogBanner; }
+	void SetResolutionDialogBanner (PPtr <Texture2D> value) { m_EditorOnly.resolutionDialogBanner = value; SetDirty(); }
+
+	std::vector<int> GetPlatformIconSizes (const std::string& platform) { return m_EditorOnly.GetPlatformIconSizes(platform); }
+	std::vector<PPtr<Texture2D> > GetPlatformIcons (const std::string& platform) { return m_EditorOnly.GetPlatformIcons(platform); }
+	void SetPlatformIcons(const std::string& platform, std::vector<PPtr<Texture2D> > icons) { if (m_EditorOnly.SetPlatformIcons(platform, icons)) SetDirty(); }
+
+	Texture2D* GetPlatformIconForSize (const std::string& platform, int size) { return m_EditorOnly.GetPlatformIconForSize(platform, size); }
+
+	void GetPlatformBatching (BuildTargetPlatform platform, bool* outStaticBatching, bool* outDynamicBatching) const { m_EditorOnly.GetPlatformBatching(platform, outStaticBatching, outDynamicBatching); }
+	void SetPlatformBatching (BuildTargetPlatform platform, bool staticBatching, bool dynamicBatching) { m_EditorOnly.SetPlatformBatching(platform, staticBatching, dynamicBatching); SetDirty(); }
+
+	void SetWebPlayerTemplate (UnityStr value) { if (!m_EditorOnly.m_WebPlayerTemplate.compare(value)) { m_EditorOnly.m_WebPlayerTemplate = value; SetDirty (); } };
+	void SetTemplateCustomKeys (std::vector<std::string> keys) { m_EditorOnly.SetTemplateCustomKeys(keys); SetDirty(); }
+	void SetTemplateCustomValue (std::string key, std::string value)  { if (m_EditorOnly.SetTemplateCustomValue(key, value)) SetDirty(); }
+
+	std::vector<std::string> GetTemplateCustomKeys () { return m_EditorOnly.GetTemplateCustomKeys(); }
+	std::string GetWebPlayerTemplate () const { return m_EditorOnly.m_WebPlayerTemplate; }
+	std::string GetTemplateCustomValue (std::string key)  { return m_EditorOnly.GetTemplateCustomValue(key); }
+
+	const EditorOnlyPlayerSettings& GetEditorOnly () const { return m_EditorOnly; }
+
+	///Always marks as dirty
+	EditorOnlyPlayerSettings& GetEditorOnlyForUpdate () { SetDirty(); return m_EditorOnly; }
+	EditorOnlyPlayerSettingsNotPersistent& GetEditorOnlyNotPersistent () { return m_EditorOnlyNotPersistent; }
+
+private:
+	std::vector<EditorOnlyPlayerSettings::IconWithSize> GetBestIconWithSizes (const std::string& platform);
+
+	#endif
+};
+
+PlayerSettings& GetPlayerSettings ();
+PlayerSettings* GetPlayerSettingsPtr ();
+
+#endif