Return of DesktopHeadTracking

ml_dht/HeadTracked.cs

@@ -0,0 +1,144 @@
+using ABI.CCK.Components;
+using ABI_RC.Core.Player;
+using RootMotion.FinalIK;
+using System.Reflection;
+using UnityEngine;
+using ViveSR.anipal.Lip;
+
+namespace ml_dht
+{
+    [DisallowMultipleComponent]
+    class HeadTracked : MonoBehaviour
+    {
+        static FieldInfo ms_emotePlaying = typeof(PlayerSetup).GetField("_emotePlaying", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        bool m_enabled = false;
+        bool m_headTracking = true;
+        float m_smoothing = 0.5f;
+
+        CVRAvatar m_avatarDescriptor = null;
+        Transform m_camera = null;
+        LookAtIK m_lookIK = null;
+        Transform m_headBone = null;
+
+        Vector3 m_headPosition;
+        Quaternion m_headRotation;
+        Vector2 m_gazeDirection;
+        float m_blinkProgress = 0f;
+
+        Quaternion m_bindRotation;
+        Quaternion m_lastHeadRotation;
+
+        // Unity events
+        void Start()
+        {
+            SetEnabled(Settings.Enabled);
+            SetHeadTracking(Settings.HeadTracking);
+            SetSmoothing(Settings.Smoothing);
+
+            Settings.EnabledChange += this.SetEnabled;
+            Settings.HeadTrackingChange += this.SetHeadTracking;
+            Settings.SmoothingChange += this.SetSmoothing;
+        }
+
+        void OnDestroy()
+        {
+            Settings.EnabledChange -= this.SetEnabled;
+            Settings.HeadTrackingChange -= this.SetHeadTracking;
+            Settings.SmoothingChange -= this.SetSmoothing;
+        }
+
+        // Tracking updates
+        public void UpdateTrackingData(ref TrackingData p_data)
+        {
+            m_headPosition.Set(p_data.m_headPositionX * (Settings.Mirrored ? -1f : 1f), p_data.m_headPositionY, p_data.m_headPositionZ);
+            m_headRotation.Set(p_data.m_headRotationX, p_data.m_headRotationY * (Settings.Mirrored ? -1f : 1f), p_data.m_headRotationZ * (Settings.Mirrored ? -1f : 1f), p_data.m_headRotationW);
+            m_gazeDirection.Set(Settings.Mirrored ? (1f - p_data.m_gazeX) : p_data.m_gazeX, p_data.m_gazeY);
+            m_blinkProgress = p_data.m_blink;
+        }
+
+        void OnLookIKPostUpdate()
+        {
+            if(m_enabled && m_headTracking && (m_headBone != null))
+            {
+                m_lastHeadRotation = Quaternion.Slerp(m_lastHeadRotation, m_avatarDescriptor.transform.rotation * (m_headRotation * m_bindRotation), m_smoothing);
+
+                if(!(bool)ms_emotePlaying.GetValue(PlayerSetup.Instance))
+                    m_headBone.rotation = m_lastHeadRotation;
+            }
+        }
+
+        // Game events
+        internal void OnSetupAvatar()
+        {
+            m_camera = PlayerSetup.Instance.GetActiveCamera().transform;
+            m_avatarDescriptor = PlayerSetup.Instance._avatar.GetComponent<CVRAvatar>();
+            m_headBone = PlayerSetup.Instance._animator.GetBoneTransform(HumanBodyBones.Head);
+            m_lookIK = PlayerSetup.Instance._avatar.GetComponent<LookAtIK>();
+
+            if(m_headBone != null)
+                m_bindRotation = (m_avatarDescriptor.transform.GetMatrix().inverse * m_headBone.GetMatrix()).rotation;
+
+            if(m_lookIK != null)
+                m_lookIK.solver.OnPostUpdate += this.OnLookIKPostUpdate;
+
+        }
+        internal void OnAvatarClear()
+        {
+            m_avatarDescriptor = null;
+            m_lookIK = null;
+            m_headBone = null;
+            m_lastHeadRotation = Quaternion.identity;
+            m_bindRotation = Quaternion.identity;
+        }
+
+        internal void OnEyeControllerUpdate(CVREyeController p_component)
+        {
+            if(m_enabled)
+            {
+                // Gaze
+                if(Settings.EyeTracking && (m_camera != null))
+                {
+                    p_component.manualViewTarget = true;
+                    p_component.targetViewPosition = m_camera.position + m_camera.rotation * new Vector3((m_gazeDirection.x - 0.5f) * 2f, (m_gazeDirection.y - 0.5f) * 2f, 1f);
+                }
+
+                // Blink
+                if(Settings.Blinking)
+                {
+                    p_component.manualBlinking = true;
+                    p_component.blinkProgress = m_blinkProgress;
+                }
+            }
+        }
+
+        // Settings
+        void SetEnabled(bool p_state)
+        {
+            if(m_enabled != p_state)
+            {
+                m_enabled = p_state;
+                TryRestoreHeadRotation();
+            }
+        }
+        void SetHeadTracking(bool p_state)
+        {
+            if(m_headTracking != p_state)
+            {
+                m_headTracking = p_state;
+                TryRestoreHeadRotation();
+            }
+        }
+        void SetSmoothing(float p_value)
+        {
+            m_smoothing = 1f - Mathf.Clamp(p_value, 0f, 0.99f);
+        }
+
+        // Arbitrary
+        void TryRestoreHeadRotation()
+        {
+            if(m_enabled && m_headTracking)
+                m_lastHeadRotation = ((m_headBone != null) ? m_headBone.rotation : m_bindRotation);
+        }
+    }
+}

ml_dht/Main.cs

@@ -0,0 +1,119 @@
+using ABI_RC.Core.Player;
+using ABI_RC.Core.Savior;
+using ABI_RC.Systems.FaceTracking;
+using System.Reflection;
+
+namespace ml_dht
+{
+    public class DesktopHeadTracking : MelonLoader.MelonMod
+    {
+        static DesktopHeadTracking ms_instance = null;
+
+        TrackingModule m_trackingModule = null;
+        HeadTracked m_localTracked = null;
+
+        public override void OnInitializeMelon()
+        {
+            if(ms_instance == null)
+                ms_instance = this;
+
+            Settings.Init();
+
+            m_trackingModule = new TrackingModule();
+
+            // Patches
+            HarmonyInstance.Patch(
+                typeof(PlayerSetup).GetMethod(nameof(PlayerSetup.ClearAvatar)),
+                null,
+                new HarmonyLib.HarmonyMethod(typeof(DesktopHeadTracking).GetMethod(nameof(OnAvatarClear_Postfix), BindingFlags.Static | BindingFlags.NonPublic))
+            );
+            HarmonyInstance.Patch(
+                typeof(PlayerSetup).GetMethod(nameof(PlayerSetup.SetupAvatar)),
+                null,
+                new HarmonyLib.HarmonyMethod(typeof(DesktopHeadTracking).GetMethod(nameof(OnSetupAvatar_Postfix), BindingFlags.Static | BindingFlags.NonPublic))
+            );
+
+            MelonLoader.MelonCoroutines.Start(WaitForInstances());
+        }
+
+        System.Collections.IEnumerator WaitForInstances()
+        {
+            while(MetaPort.Instance == null)
+                yield return null;
+
+            while(PlayerSetup.Instance == null)
+                yield return null;
+
+            m_localTracked = PlayerSetup.Instance.gameObject.AddComponent<HeadTracked>();
+            FaceTrackingManager.Instance.RegisterModule(m_trackingModule);
+
+            // If you think it's a joke to put patch here, go on, try to put it in OnInitializeMelon, you melon :>
+            HarmonyInstance.Patch(
+                typeof(CVREyeController).GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic),
+                null,
+                new HarmonyLib.HarmonyMethod(typeof(DesktopHeadTracking).GetMethod(nameof(OnEyeControllerUpdate_Postfix), BindingFlags.Static | BindingFlags.NonPublic))
+            );
+        }
+
+        public override void OnDeinitializeMelon()
+        {
+            if(ms_instance == this)
+                ms_instance = null;
+
+            m_trackingModule = null;
+            m_localTracked = null;
+        }
+
+        public override void OnUpdate()
+        {
+            if(Settings.Enabled && (m_trackingModule != null))
+            {
+                m_trackingModule.Update();
+                if(m_localTracked != null)
+                    m_localTracked.UpdateTrackingData(ref m_trackingModule.GetLatestTrackingData());
+            }
+        }
+
+        static void OnSetupAvatar_Postfix() => ms_instance?.OnSetupAvatar();
+        void OnSetupAvatar()
+        {
+            try
+            {
+                if(m_localTracked != null)
+                    m_localTracked.OnSetupAvatar();
+            }
+            catch(System.Exception e)
+            {
+                MelonLoader.MelonLogger.Error(e);
+            }
+        }
+
+        static void OnAvatarClear_Postfix() => ms_instance?.OnAvatarClear();
+        void OnAvatarClear()
+        {
+            try
+            {
+                if(m_localTracked != null)
+                    m_localTracked.OnAvatarClear();
+            }
+            catch(System.Exception e)
+            {
+                MelonLoader.MelonLogger.Error(e);
+            }
+        }
+
+        static void OnEyeControllerUpdate_Postfix(ref CVREyeController __instance) => ms_instance?.OnEyeControllerUpdate(__instance);
+        void OnEyeControllerUpdate(CVREyeController p_component)
+        {
+            try
+            {
+                if(p_component.isLocal && (m_localTracked != null))
+                    m_localTracked.OnEyeControllerUpdate(p_component);
+            }
+            catch(System.Exception e)
+            {
+                MelonLoader.MelonLogger.Error(e);
+            }
+        }
+    }
+}

ml_dht/MemoryMapReader.cs

@@ -0,0 +1,55 @@
+using System.IO;
+using System.IO.MemoryMappedFiles;
+
+namespace ml_dht
+{
+    class MemoryMapReader
+    {
+        MemoryMappedFile m_file = null;
+        MemoryMappedViewStream m_stream = null;
+        int m_dataSize = 0;
+
+        public bool Open(string p_path, int p_dataSize = 1024)
+        {
+            if(m_file == null)
+            {
+                m_dataSize = p_dataSize;
+
+                m_file = MemoryMappedFile.CreateOrOpen(p_path, m_dataSize, MemoryMappedFileAccess.ReadWrite);
+                m_stream = m_file.CreateViewStream(0, m_dataSize, MemoryMappedFileAccess.Read);
+            }
+            return (m_file != null);
+        }
+
+        public bool Read(ref byte[] p_data)
+        {
+            bool l_result = false;
+            if((m_stream != null) && m_stream.CanRead)
+            {
+                try
+                {
+                    m_stream.Seek(0, SeekOrigin.Begin);
+                    m_stream.Read(p_data, 0, (p_data.Length > m_dataSize) ? m_dataSize : p_data.Length);
+                    l_result = true;
+                }
+                catch(System.Exception) { }
+            }
+            return l_result;
+        }
+
+        public void Close()
+        {
+            if(m_file != null)
+            {
+                m_stream.Close();
+                m_stream.Dispose();
+                m_stream = null;
+
+                m_file.Dispose();
+                m_file = null;
+
+                m_dataSize = 0;
+            }
+        }
+    }
+}

ml_dht/Properties/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+[assembly: MelonLoader.MelonInfo(typeof(ml_dht.DesktopHeadTracking), "DesktopHeadTracking", "1.2.0", "SDraw", "https://github.com/SDraw/ml_mods_cvr")]
+[assembly: MelonLoader.MelonGame(null, "ChilloutVR")]
+[assembly: MelonLoader.MelonPlatform(MelonLoader.MelonPlatformAttribute.CompatiblePlatforms.WINDOWS_X64)]
+[assembly: MelonLoader.MelonPlatformDomain(MelonLoader.MelonPlatformDomainAttribute.CompatibleDomains.MONO)]

ml_dht/README.md

@@ -0,0 +1,31 @@
+# Desktop Head Tracking
+This mod adds desktop head tracking based on data from memory-mapped file `head/data`.  
+Refer to `TrackingData.cs` for reference in case of implementing own software.
+
+[![](.github/img_01.png)](https://youtu.be/jgcFhSNi9DM)
+
+# Features
+* Head rotation
+* Eyes gaze direction
+* Basic mouth shapes: open, smile and pout
+* Blinking
+
+# Installation
+* Install [latest MelonLoader](https://github.com/LavaGang/MelonLoader)
+* Get [latest release DLL](../../../releases/latest):
+  * Put `ml_dht.dll` in `Mods` folder of game
+
+# Usage
+Available mod's settings in `Settings - Implementation - Desktop Head Tracking`:
+* **Enabled:** enables mod's activity; default value - `false`.
+* **Use head tracking:** enables head tracking; default value - `true`.
+* **Use eyes tracking:** enables eyes tracking; default value - `true`.
+* **Use face tracking:** enables mouth shapes tracking; default value - `true`.
+  * **Note:** You need to enable desktop tracking of `Vive Face tracking` in `Settings - Implementation` menu page.
+  * **Note:** Your avatar should have configured `CVR Face Tracking` component.
+* **Use blinking:** uses blinking from data; default value - `true`.
+* **Mirrored movement:** mirrors movement and gaze along 0YZ plane; default value - `false`.
+* **Movement smoothing:** smoothing factor between new and old movement data; default value - `50`.
+
+# Known compatible tracking software
+* [VSeeFace](https://www.vseeface.icu) with [Tracking Data Parser mod](https://github.com/SDraw/ml_mods_vsf)

ml_dht/ResourcesHandler.cs

@@ -0,0 +1,26 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+namespace ml_dht
+{
+    static class ResourcesHandler
+    {
+        public static string GetEmbeddedResource(string p_name)
+        {
+            string l_result = "";
+            Assembly l_assembly = Assembly.GetExecutingAssembly();
+            string l_assemblyName = l_assembly.GetName().Name;
+
+            try
+            {
+                Stream l_libraryStream = l_assembly.GetManifestResourceStream(l_assemblyName + ".resources." + p_name);
+                StreamReader l_streadReader = new StreamReader(l_libraryStream);
+                l_result = l_streadReader.ReadToEnd();
+            }
+            catch(Exception) { }
+
+            return l_result;
+        }
+    }
+}

ml_dht/Settings.cs

@@ -0,0 +1,160 @@
+using ABI_RC.Core.InteractionSystem;
+using System;
+using System.Collections.Generic;
+
+namespace ml_dht
+{
+    static class Settings
+    {
+        enum ModSetting
+        {
+            Enabled = 0,
+            HeadTracking,
+            EyeTracking,
+            FaceTracking,
+            Blinking,
+            Mirrored,
+            Smoothing,
+        }
+
+        public static bool Enabled { get; private set; } = false;
+        public static bool HeadTracking { get; private set; } = true;
+        public static bool EyeTracking { get; private set; } = true;
+        public static bool FaceTracking { get; private set; } = true;
+        public static bool Blinking { get; private set; } = true;
+        public static bool Mirrored { get; private set; } = false;
+        public static float Smoothing { get; private set; } = 0.5f;
+
+        static MelonLoader.MelonPreferences_Category ms_category = null;
+        static List<MelonLoader.MelonPreferences_Entry> ms_entries = null;
+
+        static public event Action<bool> EnabledChange;
+        static public event Action<bool> HeadTrackingChange;
+        static public event Action<bool> EyeTrackingChange;
+        static public event Action<bool> FaceTrackingChange;
+        static public event Action<bool> BlinkingChange;
+        static public event Action<bool> MirroredChange;
+        static public event Action<float> SmoothingChange;
+        
+
+        internal static void Init()
+        {
+            ms_category = MelonLoader.MelonPreferences.CreateCategory("DHT");
+
+            ms_entries = new List<MelonLoader.MelonPreferences_Entry>()
+            {
+                ms_category.CreateEntry(ModSetting.Enabled.ToString(), Enabled),
+                ms_category.CreateEntry(ModSetting.HeadTracking.ToString(), HeadTracking),
+                ms_category.CreateEntry(ModSetting.EyeTracking.ToString(), EyeTracking),
+                ms_category.CreateEntry(ModSetting.FaceTracking.ToString(), FaceTracking),
+                ms_category.CreateEntry(ModSetting.Blinking.ToString(), Blinking),
+                ms_category.CreateEntry(ModSetting.Mirrored.ToString(), Mirrored),
+                ms_category.CreateEntry(ModSetting.Smoothing.ToString(), (int)(Smoothing * 50f)),
+            };
+
+            Enabled = (bool)ms_entries[(int)ModSetting.Enabled].BoxedValue;
+            HeadTracking = (bool)ms_entries[(int)ModSetting.HeadTracking].BoxedValue;
+            EyeTracking = (bool)ms_entries[(int)ModSetting.EyeTracking].BoxedValue;
+            FaceTracking = (bool)ms_entries[(int)ModSetting.FaceTracking].BoxedValue;
+            Blinking = (bool)ms_entries[(int)ModSetting.Blinking].BoxedValue;
+            Mirrored = (bool)ms_entries[(int)ModSetting.Mirrored].BoxedValue;
+            Smoothing = ((int)ms_entries[(int)ModSetting.Smoothing].BoxedValue) * 0.01f;
+
+            MelonLoader.MelonCoroutines.Start(WaitMainMenuUi());
+        }
+
+        static System.Collections.IEnumerator WaitMainMenuUi()
+        {
+            while(ViewManager.Instance == null)
+                yield return null;
+            while(ViewManager.Instance.gameMenuView == null)
+                yield return null;
+            while(ViewManager.Instance.gameMenuView.Listener == null)
+                yield return null;
+
+            ViewManager.Instance.gameMenuView.Listener.ReadyForBindings += () =>
+            {
+                ViewManager.Instance.gameMenuView.View.BindCall("OnToggleUpdate_" + ms_category.Identifier, new Action<string, string>(OnToggleUpdate));
+                ViewManager.Instance.gameMenuView.View.BindCall("OnSliderUpdate_" + ms_category.Identifier, new Action<string, string>(OnSliderUpdate));
+            };
+            ViewManager.Instance.gameMenuView.Listener.FinishLoad += (_) =>
+            {
+                ViewManager.Instance.gameMenuView.View.ExecuteScript(ResourcesHandler.GetEmbeddedResource("mods_extension.js"));
+                ViewManager.Instance.gameMenuView.View.ExecuteScript(ResourcesHandler.GetEmbeddedResource("mod_menu.js"));
+                foreach(var l_entry in ms_entries)
+                    ViewManager.Instance.gameMenuView.View.TriggerEvent("updateModSetting", ms_category.Identifier, l_entry.DisplayName, l_entry.GetValueAsString());
+            };
+        }
+
+        static void OnSliderUpdate(string p_name, string p_value)
+        {
+            if(Enum.TryParse(p_name, out ModSetting l_setting))
+            {
+                switch(l_setting)
+                {
+                    case ModSetting.Smoothing:
+                    {
+                        Smoothing = int.Parse(p_value) * 0.01f;
+                        SmoothingChange?.Invoke(Smoothing);
+                    }
+                    break;
+                }
+
+                ms_entries[(int)l_setting].BoxedValue = int.Parse(p_value);
+            }
+        }
+
+        static void OnToggleUpdate(string p_name, string p_value)
+        {
+            if(Enum.TryParse(p_name, out ModSetting l_setting))
+            {
+                switch(l_setting)
+                {
+                    case ModSetting.Enabled:
+                    {
+                        Enabled = bool.Parse(p_value);
+                        EnabledChange?.Invoke(Enabled);
+                    }
+                    break;
+
+                    case ModSetting.HeadTracking:
+                    {
+                        HeadTracking = bool.Parse(p_value);
+                        HeadTrackingChange?.Invoke(HeadTracking);
+                    }
+                    break;
+
+                    case ModSetting.EyeTracking:
+                    {
+                        EyeTracking = bool.Parse(p_value);
+                        EyeTrackingChange?.Invoke(EyeTracking);
+                    }
+                    break;
+
+                    case ModSetting.FaceTracking:
+                    {
+                        FaceTracking = bool.Parse(p_value);
+                        FaceTrackingChange?.Invoke(FaceTracking);
+                    }
+                    break;
+
+                    case ModSetting.Blinking:
+                    {
+                        Blinking = bool.Parse(p_value);
+                        BlinkingChange?.Invoke(Blinking);
+                    }
+                    break;
+
+                    case ModSetting.Mirrored:
+                    {
+                        Mirrored = bool.Parse(p_value);
+                        MirroredChange?.Invoke(Mirrored);
+                    }
+                    break;
+                }
+
+                ms_entries[(int)l_setting].BoxedValue = bool.Parse(p_value);
+            }
+        }
+    }
+}

ml_dht/TrackingData.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Runtime.InteropServices;
+
+struct TrackingData
+{
+    public float m_headPositionX; // Not used yet
+    public float m_headPositionY; // Not used yet
+    public float m_headPositionZ; // Not used yet
+    public float m_headRotationX;
+    public float m_headRotationY;
+    public float m_headRotationZ;
+    public float m_headRotationW;
+    public float m_gazeX; // Range - [0;1], 0.5 - center
+    public float m_gazeY; // Range - [0;1], 0.5 - center
+    public float m_blink; // Range - [0;1], 1.0 - closed
+    public float m_mouthOpen; // Range - [0;1]
+    public float m_mouthShape; // Range - [-1;1], -1 - wide, 1 - narrow
+    public float m_brows; // Range - [-1;1], -1 - up, 1 - down; not used yet
+
+    static public byte[] ToBytes(TrackingData p_faceData)
+    {
+        int l_size = Marshal.SizeOf(p_faceData);
+        byte[] l_arr = new byte[l_size];
+
+        IntPtr ptr = Marshal.AllocHGlobal(l_size);
+        Marshal.StructureToPtr(p_faceData, ptr, true);
+        Marshal.Copy(ptr, l_arr, 0, l_size);
+        Marshal.FreeHGlobal(ptr);
+        return l_arr;
+    }
+
+    static public TrackingData ToObject(byte[] p_buffer)
+    {
+        TrackingData l_faceData = new TrackingData();
+
+        int l_size = Marshal.SizeOf(l_faceData);
+        IntPtr l_ptr = Marshal.AllocHGlobal(l_size);
+
+        Marshal.Copy(p_buffer, 0, l_ptr, l_size);
+
+        l_faceData = (TrackingData)Marshal.PtrToStructure(l_ptr, l_faceData.GetType());
+        Marshal.FreeHGlobal(l_ptr);
+
+        return l_faceData;
+    }
+}

ml_dht/TrackingModule.cs

@@ -0,0 +1,70 @@
+using ABI_RC.Systems.FaceTracking;
+using System;
+using UnityEngine;
+using ViveSR.anipal.Lip;
+
+namespace ml_dht
+{
+    class TrackingModule : ITrackingModule
+    {
+        bool m_registered = false;
+        bool m_activeAsModule = false;
+        MemoryMapReader m_mapReader = null;
+        byte[] m_buffer = null;
+        TrackingData m_trackingData;
+        LipData_v2 m_lipData;
+
+        public TrackingModule()
+        {
+            m_lipData = new LipData_v2();
+            m_lipData.frame = 0;
+            m_lipData.time = 0;
+            m_lipData.image = IntPtr.Zero;
+            m_lipData.prediction_data = new PredictionData_v2();
+            m_lipData.prediction_data.blend_shape_weight = new float[(int)LipShape_v2.Max];
+
+            m_buffer = new byte[1024];
+            m_mapReader = new MemoryMapReader();
+            m_mapReader.Open("head/data");
+        }
+        ~TrackingModule()
+        {
+            m_mapReader.Close();
+            m_mapReader = null;
+        }
+
+        public (bool, bool) Initialize(bool useEye, bool useLip)
+        {
+            m_registered = true;
+            m_activeAsModule = true;
+            return (false, true);
+        }
+
+        public void Shutdown()
+        {
+            m_activeAsModule = false;
+        }
+
+        public bool IsEyeDataAvailable() => false;
+        public bool IsLipDataAvailable() => true;
+
+        internal void Update()
+        {
+            if(m_mapReader.Read(ref m_buffer))
+            {
+                m_trackingData = TrackingData.ToObject(m_buffer);
+
+                float l_weight = Mathf.Clamp01(Mathf.InverseLerp(0.25f, 1f, Mathf.Abs(m_trackingData.m_mouthShape)));
+                m_lipData.prediction_data.blend_shape_weight[(int)LipShape_v2.Jaw_Open] = m_trackingData.m_mouthOpen;
+                m_lipData.prediction_data.blend_shape_weight[(int)LipShape_v2.Mouth_Pout] = ((m_trackingData.m_mouthShape > 0f) ? l_weight : 0f);
+                m_lipData.prediction_data.blend_shape_weight[(int)LipShape_v2.Mouth_Smile_Left] = ((m_trackingData.m_mouthShape < 0f) ? l_weight : 0f);
+                m_lipData.prediction_data.blend_shape_weight[(int)LipShape_v2.Mouth_Smile_Right] = ((m_trackingData.m_mouthShape < 0f) ? l_weight : 0f);
+
+                if(m_registered && m_activeAsModule && Settings.FaceTracking)
+                    FaceTrackingManager.Instance.SubmitNewFacialData(m_lipData);
+            }
+        }
+
+        internal ref TrackingData GetLatestTrackingData() => ref m_trackingData;
+    }
+}

ml_dht/Utils.cs

@@ -0,0 +1,18 @@
+using ABI_RC.Core.UI;
+using System.Reflection;
+using UnityEngine;
+
+namespace ml_dht
+{
+    static class Utils
+    {
+        static readonly FieldInfo ms_view = typeof(CohtmlControlledViewWrapper).GetField("_view", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        static public void ExecuteScript(this CohtmlControlledViewWrapper p_instance, string p_script) => ((cohtml.Net.View)ms_view.GetValue(p_instance)).ExecuteScript(p_script);
+
+        public static Matrix4x4 GetMatrix(this Transform p_transform, bool p_pos = true, bool p_rot = true, bool p_scl = false)
+        {
+            return Matrix4x4.TRS(p_pos ? p_transform.position : Vector3.zero, p_rot ? p_transform.rotation : Quaternion.identity, p_scl ? p_transform.localScale : Vector3.one);
+        }
+    }
+}

ml_dht/ml_dht.csproj

@@ -0,0 +1,84 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <PackageId>DesktopHeadTracking</PackageId>
+    <Authors>SDraw</Authors>
+    <Company>None</Company>
+    <Product>DesktopHeadTracking</Product>
+    <Version>1.2.0</Version>
+    <Platforms>x64</Platforms>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <PlatformTarget>x64</PlatformTarget>
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="DesktopHeadTracking.json" />
+    <None Remove="resources\mod_menu.js" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="resources\mod_menu.js" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="..\js\mods_extension.js" Link="resources\mods_extension.js" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="0Harmony">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\MelonLoader\net35\0Harmony.dll</HintPath>
+      <SpecificVersion>false</SpecificVersion>
+      <Private>false</Private>
+    </Reference>
+    <Reference Include="Assembly-CSharp">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\Assembly-CSharp.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="Assembly-CSharp-firstpass">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\Assembly-CSharp-firstpass.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="cohtml.Net">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\cohtml.Net.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="Cohtml.Runtime">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\Cohtml.Runtime.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="MelonLoader">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\MelonLoader\net35\MelonLoader.dll</HintPath>
+      <SpecificVersion>false</SpecificVersion>
+      <Private>false</Private>
+    </Reference>
+    <Reference Include="UnityEngine">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\UnityEngine.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="UnityEngine.AnimationModule">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\UnityEngine.AnimationModule.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+    <Reference Include="UnityEngine.CoreModule">
+      <HintPath>D:\games\Steam\steamapps\common\ChilloutVR\ChilloutVR_Data\Managed\UnityEngine.CoreModule.dll</HintPath>
+      <Private>false</Private>
+      <SpecificVersion>false</SpecificVersion>
+    </Reference>
+  </ItemGroup>
+
+  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
+    <Exec Command="copy /y &quot;$(TargetPath)&quot; &quot;D:\Games\Steam\steamapps\common\ChilloutVR\Mods\&quot;" />
+  </Target>
+
+</Project>

ml_dht/resources/mod_menu.js

@@ -0,0 +1,70 @@
+// Add own menu
+{
+    let l_block = document.createElement('div');
+    l_block.innerHTML = `
+        <div class ="settings-subcategory">
+            <div class ="subcategory-name">Desktop Head Tracking</div>
+            <div class ="subcategory-description"></div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Enabled: </div>
+            <div class ="option-input">
+                <div id="Enabled" class ="inp_toggle no-scroll" data-current="false"></div>
+            </div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Use head tracking: </div>
+            <div class ="option-input">
+                <div id="HeadTracking" class ="inp_toggle no-scroll" data-current="true"></div>
+            </div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Use eyes tracking: </div>
+            <div class ="option-input">
+                <div id="EyeTracking" class ="inp_toggle no-scroll" data-current="true"></div>
+            </div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Use face tracking: </div>
+            <div class ="option-input">
+                <div id="FaceTracking" class ="inp_toggle no-scroll" data-current="true"></div>
+            </div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Use blinking: </div>
+            <div class ="option-input">
+                <div id="Blinking" class ="inp_toggle no-scroll" data-current="true"></div>
+            </div>
+        </div>
+        
+        <div class ="row-wrapper">
+            <div class ="option-caption">Mirrored movement: </div>
+            <div class ="option-input">
+                <div id="Mirrored" class ="inp_toggle no-scroll" data-current="false"></div>
+            </div>
+        </div>
+
+        <div class ="row-wrapper">
+            <div class ="option-caption">Movement smoothing: </div>
+            <div class ="option-input">
+                <div id="Smoothing" class ="inp_slider no-scroll" data-min="0" data-max="99" data-current="50"></div>
+            </div>
+        </div>
+
+        
+    `;
+    document.getElementById('settings-implementation').appendChild(l_block);
+
+    // Toggles
+    for (let l_toggle of l_block.querySelectorAll('.inp_toggle'))
+        modsExtension.addSetting('DHT', l_toggle.id, modsExtension.createToggle(l_toggle, 'OnToggleUpdate_DHT'));
+
+    // Sliders
+    for (let l_slider of l_block.querySelectorAll('.inp_slider'))
+        modsExtension.addSetting('DHT', l_slider.id, modsExtension.createSlider(l_slider, 'OnSliderUpdate_DHT'));
+}