Fix for issue #216 : engine exhaust and solar panel raycasts optimiza…

…tion

Optimization of raycasts in ModuleEngines.EngineExhaustDamage() and ModuleDeployableSolarPanel.CalculateTrackingLOS() :
- Only synchronize transforms on the first raycast from any module, mainly relevant when something else is moving transforms in between calls, which is often the case for active engines with gimbals.
- Cached ScaledSpace raycast results for solar panels : call time is divided by between 4 (when blocked by a scaled space object) and 2 (when not blocked)

GameData/KSPCommunityFixes/Settings.cfg

@@ -403,6 +403,10 @@ KSP_COMMUNITY_FIXES
   // Allow a min value of 0.02 instead of 0.03 for the "Max Physics Delta-Time Per Frame" main menu setting.
   LowerMinPhysicsDTPerFrame = true
 
+  // Improve engine exhaust damage and solar panel line of sight raycasts performance by avoiding extra physics
+  // state synchronization and caching solar panels scaled space raycasts results.
+  OptimizedModuleRaycasts = true
+
   // ##########################
   // Modding
   // ##########################

KSPCommunityFixes/KSPCommunityFixes.csproj

@@ -169,6 +169,7 @@
     <Compile Include="Modding\ReflectionTypeLoadExceptionHandler.cs" />
     <Compile Include="Performance\FewerSaves.cs" />
     <Compile Include="Performance\ConfigNodePerf.cs" />
+    <Compile Include="Performance\OptimizedModuleRaycasts.cs" />
     <Compile Include="Performance\PQSCoroutineLeak.cs" />
     <Compile Include="Performance\PQSUpdateNoMemoryAlloc.cs" />
     <Compile Include="Performance\ProgressTrackingSpeedBoost.cs" />

KSPCommunityFixes/Library/Extensions.cs

@@ -28,5 +28,10 @@ public static string AssemblyQualifiedName(this object obj)
             Type type = obj.GetType();
             return $"{type.Assembly.GetName().Name}:{type.Name}";
         }
+
+        public static bool IsPAWOpen(this Part part)
+        {
+            return part.PartActionWindow.IsNotNullOrDestroyed() && part.PartActionWindow.isActiveAndEnabled;
+        }
     }
 }

KSPCommunityFixes/Performance/OptimizedModuleRaycasts.cs

@@ -0,0 +1,152 @@
+using System;
+using HarmonyLib;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace KSPCommunityFixes.Performance
+{
+    internal class OptimizedModuleRaycasts : BasePatch
+    {
+        private static readonly WaitForFixedUpdate waitForFixedUpdate = new WaitForFixedUpdate();
+        private static bool partModulesSyncedOnceInFixedUpdate = false;
+
+        protected override Version VersionMin => new Version(1, 12, 3);
+
+        protected override void ApplyPatches(List<PatchInfo> patches)
+        {
+            patches.Add(
+                new PatchInfo(PatchMethodType.Transpiler,
+                    AccessTools.Method(typeof(ModuleEngines), nameof(ModuleEngines.EngineExhaustDamage)),
+                    this));
+
+            patches.Add(
+                new PatchInfo(PatchMethodType.Prefix,
+                    AccessTools.Method(typeof(ModuleDeployableSolarPanel), nameof(ModuleDeployableSolarPanel.CalculateTrackingLOS)),
+                    this));
+
+            KSPCommunityFixes.Instance.StartCoroutine(ResetSyncOnFixedEnd());
+        }
+
+        static IEnumerator ResetSyncOnFixedEnd()
+        {
+            while (true)
+            {
+                partModulesSyncedOnceInFixedUpdate = false;
+                lastVesselId = 0;
+                lastTrackingTransformId = 0;
+                yield return waitForFixedUpdate;
+            }
+        }
+
+        static IEnumerable<CodeInstruction> ModuleEngines_EngineExhaustDamage_Transpiler(IEnumerable<CodeInstruction> instructions)
+        {
+            MethodInfo m_Physics_RayCast = AccessTools.Method(typeof(Physics), nameof(Physics.Raycast), new[] { typeof(Vector3), typeof(Vector3), typeof(RaycastHit).MakeByRefType(), typeof(float), typeof(int) });
+            MethodInfo m_RaycastNoSync = AccessTools.Method(typeof(OptimizedModuleRaycasts), nameof(RaycastNoSync));
+
+            foreach (CodeInstruction instruction in instructions)
+            {
+                if (instruction.Calls(m_Physics_RayCast))
+                {
+                    instruction.operand = m_RaycastNoSync;
+                }
+
+                yield return instruction;
+            }
+        }
+
+        private static int lastVesselId;
+        private static int lastTrackingTransformId;
+        private static bool lastHasLoS;
+        private static string lastBlocker;
+
+        private static bool ModuleDeployableSolarPanel_CalculateTrackingLOS_Prefix(ModuleDeployableSolarPanel __instance, Vector3 trackingDirection, ref string blocker, out bool __result)
+        {
+            if (__instance.part.ShieldedFromAirstream && __instance.applyShielding)
+            {
+                blocker = "aero shielding";
+                __result = false;
+                return false;
+            }
+
+            int trackingTransformId = __instance.trackingTransformLocal.GetInstanceID();
+            int vesselId = __instance.vessel.GetInstanceID();
+            if (lastTrackingTransformId == trackingTransformId && lastVesselId == vesselId)
+            {
+                if (!lastHasLoS)
+                {
+                    __result = false;
+                    blocker = lastBlocker;
+                    return false;
+                }
+            }
+            else
+            {
+                lastTrackingTransformId = trackingTransformId;
+                lastVesselId = vesselId;
+
+                Vector3 scaledVesselPos = ScaledSpace.LocalToScaledSpace(__instance.vessel.transform.position);
+                Vector3 scaledDirection = (ScaledSpace.LocalToScaledSpace(__instance.trackingTransformLocal.position) - scaledVesselPos).normalized;
+
+                if (Physics.Raycast(scaledVesselPos, scaledDirection, out RaycastHit scaledHit, float.MaxValue, __instance.planetLayerMask) && scaledHit.transform.NotDestroyedRefNotEquals(__instance.trackingTransformScaled))
+                {
+                    __instance.hit = scaledHit; // just to ensure this is populated
+                    lastBlocker = scaledHit.transform.gameObject.name; // allocates a string
+                    blocker = lastBlocker;
+                    lastHasLoS = false;
+                    __result = false;
+                    return false;
+                }
+
+                lastHasLoS = true;
+                lastBlocker = null;
+            }
+
+            Vector3 localPanelPos = __instance.secondaryTransform.position + trackingDirection * __instance.raycastOffset;
+            __result = !RaycastNoSync(localPanelPos, trackingDirection, out RaycastHit localhit, float.MaxValue, __instance.defaultLayerMask);
+            __instance.hit = localhit; // just to ensure this is populated
+
+            if (!__result && __instance.part.IsPAWOpen() && localhit.transform.gameObject.IsNotNullOrDestroyed())
+            {
+                GameObject hitObject = localhit.transform.gameObject;
+                if (!ReferenceEquals(hitObject.GetComponent<PQ>(), null))
+                {
+                    blocker = ModuleDeployableSolarPanel.cacheAutoLOC_438839;
+                }
+                else
+                {
+                    Part partUpwardsCached = FlightGlobals.GetPartUpwardsCached(hitObject);
+                    if (partUpwardsCached.IsNotNullOrDestroyed())
+                    {
+                        blocker = partUpwardsCached.partInfo.title;
+                    }
+                    else
+                    {
+                        string tag = hitObject.tag; // allocates a string
+                        if (tag.Contains("KSC"))
+                            blocker = ResearchAndDevelopment.GetMiniBiomedisplayNameByUnityTag(tag, true);
+                        else
+                            blocker = hitObject.name;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool RaycastNoSync(Vector3 origin, Vector3 direction, out RaycastHit hitInfo, float maxDistance, int layerMask)
+        {
+            if (!partModulesSyncedOnceInFixedUpdate)
+            {
+                Physics.SyncTransforms();
+                partModulesSyncedOnceInFixedUpdate = true;
+            }
+
+            Physics.autoSyncTransforms = false;
+            bool result = Physics.defaultPhysicsScene.Raycast(origin, direction, out hitInfo, maxDistance, layerMask);
+            Physics.autoSyncTransforms = true;
+            return result;
+        }
+    }
+}

README.md

@@ -128,7 +128,7 @@ User options are available from the "ESC" in-game settings menu :<br/><img src="
 - **IMGUIOptimization** [KSP 1.8.0 - 1.12.5]<br/>Eliminate structural GC allocations and reduce performance overhead of OnGUI() methods. Can provide significant performance gains when having many mods using IMGUI heavily.
 - [**CollisionManagerFastUpdate**](https://github.com/KSPModdingLibs/KSPCommunityFixes/issues/174) [KSP 1.11.0 - 1.12.5]<br/>3-4 times faster update of parts inter-collision state, significantly reduce stutter on docking, undocking, decoupling and joint failure events.
 - [**LowerMinPhysicsDTPerFrame**](https://github.com/KSPModdingLibs/KSPCommunityFixes/issues/175) [KSP 1.12.3 - 1.12.5]<br/>Allow a min value of 0.02 instead of 0.03 for the "Max Physics Delta-Time Per Frame" main menu setting.  This allows for higher and smoother framerate at the expense of the game lagging behind real time.
-
+- [**OptimizedModuleRaycasts**](https://github.com/KSPModdingLibs/KSPCommunityFixes/issues/216) [KSP 1.12.3 - 1.12.5]<br/>Improve engine exhaust damage and solar panel line of sight raycasts performance by avoiding extra physics state synchronization and caching solar panels scaled space raycasts results.
 
 #### API and modding tools
 - **MultipleModuleInPartAPI** [KSP 1.8.0 - 1.12.5]<br/>This API allow other plugins to implement PartModules that can exist in multiple occurrence in a single part and won't suffer "module indexing mismatch" persistent data losses following part configuration changes. [See documentation on the wiki](https://github.com/KSPModdingLibs/KSPCommunityFixes/wiki/MultipleModuleInPartAPI).
@@ -189,6 +189,7 @@ If doing so in the `Debug` configuration and if your KSP install is modified to
 ### Changelog
 
 ##### 1.35.0
+- New KSP performance patch : [**OptimizedModuleRaycasts**](https://github.com/KSPModdingLibs/KSPCommunityFixes/issues/216) : Improve engine exhaust damage and solar panel line of sight raycasts performance by avoiding extra physics state synchronization and caching solar panels scaled space raycasts results.
 - **FastLoader** : Improved DDS loading performance by avoiding an extra copy of the DDS data
 
 ##### 1.34.1