private void Draw()
{
ProfilerShort.Begin("BeginScene");
MyRenderProxy.DrawBegin();
ProfilerShort.End();
ProfilerShort.Begin("Clear");
// TODO: OP! This should be done only to prevent weird things on screen, not every frame
MyRenderProxy.ClearBackbuffer(new ColorBGRA(0.0f));
MyRenderProxy.ClearLargeMessages();
ProfilerShort.End();
ProfilerShort.Begin("MyRenderProxy.Draw");
MyRenderProxy.Draw();
ProfilerShort.End();
if (m_separateThread)
{
MyRenderProxy.GetRenderProfiler().Commit();
}
MyRenderProxy.GetRenderProfiler().Draw();
ProfilerShort.Begin("EndScene");
MyRenderProxy.DrawEnd();
ProfilerShort.End();
}
public static void Commit()
{
if (MyRenderProxy.GetRenderProfiler() != null)
{
MyRenderProxy.GetRenderProfiler().Commit();
}
}
public static void DestroyThread()
{
if (MyRenderProxy.GetRenderProfiler() != null)
{
MyRenderProxy.GetRenderProfiler().DestroyThread();
}
}
protected override void CalculateTransforms(float distance)
{
ProfilerShort.Begin("MyCharacter.CalculateTransforms");
base.CalculateTransforms(distance);
if (m_headBoneIndex >= 0 && AnimationController.CharacterBones != null && (IsInFirstPersonView || ForceFirstPersonCamera) && ControllerInfo.IsLocallyControlled() && !IsBot)
{
Vector3 headHorizontalTranslation = AnimationController.CharacterBones[m_headBoneIndex].AbsoluteTransform.Translation;
headHorizontalTranslation.Y = 0;
MyCharacterBone.TranslateAllBones(AnimationController.CharacterBones, -headHorizontalTranslation);
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Calculate Hand IK");
if (this == MySession.Static.ControlledEntity)
{
// (OM) Note: only controlled character can get it's aimed point from camera, otherwise all character's will aim the same direction
// set the aimed point explicitly using AimedPoint property
m_aimedPoint = GetAimedPointFromCamera();
}
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("Update anim IK");
AnimationController.UpdateInverseKinematics(); // since we already have absolute transforms
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("UpdateLeftHandItemPosition");
if (m_leftHandItem != null)
{
UpdateLeftHandItemPosition();
}
if (m_currentWeapon != null && WeaponPosition != null && m_handItemDefinition != null)
{
WeaponPosition.Update();
//mainly IK and some zoom + ironsight stuff
if (m_handItemDefinition.SimulateLeftHand && m_leftHandIKStartBone != -1 && m_leftHandIKEndBone != -1)
{
MatrixD leftHand = (MatrixD)m_handItemDefinition.LeftHand * ((MyEntity)m_currentWeapon).WorldMatrix;
CalculateHandIK(m_leftHandIKStartBone, m_leftForearmBone, m_leftHandIKEndBone, ref leftHand);
}
if (m_handItemDefinition.SimulateRightHand && m_rightHandIKStartBone != -1 && m_rightHandIKEndBone != -1 && IsSitting == false)
{
MatrixD rightHand = (MatrixD)m_handItemDefinition.RightHand * ((MyEntity)m_currentWeapon).WorldMatrix;
CalculateHandIK(m_rightHandIKStartBone, m_rightForearmBone, m_rightHandIKEndBone, ref rightHand);
}
}
MyRenderProxy.GetRenderProfiler().StartNextBlock("UpdateTransformations");
AnimationController.UpdateTransformations();
MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
ProfilerShort.End();
}
public static void ReceiveProfiler(byte[] profilerData)
{
MemoryStream reader = new MemoryStream(profilerData);
try
{
MyObjectBuilder_ProfilerSnapshot snapshot;
MyObjectBuilderSerializer.DeserializeGZippedXML <MyObjectBuilder_ProfilerSnapshot>(reader, out snapshot);
snapshot.Init(MyRenderProxy.GetRenderProfiler(), VRage.Profiler.SnapshotType.Server, false);
MyMultiplayer.Static.ProfilerDone.InvokeIfNotNull <string>("ProfilerDownload: Done.");
}
catch
{
MyMultiplayer.Static.ProfilerDone.InvokeIfNotNull <string>("ProfilerDownload: Could not parse data.");
}
}
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);
}
}
protected virtual void CalculateTransforms(float distance)
{
ProfilerShort.Begin("MySkinnedEntity.CalculateTransforms");
VRageRender.MyRenderProxy.GetRenderProfiler().StartProfilingBlock("Clear bones");
//foreach (var bone in Bones)
//{
// bone.Translation = Vector3.Zero;
// bone.Rotation = Quaternion.Identity;
//}
VRageRender.MyRenderProxy.GetRenderProfiler().StartNextBlock("Update bones");
if (!UseNewAnimationSystem)
{
UpdateBones(distance);
}
MyRenderProxy.GetRenderProfiler().StartNextBlock("UpdateTransformations");
AnimationController.UpdateTransformations();
MyRenderProxy.GetRenderProfiler().EndProfilingBlock();
ProfilerShort.End();
}
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 CustomValue(string name, float value, float customTimeMs, string timeFormat = null, string valueFormat = null, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0, [CallerFilePath] string file = "")
{
MyRenderProxy.GetRenderProfiler().ProfileCustomValue(name, value, MyTimeSpan.FromMiliseconds(customTimeMs), timeFormat, valueFormat, member, line, file);
}
public static void End(float customValue = 0, MyTimeSpan?customTime = null, string timeFormat = null, string valueFormat = null, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0, [CallerFilePath] string file = "")
{
MyRenderProxy.GetRenderProfiler().EndProfilingBlock(customValue, customTime, timeFormat, valueFormat, member, line, file);
}
public static void BeginNextBlock(string blockName = null, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0, [CallerFilePath] string file = "")
{
MyRenderProxy.GetRenderProfiler().StartNextBlock(blockName, member, line, file);
}
public static void Begin(string blockName = null, float customValue = 0, [CallerMemberName] string member = "", [CallerLineNumber] int line = 0, [CallerFilePath] string file = "")
{
MyRenderProxy.GetRenderProfiler().StartProfilingBlock(blockName, customValue, member, line, file);
}
private void RenderCallback()
{
if (m_messageProcessingStart != MyTimeSpan.Zero)
{
MyTimeSpan messageQueueDuration = m_timer.Elapsed - m_messageProcessingStart;
ProfilerShort.CustomValue("MessageQueue", 0, messageQueueDuration);
}
ProfilerShort.Begin("Wait");
m_waiter.Wait();
ProfilerShort.End();
m_frameStart = m_timer.Elapsed;
ProfilerShort.Begin("PrepareDraw");
ProfilerShort.Begin("ProcessInvoke");
Action action;
while (m_invokeQueue.TryDequeue(out action))
{
action();
}
ProfilerShort.End();
ProfilerShort.Begin("ApplyModeChanges");
ApplySettingsChanges();
ProfilerShort.End();
ProfilerShort.Begin("BeforeRender");
MyRenderStats.Generic.WriteFormat("Available GPU memory: {0} MB", (float)MyRenderProxy.GetAvailableTextureMemory() / 1024 / 1024, MyStatTypeEnum.CurrentValue, 300, 2);
MyRenderProxy.BeforeRender(m_frameStart);
ProfilerShort.End();
ProfilerShort.Begin("RenderWindow.BeforeDraw");
m_renderWindow.BeforeDraw();
ProfilerShort.End();
ProfilerShort.Begin("BeforeDraw(event)");
if (BeforeDraw != null)
{
BeforeDraw();
}
ProfilerShort.End();
ProfilerShort.End();
ProfilerShort.Begin("Draw");
ProfilerShort.Begin("TestCooperativeLevel");
var deviceResult = MyRenderProxy.TestDeviceCooperativeLevel();
ProfilerShort.End();
if (!m_renderWindow.DrawEnabled)
{
ProfilerShort.Begin("ProcessMessages");
MyRenderProxy.ProcessMessages();
ProfilerShort.End();
}
else if (deviceResult == MyRenderDeviceCooperativeLevel.Ok)
{
Draw();
}
else
{
ProfilerShort.Begin("WaitForReset");
ProfilerShort.Begin("ProcessMessages");
MyRenderProxy.ProcessMessages();
ProfilerShort.End();
if (deviceResult == MyRenderDeviceCooperativeLevel.Lost)
{
ProfilerShort.Begin("DeviceLost");
Thread.Sleep(20);
ProfilerShort.End();
}
else if (deviceResult == MyRenderDeviceCooperativeLevel.NotReset)
{
ProfilerShort.Begin("DeviceReset");
Thread.Sleep(20);
DeviceReset();
ProfilerShort.End();
}
else
{
// TODO: OP! Log error code
}
ProfilerShort.End();
}
ProfilerShort.End();
ProfilerShort.Begin("AfterRender");
MyRenderProxy.AfterRender();
ProfilerShort.End();
ProfilerShort.Begin("Present");
if (deviceResult == MyRenderDeviceCooperativeLevel.Ok && m_renderWindow.DrawEnabled)
{
this.DoBeforePresent();
try
{
MyRenderProxy.Present();
}
catch (MyDeviceLostException)
{
}
this.DoAfterPresent();
}
ProfilerShort.End();
if (m_separateThread)
{
MyRenderProxy.GetRenderProfiler().Commit();
}
m_messageProcessingStart = m_timer.Elapsed;
}
private void ProfilerRequestAsync(WorkData data)
{
ProfilerData data2 = data as ProfilerData;
try
{
VRage.Profiler.MyRenderProfiler.AddPause(false);
MemoryStream writeTo = new MemoryStream();
MyObjectBuilderSerializer.SerializeXML(writeTo, MyObjectBuilder_ProfilerSnapshot.GetObjectBuilder(MyRenderProxy.GetRenderProfiler()), MyObjectBuilderSerializer.XmlCompression.Gzip, null);
data2.Buffer = writeTo.ToArray();
MyLog.Default.WriteLine("Profiler for " + MySession.Static.Players.TryGetIdentityNameFromSteamId(data2.Sender.Value) + " serialized");
}
catch
{
MyLog.Default.WriteLine("Profiler serialization for " + MySession.Static.Players.TryGetIdentityNameFromSteamId(data2.Sender.Value) + " crashed");
}
}
// This is mostly copied from MyProgram.Main(), with UI stripped out.
protected virtual void InitSandbox(string[] args)
{
m_args = args;
// Infinario was removed from SE in update 1.184.6, but is still in ME
var infinario = typeof(MyFakes).GetField("ENABLE_INFINARIO");
if (infinario != null)
{
infinario.SetValue(null, false);
}
if (m_game != null)
{
m_game.Exit();
}
if (!SetupBasicGameInfo())
{
return;
}
// Init null render so profiler-enabled builds don't crash
var render = new MyNullRender();
MyRenderProxy.Initialize(render);
#if SE
EmptyKeys.UserInterface.Engine engine = (EmptyKeys.UserInterface.Engine) new VRage.UserInterface.MyEngine();
if (System.Diagnostics.Debugger.IsAttached)
{
m_startup.CheckSteamRunning(); // Just give the warning message box when debugging, ignore for release
}
if (!Sandbox.Engine.Platform.Game.IsDedicated)
{
MyFileSystem.InitUserSpecific(m_steamService.UserId.ToString());
}
#endif
try
{
#if !SE
MyRenderProxy.GetRenderProfiler().SetAutocommit(false);
MyRenderProxy.GetRenderProfiler().InitMemoryHack("MainEntryPoint");
#endif
// NOTE: an assert may be thrown in debug, about missing Tutorials.sbx. Ignore it.
m_game = InitGame();
// Initializing the workshop means the categories are available
var initWorkshopMethod = m_game.GetType().GetMethod("InitSteamWorkshop", BindingFlags.NonPublic | BindingFlags.Instance);
MyDebug.AssertRelease(initWorkshopMethod != null);
if (initWorkshopMethod != null)
{
var parameters = initWorkshopMethod.GetParameters();
MyDebug.AssertRelease(parameters.Count() == 0);
}
if (initWorkshopMethod != null)
{
initWorkshopMethod.Invoke(m_game, null);
}
else
{
MySandboxGame.Log.WriteLineAndConsole(string.Format(Constants.ERROR_Reflection, "InitSteamWorkshop"));
}
}
catch (Exception ex)
{
// This shouldn't fail, but don't stop even if it does
ex.Log("WARNING: An exception occured, ignoring: ");
}
AuthenticateWorkshop();
}
public static void Commit()
{
MyRenderProxy.GetRenderProfiler().Commit();
}