private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. No renderer to revert back to.");
m_renderer = null;
}
}
if (m_renderer == null)
{
//hardcoded mesage becaouse of mytexts are not initialized yet
throw new MyRenderException(@"The current version of the game requires a Dx11 card. \n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
// Main method
static void Main(string[] args)
{
SpaceEngineersGame.SetupBasicGameInfo();
m_startup = new MyCommonProgramStartup(args);
if (m_startup.PerformReporting()) return;
m_startup.PerformAutoconnect();
if (!m_startup.CheckSingleInstance()) return;
var appDataPath = m_startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(AppId, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
m_startup.InitSplashScreen();
if (!m_startup.Check64Bit()) return;
m_startup.DetectSharpDxLeaksBeforeRun();
using (MySteamService steamService = new MySteamService(MySandboxGame.IsDedicated, AppId))
{
m_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
SpaceEngineersGame.SetupRender();
try
{
InitializeRender();
}
catch(MyRenderException ex)
{
MessageBox.Show(ex.Message);
return;
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyProgram.Init");
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MySteam.Init()");
if (!m_startup.CheckSteamRunning(steamService)) return;
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("new MySandboxGame()");
VRageGameServices services = new VRageGameServices(steamService);
if (!MySandboxGame.IsDedicated)
MyFileSystem.InitUserSpecific(steamService.UserId.ToString());
using (SpaceEngineersGame game = new SpaceEngineersGame(services, args))
{
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
game.Run(disposeSplashScreen: m_startup.DisposeSplashScreen);
}
}
m_startup.DetectSharpDxLeaksAfterRun();
#if PROFILING
MyPerformanceTimer.WriteToLog();
#endif
MyInitializer.InvokeAfterRun();
}
public override void Init()
{
Log.Info("Initializing Torch Client");
base.Init();
if (!File.Exists("steam_appid.txt"))
{
Directory.SetCurrentDirectory(Path.GetDirectoryName(typeof(VRage.FastResourceLock).Assembly.Location) + "\\..");
}
SpaceEngineersGame.SetupBasicGameInfo();
_startup = new MyCommonProgramStartup(RunArgs);
if (_startup.PerformReporting())
{
return;
}
_startup.PerformAutoconnect();
if (!_startup.CheckSingleInstance())
{
return;
}
var appDataPath = _startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(APP_ID, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
if (!_startup.Check64Bit())
{
return;
}
_startup.DetectSharpDxLeaksBeforeRun();
using (var mySteamService = new SteamService(Game.IsDedicated, APP_ID))
{
_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
OverrideMenus();
InitializeRender();
_services = new VRageGameServices(mySteamService);
if (!Game.IsDedicated)
{
MyFileSystem.InitUserSpecific(mySteamService.UserId.ToString());
}
}
_startup.DetectSharpDxLeaksAfterRun();
MyInitializer.InvokeAfterRun();
}
public override void Init()
{
Directory.SetCurrentDirectory(Program.SpaceEngineersInstallAlias);
MyFileSystem.ExePath = Path.Combine(Program.SpaceEngineersInstallAlias, Program.SpaceEngineersBinaries);
Log.Info("Initializing Torch Client");
base.Init();
SpaceEngineersGame.SetupBasicGameInfo();
_startup = new MyCommonProgramStartup(RunArgs);
if (_startup.PerformReporting())
{
throw new InvalidOperationException("Torch client won't launch when started in error reporting mode");
}
_startup.PerformAutoconnect();
if (!_startup.CheckSingleInstance())
{
throw new InvalidOperationException("Only one instance of Space Engineers can be running at a time.");
}
var appDataPath = _startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(APP_ID, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
_startup.InitSplashScreen();
if (!_startup.Check64Bit())
{
throw new InvalidOperationException("Torch requires a 64bit operating system");
}
_startup.DetectSharpDxLeaksBeforeRun();
var steamService = new SteamService(Game.IsDedicated, APP_ID);
MyServiceManager.Instance.AddService <IMyGameService>(steamService);
_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
// I'm sorry, but it's what Keen does in SpaceEngineers.MyProgram
#pragma warning disable 612
SpaceEngineersGame.SetupRender();
#pragma warning restore 612
InitializeRender();
if (!_startup.CheckSteamRunning())
{
throw new InvalidOperationException("Space Engineers requires steam to be running");
}
if (!Game.IsDedicated)
{
MyFileSystem.InitUserSpecific(MyGameService.UserId.ToString());
}
}
private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else if (MyFakes.ENABLE_DX11_RENDERER)
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. Reverting to DirectX 9.");
m_renderer = null;
}
}
if (m_renderer == null)
{
//hardcoded mesage becaouse of mytexts are not initialized yet
throw new MyRenderException(@"The current version of the game requires a Dx11 card. If you would like to play the game without it, please select the Dx9-32bit BETA tab from properties. \n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
else
{
m_renderer = new MyDX9Render();
}
MyFakes.ENABLE_PLANETS &= MySandboxGame.Config.GraphicsRenderer != MySandboxGame.DirectX9RendererKey;
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else if (MyFakes.ENABLE_DX11_RENDERER)
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. Reverting to DirectX 9.");
m_renderer = null;
}
}
if (m_renderer == null)
{
m_renderer = new MyDX9Render();
rendererId = MySandboxGame.DirectX9RendererKey;
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
else
{
m_renderer = new MyDX9Render();
}
MyFakes.ENABLE_PLANETS &= MySandboxGame.Config.GraphicsRenderer != MySandboxGame.DirectX9RendererKey;
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
private void InitializeRender()
{
try
{
if (Game.IsDedicated)
{
_renderer = new MyNullRender();
}
else
{
var graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
{
_renderer = new MyDX11Render();
if (!_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. No renderer to revert back to.");
_renderer = null;
}
}
if (_renderer == null)
{
throw new MyRenderException("The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
}
MyRenderProxy.Initialize(_renderer);
MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Render Initialization Failed");
Environment.Exit(-1);
}
}
private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. No renderer to revert back to.");
m_renderer = null;
}
}
if (m_renderer == null)
{
//hardcoded mesage becaouse of mytexts are not initialized yet
throw new MyRenderException(@"The current version of the game requires a Dx11 card. \n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
public static void Initialize(IMyRender render)
{
m_render = render;
}
static void RunInternal(string[] args)
{
using (MySteamService steamService = new MySteamService(MySandboxGame.IsDedicated, AppId))
{
IMyRender renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
if (MySandboxGame.IsDedicated)
{
renderer = new MyNullRender();
}
else if (MyFakes.ENABLE_DX11_RENDERER)
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
renderer = new MyDX11Render();
if (!renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. Reverting to DirectX 9.");
renderer = null;
}
}
if (renderer == null)
{
renderer = new MyDX9Render();
rendererId = MySandboxGame.DirectX9RendererKey;
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
else
{
renderer = new MyDX9Render();
}
MyFakes.ENABLE_PLANETS &= MySandboxGame.Config.GraphicsRenderer != MySandboxGame.DirectX9RendererKey;
VRageRender.MyRenderProxy.Initialize(renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyProgram.Init");
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MySteam.Init()");
if (!MySandboxGame.IsDedicated)
{
if (steamService.IsActive)
{
steamService.SetNotificationPosition(MySteamService.NotificationPosition.TopLeft);
MySandboxGame.Log.WriteLineAndConsole("Steam.IsActive: " + steamService.IsActive);
MySandboxGame.Log.WriteLineAndConsole("Steam.IsOnline: " + steamService.IsOnline);
MySandboxGame.Log.WriteLineAndConsole("Steam.OwnsGame: " + steamService.OwnsGame);
MySandboxGame.Log.WriteLineAndConsole("Steam.UserId: " + steamService.UserId);
MySandboxGame.Log.WriteLineAndConsole("Steam.UserName: "******"[n/a]");
MySandboxGame.Log.WriteLineAndConsole("Steam.Branch: " + steamService.BranchName ?? "[n/a]");
MySandboxGame.Log.WriteLineAndConsole("Build date: " + MySandboxGame.BuildDateTime.ToString("yyyy-MM-dd hh:mm", CultureInfo.InvariantCulture));
MySandboxGame.Log.WriteLineAndConsole("Build version: " + MySandboxGame.BuildVersion.ToString());
}
else if (MyFinalBuildConstants.IS_OFFICIAL) //We dont need Steam only in VS
{
if (!(steamService.IsActive && steamService.OwnsGame))
{
if (MyFakes.ENABLE_RUN_WITHOUT_STEAM == false)
{
MessageBoxWrapper("Steam is not running!", "Please run this game from Steam." + Environment.NewLine + "(restart Steam if already running)");
return;
}
}
}
else
{
if (!(steamService.IsActive && steamService.OwnsGame))
{
if (MyFakes.ENABLE_RUN_WITHOUT_STEAM == false)
{
MessageBoxWrapper("Steam is not running!", "Game might be unstable when run without Steam!");
}
}
}
}
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("new MySandboxGame()");
VRageGameServices services = new VRageGameServices(steamService);
if (!MySandboxGame.IsDedicated)
{
MyFileSystem.InitUserSpecific(steamService.UserId.ToString());
}
using (MySandboxGame game = new MySandboxGame(services, args))
{
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
game.Run(disposeSplashScreen: DisposeSplashScreen);
}
}
}
private void Create()
{
bool dedicated = Sandbox.Engine.Platform.Game.IsDedicated;
Environment.SetEnvironmentVariable("SteamAppId", _appSteamId.ToString());
MyServiceManager.Instance.AddService <IMyGameService>(new MySteamService(dedicated, _appSteamId));
if (dedicated && !MyGameService.HasGameServer)
{
_log.Warn("Steam service is not running! Please reinstall dedicated server.");
return;
}
SpaceEngineersGame.SetupBasicGameInfo();
SpaceEngineersGame.SetupPerGameSettings();
MyFinalBuildConstants.APP_VERSION = MyPerGameSettings.BasicGameInfo.GameVersion;
MySessionComponentExtDebug.ForceDisable = true;
MyPerGameSettings.SendLogToKeen = false;
// SpaceEngineersGame.SetupAnalytics();
MyFileSystem.ExePath = Path.GetDirectoryName(typeof(SpaceEngineersGame).Assembly.Location);
_tweakGameSettings();
MyFileSystem.Reset();
MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
// MyInitializer.InitCheckSum();
// Hook into the VRage plugin system for updates.
_getVRagePluginList().Add(_torch);
if (!MySandboxGame.IsReloading)
{
MyFileSystem.InitUserSpecific(dedicated ? null : MyGameService.UserId.ToString());
}
MySandboxGame.IsReloading = dedicated;
// render init
{
IMyRender renderer = null;
if (dedicated)
{
renderer = new MyNullRender();
}
else
{
MyPerformanceSettings preset = MyGuiScreenOptionsGraphics.GetPreset(MyRenderQualityEnum.NORMAL);
MyRenderProxy.Settings.User = MyVideoSettingsManager.GetGraphicsSettingsFromConfig(ref preset)
.PerformanceSettings.RenderSettings;
MyStringId graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
{
renderer = new MyDX11Render(new MyRenderSettings?(MyRenderProxy.Settings));
if (!renderer.IsSupported)
{
MySandboxGame.Log.WriteLine(
"DirectX 11 renderer not supported. No renderer to revert back to.");
renderer = null;
}
}
if (renderer == null)
{
throw new MyRenderException(
"The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html",
MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
}
MyRenderProxy.Initialize(renderer);
MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
// Loads object builder serializers. Intuitive, right?
_log.Info("Setting up serializers");
MyPlugins.RegisterGameAssemblyFile(MyPerGameSettings.GameModAssembly);
if (MyPerGameSettings.GameModBaseObjBuildersAssembly != null)
{
MyPlugins.RegisterBaseGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModBaseObjBuildersAssembly);
}
MyPlugins.RegisterGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModObjBuildersAssembly);
MyPlugins.RegisterSandboxAssemblyFile(MyPerGameSettings.SandboxAssembly);
MyPlugins.RegisterSandboxGameAssemblyFile(MyPerGameSettings.SandboxGameAssembly);
//typeof(MySandboxGame).GetMethod("Preallocate", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
MyGlobalTypeMetadata.Static.Init(false);
}
public static void Initialize(IMyRender render)
{
m_render = render;
UpdateDebugOverrides();
}
// Main method
static void Main(string[] args)
{
#if XB1
XB1Interface.XB1Interface.Init();
MyAssembly.Init();
#endif
SpaceEngineersGame.SetupBasicGameInfo();
m_startup = new MyCommonProgramStartup(args);
if (m_startup.PerformReporting())
{
return;
}
m_startup.PerformAutoconnect();
#if !XB1
if (!m_startup.CheckSingleInstance())
{
return;
}
#endif // !XB1
var appDataPath = m_startup.GetAppDataPath();
MyInitializer.InvokeBeforeRun(AppId, MyPerGameSettings.BasicGameInfo.ApplicationName, appDataPath);
MyInitializer.InitCheckSum();
m_startup.InitSplashScreen();
if (!m_startup.Check64Bit())
{
return;
}
m_startup.DetectSharpDxLeaksBeforeRun();
using (MySteamService steamService = new MySteamService(MySandboxGame.IsDedicated, AppId))
{
m_renderer = null;
SpaceEngineersGame.SetupPerGameSettings();
SpaceEngineersGame.SetupRender();
try
{
InitializeRender();
}
catch (MyRenderException ex)
{
#if !XB1
MessageBox.Show(ex.Message);
#else // XB1
System.Diagnostics.Debug.Assert(false, "InitializeRender failed");
#endif // XB1
return;
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MyProgram.Init");
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("MySteam.Init()");
if (!m_startup.CheckSteamRunning(steamService))
{
return;
}
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("new MySandboxGame()");
VRageGameServices services = new VRageGameServices(steamService);
if (!MySandboxGame.IsDedicated)
{
MyFileSystem.InitUserSpecific(steamService.UserId.ToString());
}
using (SpaceEngineersGame game = new SpaceEngineersGame(services, args))
{
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
VRageRender.MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
game.Run(disposeSplashScreen: m_startup.DisposeSplashScreen);
}
}
m_startup.DetectSharpDxLeaksAfterRun();
#if PROFILING
MyPerformanceTimer.WriteToLog();
#endif
MyInitializer.InvokeAfterRun();
}
private void Create()
{
bool dedicated = true;
Environment.SetEnvironmentVariable("SteamAppId", _appSteamId.ToString());
SpaceEngineersGame.SetupBasicGameInfo();
SpaceEngineersGame.SetupPerGameSettings();
MyFinalBuildConstants.APP_VERSION = MyPerGameSettings.BasicGameInfo.GameVersion;
MySessionComponentExtDebug.ForceDisable = true;
MyPerGameSettings.SendLogToKeen = false;
// SpaceEngineersGame.SetupAnalytics();
//not implemented by keen.. removed in cross-play update
//MyVRage.Platform.InitScripting(MyVRageScripting.Create());
_ = MyVRage.Platform.Scripting;
MyFileSystem.ExePath = Path.GetDirectoryName(typeof(SpaceEngineersGame).Assembly.Location);
_tweakGameSettings();
MyFileSystem.Reset();
MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
_log.Info("Loading Dedicated Config");
// object created in SpaceEngineersGame.SetupPerGameSettings()
MySandboxGame.ConfigDedicated.Load();
MyPlatformGameSettings.CONSOLE_COMPATIBLE = MySandboxGame.ConfigDedicated.ConsoleCompatibility;
//Type.GetType("VRage.Steam.MySteamService, VRage.Steam").GetProperty("IsActive").GetSetMethod(true).Invoke(service, new object[] {SteamAPI.Init()});
_log.Info("Initializing network services");
var isEos = TorchBase.Instance.Config.UgcServiceType == UGCServiceType.EOS;
if (isEos)
{
_log.Info("Running on Epic Online Services.");
_log.Warn("Steam workshop will not work with current settings. Some functions might not work properly!");
}
var aggregator = new MyServerDiscoveryAggregator();
MyServiceManager.Instance.AddService <IMyServerDiscovery>(aggregator);
IMyGameService service;
if (isEos)
{
service = MyEOSService.Create();
MyEOSService.InitNetworking(dedicated,
"Space Engineers",
service,
"xyza7891A4WeGrpP85BTlBa3BSfUEABN",
"ZdHZVevSVfIajebTnTmh5MVi3KPHflszD9hJB7mRkgg",
"24b1cd652a18461fa9b3d533ac8d6b5b",
"1958fe26c66d4151a327ec162e4d49c8",
"07c169b3b641401496d352cad1c905d6",
"https://retail.epicgames.com/",
MyEOSService.CreatePlatform(),
MySandboxGame.ConfigDedicated.VerboseNetworkLogging,
Enumerable.Empty <string>(),
aggregator,
MyMultiplayer.Channels);
var mockingInventory = new MyMockingInventory(service);
MyServiceManager.Instance.AddService <IMyInventoryService>(mockingInventory);
}
else
{
service = MySteamGameService.Create(dedicated, _appSteamId);
MyGameService.WorkshopService.AddAggregate(MySteamUgcService.Create(_appSteamId, service));
MySteamGameService.InitNetworking(dedicated,
service,
"Space Engineers",
aggregator);
}
MyServiceManager.Instance.AddService(service);
MyGameService.WorkshopService.AddAggregate(MyModIoService.Create(service, "spaceengineers", "264",
"1fb4489996a5e8ffc6ec1135f9985b5b", "331", "f2b64abe55452252b030c48adc0c1f0e",
MyPlatformGameSettings.UGC_TEST_ENVIRONMENT, true));
if (!isEos && !MyGameService.HasGameServer)
{
_log.Warn("Network service is not running! Please reinstall dedicated server.");
return;
}
_log.Info("Initializing services");
MyServiceManager.Instance.AddService <IMyMicrophoneService>(new MyNullMicrophone());
MyNetworkMonitor.Init();
_log.Info("Services initialized");
MySandboxGame.InitMultithreading();
// MyInitializer.InitCheckSum();
// Hook into the VRage plugin system for updates.
_getVRagePluginList().Add(_torch);
if (!MySandboxGame.IsReloading)
{
MyFileSystem.InitUserSpecific(dedicated ? null : MyGameService.UserId.ToString());
}
MySandboxGame.IsReloading = dedicated;
// render init
{
IMyRender renderer = null;
if (dedicated)
{
renderer = new MyNullRender();
}
else
{
MyPerformanceSettings preset = MyGuiScreenOptionsGraphics.GetPreset(MyRenderPresetEnum.NORMAL);
MyRenderProxy.Settings.User = MyVideoSettingsManager.GetGraphicsSettingsFromConfig(ref preset, false)
.PerformanceSettings.RenderSettings;
MyStringId graphicsRenderer = MySandboxGame.Config.GraphicsRenderer;
if (graphicsRenderer == MySandboxGame.DirectX11RendererKey)
{
renderer = new MyDX11Render(new MyRenderSettings?(MyRenderProxy.Settings));
if (!renderer.IsSupported)
{
MySandboxGame.Log.WriteLine(
"DirectX 11 renderer not supported. No renderer to revert back to.");
renderer = null;
}
}
if (renderer == null)
{
throw new MyRenderException(
"The current version of the game requires a Dx11 card. \\n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html",
MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = graphicsRenderer;
}
MyRenderProxy.Initialize(renderer);
MyRenderProfiler.SetAutocommit(false);
//This broke services?
//MyRenderProfiler.InitMemoryHack("MainEntryPoint");
}
// Loads object builder serializers. Intuitive, right?
_log.Info("Setting up serializers");
MyPlugins.RegisterGameAssemblyFile(MyPerGameSettings.GameModAssembly);
if (MyPerGameSettings.GameModBaseObjBuildersAssembly != null)
{
MyPlugins.RegisterBaseGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModBaseObjBuildersAssembly);
}
MyPlugins.RegisterGameObjectBuildersAssemblyFile(MyPerGameSettings.GameModObjBuildersAssembly);
MyPlugins.RegisterSandboxAssemblyFile(MyPerGameSettings.SandboxAssembly);
MyPlugins.RegisterSandboxGameAssemblyFile(MyPerGameSettings.SandboxGameAssembly);
//typeof(MySandboxGame).GetMethod("Preallocate", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
MyGlobalTypeMetadata.Static.Init(false);
}
public static void Initialize(IMyRender render)
{
m_render = render;
UpdateDebugOverrides();
ProfilerShort.SetProfiler(render.GetRenderProfiler());
}
private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else if (MyFakes.ENABLE_DX11_RENDERER)
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. Reverting to DirectX 9.");
m_renderer = null;
}
}
if (m_renderer == null)
{
//hardcoded mesage becaouse of mytexts are not initialized yet
throw new MyRenderException(@"The current version of the game requires a Dx11 card. If you would like to play the game without it, please select the Dx9-32bit BETA tab from properties. \n For more information please see : http://blog.marekrosa.org/2016/02/space-engineers-news-full-source-code_26.html", MyRenderExceptionEnum.GpuNotSupported);
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
else
{
m_renderer = new MyDX9Render();
}
MyFakes.ENABLE_PLANETS &= MySandboxGame.Config.GraphicsRenderer != MySandboxGame.DirectX9RendererKey;
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
private static void InitializeRender()
{
if (MySandboxGame.IsDedicated)
{
m_renderer = new MyNullRender();
}
else if (MyFakes.ENABLE_DX11_RENDERER)
{
var rendererId = MySandboxGame.Config.GraphicsRenderer;
if (rendererId == MySandboxGame.DirectX11RendererKey)
{
m_renderer = new MyDX11Render();
if (!m_renderer.IsSupported)
{
MySandboxGame.Log.WriteLine("DirectX 11 renderer not supported. Reverting to DirectX 9.");
m_renderer = null;
}
}
if (m_renderer == null)
{
m_renderer = new MyDX9Render();
rendererId = MySandboxGame.DirectX9RendererKey;
}
MySandboxGame.Config.GraphicsRenderer = rendererId;
}
else
{
m_renderer = new MyDX9Render();
}
MyFakes.ENABLE_PLANETS &= MySandboxGame.Config.GraphicsRenderer != MySandboxGame.DirectX9RendererKey;
VRageRender.MyRenderProxy.Initialize(m_renderer);
VRageRender.MyRenderProxy.IS_OFFICIAL = MyFinalBuildConstants.IS_OFFICIAL;
VRageRender.MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
VRageRender.MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
}
