using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using FistVR;
using HarmonyLib;
using OtherLoader;
using UnityEngine;
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace JerryAr.PC
{
[BepInPlugin("JerryAr.PC", "PC", "1.0.0")]
[BepInProcess("h3vr.exe")]
[Description("Built with MeatKit")]
[BepInDependency("h3vr.otherloader", "1.3.0")]
public class PCPlugin : BaseUnityPlugin
{
private static readonly string BasePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
internal static ManualLogSource Logger;
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
LoadAssets();
}
private void LoadAssets()
{
Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "JerryAr.PC");
OtherLoader.RegisterDirectLoad(BasePath, "JerryAr.PC", "", "", "pc_set", "");
}
}
}
namespace JerryPC
{
[RequireComponent(typeof(Renderer))]
public class DesktopCursorOverlay : MonoBehaviour
{
[SerializeField]
private DesktopMirrorDisplay mirrorDisplay;
[SerializeField]
private int monitorIndex = 0;
[SerializeField]
private int maxCaptureWidth = 1280;
[SerializeField]
private int maxCaptureHeight = 720;
[SerializeField]
private float targetFrameRate = 60f;
[SerializeField]
private bool startOnAwake = true;
[SerializeField]
private bool syncTransformWithMirror = true;
[SerializeField]
private Shader cursorShader;
private WindowsCursorCapture capture;
private Material runtimeMaterial;
private Renderer targetRenderer;
private Coroutine captureRoutine;
public Texture CursorTexture
{
get
{
if (capture == null)
{
return null;
}
return (Texture)(object)capture.Texture;
}
}
private void Awake()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
targetRenderer = ((Component)this).GetComponent<Renderer>();
if ((Object)(object)cursorShader == (Object)null)
{
cursorShader = Shader.Find("DesktopMirror/CursorOverlay");
if ((Object)(object)cursorShader == (Object)null)
{
cursorShader = Shader.Find("Transparent/Diffuse");
}
}
runtimeMaterial = new Material(cursorShader);
runtimeMaterial.mainTexture = null;
targetRenderer.material = runtimeMaterial;
}
private void Start()
{
if (startOnAwake)
{
StartOverlay();
}
}
private void LateUpdate()
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
if (syncTransformWithMirror && !((Object)(object)mirrorDisplay == (Object)null))
{
Transform transform = ((Component)mirrorDisplay).transform;
((Component)this).transform.localPosition = transform.localPosition;
((Component)this).transform.localRotation = transform.localRotation;
Vector3 localPosition = ((Component)this).transform.localPosition;
localPosition.z -= 0.001f;
((Component)this).transform.localPosition = localPosition;
}
}
private void OnDestroy()
{
StopOverlay();
}
private void OnApplicationQuit()
{
StopOverlay();
}
public void StartOverlay()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Invalid comparison between Unknown and I4
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Invalid comparison between Unknown and I4
if (captureRoutine != null)
{
return;
}
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
Debug.LogWarning((object)"DesktopCursorOverlay requires a Windows build or the Windows Editor.");
return;
}
ApplyMirrorSettings();
try
{
capture = new WindowsCursorCapture(monitorIndex, maxCaptureWidth, maxCaptureHeight);
captureRoutine = ((MonoBehaviour)this).StartCoroutine(CaptureLoop());
}
catch (Exception ex)
{
Debug.LogError((object)("DesktopCursorOverlay failed to start: " + ex.Message));
StopOverlay();
}
}
public void StopOverlay()
{
if (captureRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(captureRoutine);
captureRoutine = null;
}
if (capture != null)
{
capture.Dispose();
capture = null;
}
if ((Object)(object)runtimeMaterial != (Object)null)
{
runtimeMaterial.mainTexture = null;
}
}
private void ApplyMirrorSettings()
{
if (!((Object)(object)mirrorDisplay == (Object)null))
{
monitorIndex = mirrorDisplay.GetMonitorIndex();
mirrorDisplay.GetCaptureSize(out maxCaptureWidth, out maxCaptureHeight);
}
}
private IEnumerator CaptureLoop()
{
float interval = ((!(targetFrameRate > 0f)) ? 0f : (1f / targetFrameRate));
WaitForSeconds wait = ((!(interval > 0f)) ? ((WaitForSeconds)null) : new WaitForSeconds(interval));
while (capture != null)
{
if (capture.CaptureFrame())
{
runtimeMaterial.mainTexture = (Texture)(object)capture.Texture;
}
if (wait != null)
{
yield return wait;
}
else
{
yield return null;
}
}
}
public void AssignMirrorDisplay(DesktopMirrorDisplay display)
{
mirrorDisplay = display;
}
}
public class IgnoreCol : MonoBehaviour
{
public List<Collider> col;
private void Start()
{
for (int i = 0; i < col.Count; i++)
{
for (int j = 0; j < col.Count; j++)
{
Physics.IgnoreCollision(col[j], col[i]);
}
}
}
}
internal static class MonitorLayoutUtility
{
internal static WindowsNative.RECT GetMonitorRect(int index)
{
List<WindowsNative.RECT> monitors = new List<WindowsNative.RECT>();
WindowsNative.MonitorEnumProc lpfnEnum = delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref WindowsNative.RECT lprcMonitor, IntPtr dwData)
{
monitors.Add(lprcMonitor);
return true;
};
if (!WindowsNative.EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, lpfnEnum, IntPtr.Zero))
{
throw new InvalidOperationException("EnumDisplayMonitors failed.");
}
if (monitors.Count == 0)
{
throw new InvalidOperationException("No monitors were found.");
}
if (index < 0 || index >= monitors.Count)
{
throw new ArgumentOutOfRangeException("monitorIndex", "Monitor index is out of range.");
}
return monitors[index];
}
internal static int ScaleToMax(int sourceSize, int maxSize)
{
if (maxSize <= 0 || sourceSize <= maxSize)
{
return sourceSize;
}
return maxSize;
}
}
public class PCKeyBoard : MonoBehaviour
{
public struct KeyboardInput
{
public ushort wVk;
public ushort wScan;
public uint dwFlags;
public uint time;
public IntPtr dwExtraInfo;
}
[StructLayout(LayoutKind.Explicit)]
public struct InputUnion
{
[FieldOffset(0)]
public KeyboardInput ki;
}
public struct Input
{
public int type;
public InputUnion u;
}
[Flags]
public enum InputType
{
Mouse = 0,
Keyboard = 1,
Hardware = 2
}
[Flags]
public enum KeyEventF
{
KeyDown = 0,
ExtendedKey = 1,
KeyUp = 2,
Unicode = 4,
Scancode = 8
}
public Rigidbody rig;
public GameObject PC_Core;
public FVRPhysicalObject obj;
public bool ispressingPhy;
public KeyCode key;
private const int KEYEVENTF_KEYDOWN = 0;
private const int KEYEVENTF_KEYUP = 2;
public AudioEvent keypress;
public AudioEvent keyup;
public float PressThreshoud;
public bool pressing;
public float cd = 1f;
public bool presscontinue = false;
[DllImport("user32.dll")]
public static extern void keybd_event(byte bVk, byte bScan, int dwFlags, int dwExtraInfo);
[DllImport("user32.dll", SetLastError = true)]
private static extern uint SendInput(uint nInputs, Input[] pInputs, int cbSize);
[DllImport("user32.dll")]
private static extern IntPtr GetMessageExtraInfo();
private void Start()
{
rig = ((Component)this).GetComponent<Rigidbody>();
}
private void OnTriggerStay(Collider other)
{
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)other == (Object)(object)GM.CurrentMovementManager.Hands[0].Collider_Fingers || (Object)(object)other == (Object)(object)GM.CurrentMovementManager.Hands[1].Collider_Fingers)
{
rig.AddRelativeForce(new Vector3(0f, 0.105f, 0f), (ForceMode)1);
}
}
private void Update()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
rig.AddRelativeForce(new Vector3(0f, -0.1f, 0f), (ForceMode)1);
if (((Component)this).gameObject.transform.localPosition.y >= PressThreshoud && !ispressingPhy)
{
SM.PlayCoreSound((FVRPooledAudioType)41, keypress, ((Component)this).transform.position);
ispressingPhy = true;
}
if (((Component)this).gameObject.transform.localPosition.y < PressThreshoud && ispressingPhy)
{
SM.PlayCoreSound((FVRPooledAudioType)41, keyup, ((Component)this).transform.position);
ispressingPhy = false;
}
}
private void FixedUpdate()
{
//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)PC_Core == (Object)null)
{
PC_Core = GameObject.Find("YES_Potato");
}
if (!((FVRInteractiveObject)obj).m_isHeld && (Object)(object)PC_Core != (Object)null)
{
if (ispressingPhy)
{
if (!pressing)
{
KeyDown(key);
pressing = true;
}
}
else if (!ispressingPhy && pressing)
{
KeyUp(key);
pressing = false;
}
}
if ((((FVRInteractiveObject)obj).m_isHeld || (Object)(object)PC_Core == (Object)null) && pressing)
{
KeyUp(key);
pressing = false;
}
}
public static void KeyPress(KeyCode key)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
byte bVk = (byte)KeyCodeToVK(key);
keybd_event(bVk, 0, 0, 0);
keybd_event(bVk, 0, 2, 0);
}
public void KeyDown(KeyCode key)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
if (!presscontinue)
{
UnityKeyCodeWindowsOutput.Press(key);
presscontinue = true;
}
if (presscontinue)
{
cd -= Time.deltaTime;
if (cd < 0f)
{
cd = 0f;
UnityKeyCodeWindowsOutput.Press(key);
}
}
}
private static int KeyCodeToVK(KeyCode kc)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Expected I4, but got Unknown
return (int)kc;
}
public void KeyUp(KeyCode key)
{
presscontinue = false;
cd = 1f;
}
}
public class PCMonitor : MonoBehaviour
{
public AR15HandleSightFlipper trig;
public GameObject PC_Core;
public DesktopMirrorDisplay screen;
public DesktopCursorOverlay cursor;
public GameObject screenGeo;
public bool switched;
public bool captured;
private void FixedUpdate()
{
if ((Object)(object)PC_Core != (Object)null)
{
if (!captured)
{
screen.StartCapture();
cursor.StartOverlay();
captured = true;
}
screenGeo.SetActive(true);
if (trig.m_isLargeAperture)
{
if (!switched)
{
screen.StartCapture();
cursor.StartOverlay();
screen.SetMonitorIndex(0);
switched = true;
}
}
else if (!trig.m_isLargeAperture && switched)
{
screen.StartCapture();
cursor.StartOverlay();
screen.SetMonitorIndex(1);
switched = false;
}
}
if ((Object)(object)PC_Core == (Object)null)
{
captured = false;
screenGeo.SetActive(false);
PC_Core = GameObject.Find("YES_Potato");
}
}
}
public class PCMouse : MonoBehaviour
{
public FVRPhysicalObject obj;
public GameObject PC_Core;
[Header("射线检测")]
[Tooltip("射线向下检测的距离（从鼠标底部开始）")]
public float rayDistance = 0.5f;
[Tooltip("射线检测的层级掩码（哪些层被认为是平面）")]
public LayerMask planeLayerMask = LayerMask.op_Implicit(-1);
[Header("位置贴合")]
[Tooltip("鼠标模型底部相对于物体中心点的局部偏移。例如鼠标模型中心在几何中心，底部向下偏移量为负Y值）")]
public Vector3 bottomLocalOffset = new Vector3(0f, -0.1f, 0f);
[Tooltip("是否自动将鼠标位置贴合到平面上")]
public bool snapToPlane = true;
[Header("光标控制")]
[Tooltip("光标移动的灵敏度（屏幕像素 / 世界单位）")]
public float sensitivity = 500f;
public float Speed = 0.1f;
[Tooltip("是否反转X轴")]
public bool invertX = false;
[Tooltip("是否反转Y轴")]
public bool invertY = false;
[Tooltip("是否实时更新系统光标位置")]
public bool updateSystemCursor = true;
private Vector3 lastWorldPosition;
public Transform rayp;
private bool isOnPlane = false;
private Vector3 planeNormal;
private Vector3 planePoint;
public AudioEvent click;
public bool leftc;
public bool rightc;
public bool middlec;
public Vector3 velLinearWorldL;
public Vector3 velLinearWorldR;
public Transform slapdir;
private const uint MOUSEEVENTF_LEFTDOWN = 2u;
private const uint MOUSEEVENTF_LEFTUP = 4u;
private const uint MOUSEEVENTF_RIGHTDOWN = 8u;
private const uint MOUSEEVENTF_RIGHTUP = 16u;
private const uint MOUSEEVENTF_MIDDLEDOWN = 32u;
private const uint MOUSEEVENTF_MIDDLEUP = 64u;
private const uint MOUSEEVENTF_WHEEL = 2048u;
private const uint MOUSEEVENTF_HWHEEL = 4096u;
public GameObject localpos;
public GameObject worldpos;
public GameObject localposH;
public WindowsCursorController cursorC;
[DllImport("user32.dll")]
public static extern bool SetCursorPos(int X, int Y);
[DllImport("user32.dll")]
private static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, UIntPtr dwExtraInfo);
public static void LeftClick()
{
mouse_event(2u, 0u, 0u, 0u, UIntPtr.Zero);
mouse_event(4u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void LeftDown()
{
mouse_event(2u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void LeftUp()
{
mouse_event(4u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void RightClick()
{
mouse_event(8u, 0u, 0u, 0u, UIntPtr.Zero);
mouse_event(16u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void RightDown()
{
mouse_event(8u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void RightUp()
{
mouse_event(16u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void MiddleClick()
{
mouse_event(32u, 0u, 0u, 0u, UIntPtr.Zero);
mouse_event(64u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void MiddleDown()
{
mouse_event(32u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void MiddleUp()
{
mouse_event(64u, 0u, 0u, 0u, UIntPtr.Zero);
}
public static void ScrollWheel(int delta)
{
mouse_event(2048u, 0u, 0u, (uint)delta, UIntPtr.Zero);
}
public static void HorizontalScroll(int delta)
{
mouse_event(4096u, 0u, 0u, (uint)delta, UIntPtr.Zero);
}
private void Start()
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
worldpos.transform.SetParent((Transform)null);
lastWorldPosition = ((Component)this).transform.position;
}
private void FixedUpdate()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
//IL_0524: Unknown result type (might be due to invalid IL or missing references)
//IL_0272: Unknown result type (might be due to invalid IL or missing references)
//IL_055b: Unknown result type (might be due to invalid IL or missing references)
//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_058a: Unknown result type (might be due to invalid IL or missing references)
//IL_059a: Unknown result type (might be due to invalid IL or missing references)
//IL_0312: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Unknown result type (might be due to invalid IL or missing references)
//IL_0607: Unknown result type (might be due to invalid IL or missing references)
//IL_0617: Unknown result type (might be due to invalid IL or missing references)
//IL_05af: Unknown result type (might be due to invalid IL or missing references)
//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
//IL_0409: Unknown result type (might be due to invalid IL or missing references)
//IL_0384: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_0684: Unknown result type (might be due to invalid IL or missing references)
//IL_0694: Unknown result type (might be due to invalid IL or missing references)
//IL_062c: Unknown result type (might be due to invalid IL or missing references)
//IL_0637: Unknown result type (might be due to invalid IL or missing references)
//IL_0485: Unknown result type (might be due to invalid IL or missing references)
//IL_070d: Unknown result type (might be due to invalid IL or missing references)
//IL_071d: Unknown result type (might be due to invalid IL or missing references)
//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
//IL_06be: Unknown result type (might be due to invalid IL or missing references)
//IL_0732: Unknown result type (might be due to invalid IL or missing references)
//IL_073d: Unknown result type (might be due to invalid IL or missing references)
//IL_0747: Unknown result type (might be due to invalid IL or missing references)
velLinearWorldL = GM.CurrentMovementManager.Hands[0].Input.VelLinearWorld;
if (((FVRInteractiveObject)obj).m_isHeld)
{
if (((FVRInteractiveObject)obj).m_hand.Input.TriggerFloat > 0.5f)
{
if (((FVRInteractiveObject)obj).m_hand.IsInStreamlinedMode)
{
if (((FVRInteractiveObject)obj).m_hand.Input.BYButtonPressed && !rightc)
{
rightc = true;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
RightDown();
}
}
if (!((FVRInteractiveObject)obj).m_hand.Input.BYButtonPressed && !leftc)
{
leftc = true;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
LeftDown();
}
}
}
else if (!((FVRInteractiveObject)obj).m_hand.IsInStreamlinedMode)
{
if (((FVRInteractiveObject)obj).m_hand.Input.Secondary2AxisInputAxes.y > 0.5f && !rightc)
{
rightc = true;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
RightDown();
}
}
if (((FVRInteractiveObject)obj).m_hand.Input.Secondary2AxisInputAxes.y <= 0.5f && !leftc)
{
leftc = true;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
LeftDown();
}
}
}
}
else if (((FVRInteractiveObject)obj).m_hand.Input.TriggerFloat <= 0.5f)
{
if (leftc)
{
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
LeftUp();
leftc = false;
}
if (rightc)
{
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
RightUp();
rightc = false;
}
}
if (((FVRInteractiveObject)obj).m_hand.IsInStreamlinedMode)
{
if (((FVRInteractiveObject)obj).m_hand.Input.AXButtonPressed)
{
if (!middlec)
{
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
middlec = true;
if ((Object)(object)PC_Core != (Object)null)
{
MiddleDown();
}
}
}
else if (!((FVRInteractiveObject)obj).m_hand.Input.AXButtonPressed && middlec)
{
middlec = false;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
MiddleUp();
}
}
}
else if (((FVRInteractiveObject)obj).m_hand.IsInStreamlinedMode)
{
if (((FVRInteractiveObject)obj).m_hand.Input.Secondary2AxisInputAxes.y < -0.5f)
{
if (!middlec)
{
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
middlec = true;
if ((Object)(object)PC_Core != (Object)null)
{
MiddleDown();
}
}
}
else if (((FVRInteractiveObject)obj).m_hand.Input.Secondary2AxisInputAxes.y >= -0.5f && middlec)
{
middlec = false;
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
if ((Object)(object)PC_Core != (Object)null)
{
MiddleUp();
}
}
}
}
else if (!((FVRInteractiveObject)obj).m_isHeld)
{
if (leftc)
{
leftc = false;
LeftUp();
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
}
if (rightc)
{
rightc = false;
RightUp();
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
}
if (middlec)
{
middlec = false;
MiddleUp();
SM.PlayCoreSound((FVRPooledAudioType)41, click, ((Component)this).gameObject.transform.position);
}
if ((Object)(object)PC_Core != (Object)null)
{
if (Vector3.Distance(GM.CurrentMovementManager.Hands[0].PointingTransform.position, ((FVRInteractiveObject)obj).PoseOverride.position) < 0.15f && Vector3.Angle(velLinearWorldL, slapdir.forward) < 45f && ((Vector3)(ref velLinearWorldL)).magnitude > 1f)
{
ScrollWheel((int)((Vector3)(ref velLinearWorldL)).magnitude);
}
if (Vector3.Distance(GM.CurrentMovementManager.Hands[1].PointingTransform.position, ((FVRInteractiveObject)obj).PoseOverride.position) < 0.15f && Vector3.Angle(velLinearWorldR, slapdir.forward) < 45f && ((Vector3)(ref velLinearWorldR)).magnitude > 1f)
{
ScrollWheel((int)((Vector3)(ref velLinearWorldR)).magnitude);
}
if (Vector3.Distance(GM.CurrentMovementManager.Hands[0].PointingTransform.position, ((FVRInteractiveObject)obj).PoseOverride.position) < 0.15f && Vector3.Angle(velLinearWorldL, slapdir.forward * -1f) < 45f && ((Vector3)(ref velLinearWorldL)).magnitude > 1f)
{
ScrollWheel(-1 * (int)((Vector3)(ref velLinearWorldL)).magnitude);
}
if (Vector3.Distance(GM.CurrentMovementManager.Hands[1].PointingTransform.position, ((FVRInteractiveObject)obj).PoseOverride.position) < 0.15f && Vector3.Angle(velLinearWorldR, slapdir.forward * -1f) < 45f && ((Vector3)(ref velLinearWorldR)).magnitude > 1f)
{
ScrollWheel(-1 * (int)((Vector3)(ref velLinearWorldR)).magnitude);
}
}
}
if ((Object)(object)PC_Core == (Object)null)
{
PC_Core = GameObject.Find("YES_Potato");
}
}
private void Update()
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_019c: Unknown result type (might be due to invalid IL or missing references)
//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
Ray val = default(Ray);
((Ray)(ref val))..ctor(rayp.position, -((Component)this).transform.up);
RaycastHit val2 = default(RaycastHit);
isOnPlane = Physics.Raycast(val, ref val2, rayDistance, LayerMask.op_Implicit(planeLayerMask));
if (!isOnPlane)
{
worldpos.transform.position = localposH.transform.position;
worldpos.transform.rotation = localposH.transform.rotation;
localpos.transform.localPosition = new Vector3(0f, 0f, 0f);
cursorC.X = 0f;
cursorC.Y = 0f;
}
if (isOnPlane)
{
worldpos.transform.position = Vector3.Lerp(worldpos.transform.position, localposH.transform.position, Time.deltaTime * Speed);
worldpos.transform.rotation = localposH.transform.rotation;
localpos.transform.position = worldpos.transform.position;
cursorC.X = (0f - localpos.transform.localPosition.x) * sensitivity;
cursorC.Y = localpos.transform.localPosition.z * sensitivity;
}
}
private void AlignToPlaneNormal()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
if (isOnPlane)
{
Vector3 val = planeNormal;
Vector3 val2 = ((Component)this).transform.forward;
if (Mathf.Abs(Vector3.Dot(val2, val)) > 0.9999f)
{
val2 = ((Component)this).transform.right;
}
Quaternion rotation = Quaternion.LookRotation(val2, val);
((Component)this).transform.rotation = rotation;
}
}
public void MoveSystemCursorTo(int screenX, int screenY)
{
screenX = Mathf.Clamp(screenX, 0, Screen.width);
screenY = Mathf.Clamp(screenY, 0, Screen.height);
SetCursorPos(screenX, screenY);
}
public Vector2 ConvertUnityScreenCoordToSystemCoord(Vector2 unityScreenPos)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
float x = unityScreenPos.x;
float num = (float)Screen.height - unityScreenPos.y;
return new Vector2(x, num);
}
}
public static class PhysicalKeySimulator
{
public static bool SimulatePhysicalKeyPress(PhysicalScanCode scanCode)
{
return WindowsSystemKeyOutput.SendPhysicalKeyPress(scanCode);
}
public static bool SimulatePhysicalKeyPressToSystem(PhysicalScanCode scanCode, SystemKeyDeliveryMode deliveryMode, IntPtr targetWindow, bool restoreUnityFocus)
{
return WindowsSystemKeyOutput.SendPhysicalKeyPress(scanCode, deliveryMode, targetWindow, restoreUnityFocus);
}
public static bool SimulatePhysicalKeyPress(ushort scanCode, bool isExtendedKey)
{
if (!SendScanCode(scanCode, isExtendedKey, keyDown: true))
{
return false;
}
return SendScanCode(scanCode, isExtendedKey, keyDown: false);
}
public static bool SimulatePhysicalKeyDown(PhysicalScanCode scanCode)
{
return SimulatePhysicalKeyDown((ushort)scanCode, IsExtendedScanCode(scanCode));
}
public static bool SimulatePhysicalKeyDown(ushort scanCode, bool isExtendedKey)
{
return SendScanCode(scanCode, isExtendedKey, keyDown: true);
}
public static bool SimulatePhysicalKeyUp(PhysicalScanCode scanCode)
{
return SimulatePhysicalKeyUp((ushort)scanCode, IsExtendedScanCode(scanCode));
}
public static bool SimulatePhysicalKeyUp(ushort scanCode, bool isExtendedKey)
{
return SendScanCode(scanCode, isExtendedKey, keyDown: false);
}
public static bool SimulateUnityKeyPress(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
if (!TryGetScanCodeFromUnityKeyCode(keyCode, out var scanCode, out var isExtended))
{
Debug.LogWarning((object)("PhysicalKeySimulator: unsupported KeyCode " + keyCode));
return false;
}
return SimulatePhysicalKeyPress(scanCode, isExtended);
}
public static bool SimulateWindowsVirtualKeyPress(ushort virtualKey)
{
if (!TryGetScanCodeFromVirtualKey(virtualKey, out var scanCode, out var isExtended))
{
Debug.LogWarning((object)("PhysicalKeySimulator: unsupported virtual key 0x" + virtualKey.ToString("X2")));
return false;
}
return SimulatePhysicalKeyPress(scanCode, isExtended);
}
public static bool TryGetScanCodeFromUnityKeyCode(KeyCode keyCode, out ushort scanCode, out bool isExtended)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
scanCode = 0;
isExtended = false;
if (!TryConvertUnityKeyCodeToVirtualKey(keyCode, out var virtualKey))
{
return false;
}
return TryGetScanCodeFromVirtualKey(virtualKey, out scanCode, out isExtended);
}
public static bool TryGetScanCodeFromVirtualKey(ushort virtualKey, out ushort scanCode, out bool isExtended)
{
scanCode = 0;
isExtended = IsExtendedVirtualKey(virtualKey);
uint num = WindowsInputNative.MapVirtualKey(virtualKey, 0u);
if (num == 0)
{
return false;
}
scanCode = (ushort)num;
return true;
}
public static bool IsExtendedScanCodePublic(PhysicalScanCode scanCode)
{
return IsExtendedScanCode(scanCode);
}
private static bool SendScanCode(ushort scanCode, bool isExtendedKey, bool keyDown)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
Debug.LogWarning((object)"PhysicalKeySimulator only works on Windows.");
return false;
}
return WindowsInputNative.SendKeyboardScanCode(scanCode, isExtendedKey, keyDown);
}
private static bool TryConvertUnityKeyCodeToVirtualKey(KeyCode keyCode, out ushort virtualKey)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected I4, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0121: Expected I4, but got Unknown
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0124: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Expected I4, but got Unknown
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Expected I4, but got Unknown
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_0195: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Expected I4, but got Unknown
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Invalid comparison between Unknown and I4
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
//IL_01be: Invalid comparison between Unknown and I4
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c6: Invalid comparison between Unknown and I4
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01ce: Invalid comparison between Unknown and I4
//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Invalid comparison between Unknown and I4
virtualKey = 0;
int num = (int)keyCode;
if (num >= 97 && num <= 122)
{
virtualKey = (ushort)(num - 32);
return true;
}
if (num >= 32 && num <= 126)
{
virtualKey = (ushort)num;
return true;
}
switch (keyCode - 256)
{
default:
switch (keyCode - 44)
{
case 4:
virtualKey = 48;
return true;
case 5:
virtualKey = 49;
return true;
case 6:
virtualKey = 50;
return true;
case 7:
virtualKey = 51;
return true;
case 8:
virtualKey = 52;
return true;
case 9:
virtualKey = 53;
return true;
case 10:
virtualKey = 54;
return true;
case 11:
virtualKey = 55;
return true;
case 12:
virtualKey = 56;
return true;
case 13:
virtualKey = 57;
return true;
case 15:
virtualKey = 186;
return true;
case 17:
virtualKey = 187;
return true;
case 0:
virtualKey = 188;
return true;
case 1:
virtualKey = 189;
return true;
case 2:
virtualKey = 190;
return true;
case 3:
virtualKey = 191;
return true;
}
switch (keyCode - 8)
{
default:
switch (keyCode - 91)
{
default:
if ((int)keyCode != 19)
{
if ((int)keyCode != 27)
{
if ((int)keyCode != 32)
{
if ((int)keyCode != 39)
{
if ((int)keyCode == 127)
{
virtualKey = 46;
return true;
}
return false;
}
virtualKey = 222;
return true;
}
virtualKey = 32;
return true;
}
virtualKey = 27;
return true;
}
virtualKey = 19;
return true;
case 5:
virtualKey = 192;
return true;
case 0:
virtualKey = 219;
return true;
case 1:
virtualKey = 220;
return true;
case 2:
virtualKey = 221;
return true;
}
case 0:
virtualKey = 8;
return true;
case 1:
virtualKey = 9;
return true;
case 4:
virtualKey = 12;
return true;
case 5:
break;
}
goto case 15;
case 15:
virtualKey = 13;
return true;
case 24:
virtualKey = 33;
return true;
case 25:
virtualKey = 34;
return true;
case 23:
virtualKey = 35;
return true;
case 22:
virtualKey = 36;
return true;
case 20:
virtualKey = 37;
return true;
case 17:
virtualKey = 38;
return true;
case 19:
virtualKey = 39;
return true;
case 18:
virtualKey = 40;
return true;
case 21:
virtualKey = 45;
return true;
case 0:
virtualKey = 96;
return true;
case 1:
virtualKey = 97;
return true;
case 2:
virtualKey = 98;
return true;
case 3:
virtualKey = 99;
return true;
case 4:
virtualKey = 100;
return true;
case 5:
virtualKey = 101;
return true;
case 6:
virtualKey = 102;
return true;
case 7:
virtualKey = 103;
return true;
case 8:
virtualKey = 104;
return true;
case 9:
virtualKey = 105;
return true;
case 10:
virtualKey = 110;
return true;
case 11:
virtualKey = 111;
return true;
case 12:
virtualKey = 106;
return true;
case 13:
virtualKey = 109;
return true;
case 14:
virtualKey = 107;
return true;
case 48:
virtualKey = 160;
return true;
case 47:
virtualKey = 161;
return true;
case 50:
virtualKey = 162;
return true;
case 49:
virtualKey = 163;
return true;
case 52:
virtualKey = 164;
return true;
case 51:
virtualKey = 165;
return true;
case 26:
virtualKey = 112;
return true;
case 27:
virtualKey = 113;
return true;
case 28:
virtualKey = 114;
return true;
case 29:
virtualKey = 115;
return true;
case 30:
virtualKey = 116;
return true;
case 31:
virtualKey = 117;
return true;
case 32:
virtualKey = 118;
return true;
case 33:
virtualKey = 119;
return true;
case 34:
virtualKey = 120;
return true;
case 35:
virtualKey = 121;
return true;
case 36:
virtualKey = 122;
return true;
case 37:
virtualKey = 123;
return true;
}
}
private static bool IsExtendedVirtualKey(ushort virtualKey)
{
switch (virtualKey)
{
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
case 39:
case 40:
case 45:
case 46:
case 111:
case 163:
case 165:
return true;
default:
return false;
}
}
private static bool IsExtendedScanCode(PhysicalScanCode scanCode)
{
switch (scanCode)
{
case PhysicalScanCode.Enter:
case PhysicalScanCode.LeftControl:
case PhysicalScanCode.Slash:
case PhysicalScanCode.NumpadMultiply:
case PhysicalScanCode.LeftAlt:
case PhysicalScanCode.Numpad7:
case PhysicalScanCode.Numpad8:
case PhysicalScanCode.Numpad9:
case PhysicalScanCode.Numpad4:
case PhysicalScanCode.Numpad6:
case PhysicalScanCode.Numpad1:
case PhysicalScanCode.Numpad2:
case PhysicalScanCode.Numpad3:
case PhysicalScanCode.Numpad0:
case PhysicalScanCode.NumpadDecimal:
case PhysicalScanCode.LeftWindows:
case PhysicalScanCode.RightWindows:
case PhysicalScanCode.Menu:
return true;
default:
return false;
}
}
}
public enum PhysicalScanCode : ushort
{
Escape = 1,
Digit1 = 2,
Digit2 = 3,
Digit3 = 4,
Digit4 = 5,
Digit5 = 6,
Digit6 = 7,
Digit7 = 8,
Digit8 = 9,
Digit9 = 10,
Digit0 = 11,
Minus = 12,
Equals = 13,
Backspace = 14,
Tab = 15,
Q = 16,
W = 17,
E = 18,
R = 19,
T = 20,
Y = 21,
U = 22,
I = 23,
O = 24,
P = 25,
LeftBracket = 26,
RightBracket = 27,
Enter = 28,
LeftControl = 29,
A = 30,
S = 31,
D = 32,
F = 33,
G = 34,
H = 35,
J = 36,
K = 37,
L = 38,
Semicolon = 39,
Apostrophe = 40,
Grave = 41,
LeftShift = 42,
Backslash = 43,
Z = 44,
X = 45,
C = 46,
V = 47,
B = 48,
N = 49,
M = 50,
Comma = 51,
Period = 52,
Slash = 53,
RightShift = 54,
NumpadMultiply = 55,
LeftAlt = 56,
Space = 57,
CapsLock = 58,
F1 = 59,
F2 = 60,
F3 = 61,
F4 = 62,
F5 = 63,
F6 = 64,
F7 = 65,
F8 = 66,
F9 = 67,
F10 = 68,
NumLock = 69,
ScrollLock = 70,
Numpad7 = 71,
Numpad8 = 72,
Numpad9 = 73,
NumpadMinus = 74,
Numpad4 = 75,
Numpad5 = 76,
Numpad6 = 77,
NumpadPlus = 78,
Numpad1 = 79,
Numpad2 = 80,
Numpad3 = 81,
Numpad0 = 82,
NumpadDecimal = 83,
F11 = 87,
F12 = 88,
NumpadEnter = 28,
RightControl = 29,
NumpadDivide = 53,
PrintScreen = 55,
RightAlt = 56,
Home = 71,
ArrowUp = 72,
PageUp = 73,
ArrowLeft = 75,
ArrowRight = 77,
End = 79,
ArrowDown = 80,
PageDown = 81,
Insert = 82,
Delete = 83,
LeftWindows = 91,
RightWindows = 92,
Menu = 93
}
[RequireComponent(typeof(Renderer))]
public class DesktopMirrorDisplay : MonoBehaviour
{
[SerializeField]
private int monitorIndex = 0;
[SerializeField]
private int maxCaptureWidth = 1280;
[SerializeField]
private int maxCaptureHeight = 720;
[SerializeField]
private float targetFrameRate = 30f;
[SerializeField]
private bool startOnAwake = true;
[SerializeField]
private bool flipVertical = false;
[SerializeField]
private Shader mirrorShader;
private WindowsDesktopCapture capture;
private Material runtimeMaterial;
private Renderer targetRenderer;
private Coroutine captureRoutine;
public Texture DesktopTexture
{
get
{
if (capture == null)
{
return null;
}
return (Texture)(object)capture.Texture;
}
}
private void Awake()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
targetRenderer = ((Component)this).GetComponent<Renderer>();
if ((Object)(object)mirrorShader == (Object)null)
{
mirrorShader = Shader.Find("DesktopMirror/Unlit");
if ((Object)(object)mirrorShader == (Object)null)
{
mirrorShader = Shader.Find("Unlit/Texture");
}
}
runtimeMaterial = new Material(mirrorShader);
runtimeMaterial.mainTexture = null;
targetRenderer.material = runtimeMaterial;
}
private void Start()
{
if (startOnAwake)
{
StartCapture();
}
}
private void OnDestroy()
{
StopCapture();
}
private void OnApplicationQuit()
{
StopCapture();
}
public void StartCapture()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Invalid comparison between Unknown and I4
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Invalid comparison between Unknown and I4
if (captureRoutine != null)
{
return;
}
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
Debug.LogWarning((object)"DesktopMirrorDisplay requires a Windows build or the Windows Editor.");
return;
}
try
{
capture = new WindowsDesktopCapture(monitorIndex, maxCaptureWidth, maxCaptureHeight);
FitMeshAspect(capture.Width, capture.Height);
captureRoutine = ((MonoBehaviour)this).StartCoroutine(CaptureLoop());
}
catch (Exception ex)
{
Debug.LogError((object)("DesktopMirrorDisplay failed to start: " + ex.Message));
StopCapture();
}
}
public void StopCapture()
{
if (captureRoutine != null)
{
((MonoBehaviour)this).StopCoroutine(captureRoutine);
captureRoutine = null;
}
if (capture != null)
{
capture.Dispose();
capture = null;
}
if ((Object)(object)runtimeMaterial != (Object)null)
{
runtimeMaterial.mainTexture = null;
}
}
private IEnumerator CaptureLoop()
{
float interval = ((!(targetFrameRate > 0f)) ? 0f : (1f / targetFrameRate));
WaitForSeconds wait = ((!(interval > 0f)) ? ((WaitForSeconds)null) : new WaitForSeconds(interval));
while (capture != null)
{
if (capture.CaptureFrame())
{
runtimeMaterial.mainTexture = (Texture)(object)capture.Texture;
}
if (wait != null)
{
yield return wait;
}
else
{
yield return null;
}
}
}
private void FitMeshAspect(int textureWidth, int textureHeight)
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
if (textureWidth > 0 && textureHeight > 0)
{
float num = (float)textureWidth / (float)textureHeight;
Vector3 localScale = ((Component)this).transform.localScale;
if (num >= 1f)
{
localScale.x = num;
localScale.y = 1f;
}
else
{
localScale.x = 1f;
localScale.y = 1f / num;
}
if (flipVertical)
{
Vector3 localEulerAngles = ((Component)this).transform.localEulerAngles;
localEulerAngles.x = 180f;
((Component)this).transform.localEulerAngles = localEulerAngles;
}
}
}
public void SetMonitorIndex(int index)
{
monitorIndex = index;
StopCapture();
StartCapture();
}
public int GetMonitorIndex()
{
return monitorIndex;
}
public void GetCaptureSize(out int width, out int height)
{
width = maxCaptureWidth;
height = maxCaptureHeight;
}
}
public static class DesktopMirrorMenu
{
private static void CreateQuadDisplay()
{
GameObject val = GameObject.CreatePrimitive((PrimitiveType)5);
((Object)val).name = "DesktopMirror";
Object.DestroyImmediate((Object)(object)val.GetComponent<Collider>());
val.AddComponent<DesktopMirrorDisplay>();
}
}
public class WindowsDesktopCapture : IDisposable
{
private readonly int monitorIndex;
private readonly int captureWidth;
private readonly int captureHeight;
private IntPtr screenDc;
private IntPtr memoryDc;
private IntPtr bitmap;
private IntPtr oldBitmap;
private byte[] pixelBuffer;
private WindowsNative.RECT monitorRect;
public Texture2D Texture { get; private set; }
public int Width => captureWidth;
public int Height => captureHeight;
public WindowsDesktopCapture(int monitorIndex, int maxWidth, int maxHeight)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Invalid comparison between Unknown and I4
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Invalid comparison between Unknown and I4
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
throw new PlatformNotSupportedException("WindowsDesktopCapture only works on Windows.");
}
this.monitorIndex = monitorIndex;
monitorRect = GetMonitorRect(monitorIndex);
captureWidth = ScaleToMax(monitorRect.Width, maxWidth);
captureHeight = ScaleToMax(monitorRect.Height, maxHeight);
CreateGpuTexture();
CreateGdiResources();
}
private static int ScaleToMax(int sourceSize, int maxSize)
{
if (maxSize <= 0 || sourceSize <= maxSize)
{
return sourceSize;
}
return maxSize;
}
private static WindowsNative.RECT GetMonitorRect(int index)
{
List<WindowsNative.RECT> monitors = new List<WindowsNative.RECT>();
WindowsNative.MonitorEnumProc lpfnEnum = delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref WindowsNative.RECT lprcMonitor, IntPtr dwData)
{
monitors.Add(lprcMonitor);
return true;
};
if (!WindowsNative.EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, lpfnEnum, IntPtr.Zero))
{
throw new InvalidOperationException("EnumDisplayMonitors failed.");
}
if (monitors.Count == 0)
{
throw new InvalidOperationException("No monitors were found.");
}
if (index < 0 || index >= monitors.Count)
{
throw new ArgumentOutOfRangeException("monitorIndex", "Monitor index is out of range.");
}
return monitors[index];
}
private void CreateGpuTexture()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Texture = new Texture2D(captureWidth, captureHeight, (TextureFormat)14, false);
((Texture)Texture).wrapMode = (TextureWrapMode)1;
((Texture)Texture).filterMode = (FilterMode)1;
pixelBuffer = new byte[captureWidth * captureHeight * 4];
}
private void CreateGdiResources()
{
screenDc = WindowsNative.GetDC(IntPtr.Zero);
if (screenDc == IntPtr.Zero)
{
throw new InvalidOperationException("GetDC failed.");
}
memoryDc = WindowsNative.CreateCompatibleDC(screenDc);
if (memoryDc == IntPtr.Zero)
{
throw new InvalidOperationException("CreateCompatibleDC failed.");
}
bitmap = WindowsNative.CreateCompatibleBitmap(screenDc, monitorRect.Width, monitorRect.Height);
if (bitmap == IntPtr.Zero)
{
throw new InvalidOperationException("CreateCompatibleBitmap failed.");
}
oldBitmap = WindowsNative.SelectObject(memoryDc, bitmap);
}
public bool CaptureFrame()
{
if (screenDc == IntPtr.Zero || memoryDc == IntPtr.Zero || bitmap == IntPtr.Zero)
{
return false;
}
if (!WindowsNative.BitBlt(memoryDc, 0, 0, monitorRect.Width, monitorRect.Height, screenDc, monitorRect.Left, monitorRect.Top, 13369376))
{
return false;
}
WindowsNative.BITMAPINFO lpbi = default(WindowsNative.BITMAPINFO);
lpbi.bmiHeader.biSize = MarshalSizeOf(typeof(WindowsNative.BITMAPINFOHEADER));
lpbi.bmiHeader.biWidth = monitorRect.Width;
lpbi.bmiHeader.biHeight = -monitorRect.Height;
lpbi.bmiHeader.biPlanes = 1;
lpbi.bmiHeader.biBitCount = 32;
lpbi.bmiHeader.biCompression = 0;
byte[] array = new byte[monitorRect.Width * monitorRect.Height * 4];
if (WindowsNative.GetDIBits(memoryDc, bitmap, 0u, (uint)monitorRect.Height, array, ref lpbi, 0u) == 0)
{
return false;
}
CopyAndDownscale(array, monitorRect.Width, monitorRect.Height);
Texture.LoadRawTextureData(pixelBuffer);
Texture.Apply(false, false);
return true;
}
private void CopyAndDownscale(byte[] source, int sourceWidth, int sourceHeight)
{
if (sourceWidth == captureWidth && sourceHeight == captureHeight)
{
Buffer.BlockCopy(source, 0, pixelBuffer, 0, pixelBuffer.Length);
return;
}
float num = (float)sourceWidth / (float)captureWidth;
float num2 = (float)sourceHeight / (float)captureHeight;
int num3 = sourceWidth * 4;
int num4 = captureWidth * 4;
for (int i = 0; i < captureHeight; i++)
{
int num5 = Mathf.Min(sourceHeight - 1, (int)((float)i * num2));
int num6 = num5 * num3;
int num7 = i * num4;
for (int j = 0; j < captureWidth; j++)
{
int num8 = Mathf.Min(sourceWidth - 1, (int)((float)j * num));
int num9 = num6 + num8 * 4;
int num10 = num7 + j * 4;
pixelBuffer[num10] = source[num9];
pixelBuffer[num10 + 1] = source[num9 + 1];
pixelBuffer[num10 + 2] = source[num9 + 2];
pixelBuffer[num10 + 3] = source[num9 + 3];
}
}
}
private static int MarshalSizeOf(Type type)
{
return Marshal.SizeOf(type);
}
public void Dispose()
{
if (memoryDc != IntPtr.Zero && oldBitmap != IntPtr.Zero)
{
WindowsNative.SelectObject(memoryDc, oldBitmap);
oldBitmap = IntPtr.Zero;
}
if (bitmap != IntPtr.Zero)
{
WindowsNative.DeleteObject(bitmap);
bitmap = IntPtr.Zero;
}
if (memoryDc != IntPtr.Zero)
{
WindowsNative.DeleteDC(memoryDc);
memoryDc = IntPtr.Zero;
}
if (screenDc != IntPtr.Zero)
{
WindowsNative.ReleaseDC(IntPtr.Zero, screenDc);
screenDc = IntPtr.Zero;
}
if ((Object)(object)Texture != (Object)null)
{
Object.Destroy((Object)(object)Texture);
Texture = null;
}
}
}
internal static class WindowsNative
{
internal struct POINT
{
public int X;
public int Y;
}
internal struct CURSORINFO
{
public int cbSize;
public int flags;
public IntPtr hCursor;
public POINT ptScreenPos;
}
internal struct ICONINFO
{
[MarshalAs(UnmanagedType.Bool)]
public bool fIcon;
public int xHotspot;
public int yHotspot;
public IntPtr hbmMask;
public IntPtr hbmColor;
}
internal struct RECT
{
public int Left;
public int Top;
public int Right;
public int Bottom;
public int Width => Right - Left;
public int Height => Bottom - Top;
}
internal struct BITMAPINFOHEADER
{
public int biSize;
public int biWidth;
public int biHeight;
public short biPlanes;
public short biBitCount;
public int biCompression;
public int biSizeImage;
public int biXPelsPerMeter;
public int biYPelsPerMeter;
public int biClrUsed;
public int biClrImportant;
}
internal struct BITMAPINFO
{
public BITMAPINFOHEADER bmiHeader;
}
internal delegate bool MonitorEnumProc(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData);
internal const int SRCCOPY = 13369376;
internal const int DIB_RGB_COLORS = 0;
internal const int BI_RGB = 0;
internal const int CURSOR_SHOWING = 1;
internal const int DI_NORMAL = 3;
[DllImport("user32.dll")]
internal static extern IntPtr GetDesktopWindow();
[DllImport("user32.dll")]
internal static extern IntPtr GetDC(IntPtr hWnd);
[DllImport("user32.dll")]
internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
[DllImport("user32.dll")]
internal static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, MonitorEnumProc lpfnEnum, IntPtr dwData);
[DllImport("gdi32.dll")]
internal static extern bool BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, int dwRop);
[DllImport("gdi32.dll")]
internal static extern IntPtr CreateCompatibleDC(IntPtr hdc);
[DllImport("gdi32.dll")]
internal static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);
[DllImport("gdi32.dll")]
internal static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);
[DllImport("gdi32.dll")]
internal static extern bool DeleteDC(IntPtr hdc);
[DllImport("gdi32.dll")]
internal static extern bool DeleteObject(IntPtr hObject);
[DllImport("gdi32.dll")]
internal static extern int GetDIBits(IntPtr hdc, IntPtr hbmp, uint uStartScan, uint cScanLines, byte[] lpvBits, ref BITMAPINFO lpbi, uint uUsage);
[DllImport("gdi32.dll")]
internal static extern IntPtr CreateDIBSection(IntPtr hdc, ref BITMAPINFO pbmi, uint usage, out IntPtr ppvBits, IntPtr hSection, uint offset);
[DllImport("user32.dll")]
internal static extern bool GetCursorPos(out POINT lpPoint);
[DllImport("user32.dll")]
internal static extern bool SetCursorPos(int x, int y);
[DllImport("user32.dll")]
internal static extern IntPtr GetActiveWindow();
[DllImport("user32.dll")]
internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);
[DllImport("user32.dll")]
internal static extern bool GetCursorInfo(ref CURSORINFO pci);
[DllImport("user32.dll")]
internal static extern bool GetIconInfo(IntPtr hIcon, out ICONINFO piconinfo);
[DllImport("user32.dll")]
internal static extern bool DrawIconEx(IntPtr hdc, int xLeft, int yTop, IntPtr hIcon, int cxWidth, int cyWidth, uint istepIfAniCur, IntPtr hbrFlickerFreeDraw, uint diFlags);
}
}
public class SnapToPoint : MonoBehaviour
{
public GameObject Obj;
public GameObject Targ;
private void Start()
{
}
private void Update()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
Obj.transform.position = Targ.transform.position;
Obj.transform.rotation = Targ.transform.rotation;
}
}
namespace JerryPC
{
public class SystemKeyboardOutputBridge : MonoBehaviour
{
[SerializeField]
private bool sendOnStartTestKey = false;
[SerializeField]
private PhysicalScanCode testScanCode = PhysicalScanCode.W;
[SerializeField]
private SystemKeyDeliveryMode deliveryMode = SystemKeyDeliveryMode.DirectToWindow;
[SerializeField]
private string targetProcessName = "notepad";
[SerializeField]
private string targetWindowTitle = string.Empty;
[SerializeField]
private bool restoreUnityFocus = true;
[SerializeField]
private float focusDelaySeconds = 0.05f;
private IntPtr cachedTargetWindow;
private void Start()
{
RefreshTargetWindow();
if (sendOnStartTestKey)
{
SendTestKey();
}
}
public void RefreshTargetWindow()
{
cachedTargetWindow = IntPtr.Zero;
if (!string.IsNullOrEmpty(targetWindowTitle))
{
cachedTargetWindow = WindowsSystemKeyOutput.FindWindowByTitle(targetWindowTitle);
}
if (cachedTargetWindow == IntPtr.Zero && !string.IsNullOrEmpty(targetProcessName))
{
cachedTargetWindow = WindowsSystemKeyOutput.FindMainWindowForProcess(targetProcessName);
}
}
public void SendTestKey()
{
SendPhysicalKey(testScanCode);
}
public void SendPhysicalKey(PhysicalScanCode scanCode)
{
if (deliveryMode == SystemKeyDeliveryMode.DirectToWindow || deliveryMode == SystemKeyDeliveryMode.FocusTargetThenSendInput)
{
if (cachedTargetWindow == IntPtr.Zero)
{
RefreshTargetWindow();
}
if (cachedTargetWindow == IntPtr.Zero)
{
Debug.LogWarning((object)"SystemKeyboardOutputBridge: no target window configured.");
return;
}
}
if (deliveryMode == SystemKeyDeliveryMode.FocusTargetThenSendInput && focusDelaySeconds > 0f)
{
WindowsSystemKeyOutput.TryFocusWindow(cachedTargetWindow);
}
WindowsSystemKeyOutput.SendPhysicalKeyPress(scanCode, deliveryMode, cachedTargetWindow, restoreUnityFocus);
}
public void SendPhysicalKeyToForeground(PhysicalScanCode scanCode)
{
WindowsSystemKeyOutput.SendPhysicalKeyPress(scanCode, SystemKeyDeliveryMode.ForegroundWindow, IntPtr.Zero, restoreUnityFocus: false);
}
public void SendPhysicalKeyToTarget(PhysicalScanCode scanCode)
{
RefreshTargetWindow();
WindowsSystemKeyOutput.SendPhysicalKeyPress(scanCode, SystemKeyDeliveryMode.DirectToWindow, cachedTargetWindow, restoreUnityFocus);
}
public void SendPhysicalKeyDownToTarget(PhysicalScanCode scanCode)
{
SendPhysicalKeyStateToTarget(scanCode, keyDown: true);
}
public void SendPhysicalKeyUpToTarget(PhysicalScanCode scanCode)
{
SendPhysicalKeyStateToTarget(scanCode, keyDown: false);
}
private void SendPhysicalKeyStateToTarget(PhysicalScanCode scanCode, bool keyDown)
{
RefreshTargetWindow();
if (cachedTargetWindow == IntPtr.Zero)
{
Debug.LogWarning((object)"SystemKeyboardOutputBridge: no target window configured.");
return;
}
ushort scanCode2 = (ushort)scanCode;
bool isExtended = PhysicalKeySimulator.IsExtendedScanCodePublic(scanCode);
if (TryScanCodeToVirtualKey(scanCode2, isExtended, out var virtualKey))
{
uint msg = ((!keyDown) ? 257u : 256u);
IntPtr lParam = BuildKeyLParam(scanCode2, isExtended, !keyDown);
WindowsInputNative.PostMessage(cachedTargetWindow, msg, new IntPtr(virtualKey), lParam);
}
}
private static bool TryScanCodeToVirtualKey(ushort scanCode, bool isExtended, out ushort virtualKey)
{
virtualKey = 0;
uint num = WindowsInputNative.MapVirtualKey(scanCode, 1u);
if (num == 0)
{
return false;
}
virtualKey = (ushort)num;
return true;
}
private static IntPtr BuildKeyLParam(ushort scanCode, bool isExtended, bool keyUp)
{
int num = 1;
num |= scanCode << 16;
if (isExtended)
{
num |= 0x1000000;
}
if (keyUp)
{
num |= 0x40000000;
num |= int.MinValue;
}
return new IntPtr(num);
}
}
public static class UnityKeyCodeWindowsOutput
{
public static bool Press(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return WindowsSystemKeyOutput.SendKeyCodePress(keyCode);
}
public static bool Press(KeyCode keyCode, SystemKeyDeliveryMode deliveryMode, string targetProcessName, bool restoreUnityFocus)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
if (string.IsNullOrEmpty(targetProcessName))
{
return WindowsSystemKeyOutput.SendKeyCodePress(keyCode, deliveryMode, IntPtr.Zero, restoreUnityFocus);
}
return WindowsSystemKeyOutput.SendKeyCodePressToProcess(keyCode, targetProcessName, deliveryMode, restoreUnityFocus);
}
public static bool KeyDown(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return WindowsSystemKeyOutput.SendKeyCodeDown(keyCode);
}
public static bool KeyUp(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return WindowsSystemKeyOutput.SendKeyCodeUp(keyCode);
}
public static bool PressChord(params KeyCode[] keys)
{
if (keys == null || keys.Length == 0)
{
return false;
}
for (int i = 0; i < keys.Length - 1; i++)
{
if (!KeyDown(keys[i]))
{
return false;
}
}
if (!Press(keys[^1]))
{
return false;
}
for (int num = keys.Length - 2; num >= 0; num--)
{
if (!KeyUp(keys[num]))
{
return false;
}
}
return true;
}
}
public class UnityKeyCodeWindowsSender : MonoBehaviour
{
[SerializeField]
private KeyCode keyCode = (KeyCode)32;
[SerializeField]
private SystemKeyDeliveryMode deliveryMode = SystemKeyDeliveryMode.ForegroundWindow;
[SerializeField]
private string targetProcessName = string.Empty;
[SerializeField]
private bool restoreUnityFocus = true;
[SerializeField]
private bool sendOnStart = false;
public KeyCode KeyCode
{
get
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
return keyCode;
}
set
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
keyCode = value;
}
}
private void Start()
{
if (sendOnStart)
{
SendPress();
}
}
public void SendPress()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
UnityKeyCodeWindowsOutput.Press(keyCode, deliveryMode, targetProcessName, restoreUnityFocus);
}
public void SendKeyDown()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
UnityKeyCodeWindowsOutput.KeyDown(keyCode);
}
public void SendKeyUp()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
UnityKeyCodeWindowsOutput.KeyUp(keyCode);
}
public void SendPress(KeyCode code)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
keyCode = code;
SendPress();
}
}
public class WindowsCursorCapture : IDisposable
{
private const int CursorDrawSize = 128;
private readonly int captureWidth;
private readonly int captureHeight;
private readonly WindowsNative.RECT monitorRect;
private IntPtr screenDc;
private IntPtr overlayDc;
private IntPtr overlayBitmap;
private IntPtr overlayBits;
private IntPtr cursorDc;
private IntPtr cursorBitmap;
private IntPtr cursorBits;
private byte[] overlayPixels;
private byte[] cursorPixels;
public Texture2D Texture { get; private set; }
public int Width => captureWidth;
public int Height => captureHeight;
public WindowsCursorCapture(int monitorIndex, int maxWidth, int maxHeight)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Invalid comparison between Unknown and I4
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Invalid comparison between Unknown and I4
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
throw new PlatformNotSupportedException("WindowsCursorCapture only works on Windows.");
}
monitorRect = MonitorLayoutUtility.GetMonitorRect(monitorIndex);
captureWidth = MonitorLayoutUtility.ScaleToMax(monitorRect.Width, maxWidth);
captureHeight = MonitorLayoutUtility.ScaleToMax(monitorRect.Height, maxHeight);
overlayPixels = new byte[captureWidth * captureHeight * 4];
cursorPixels = new byte[65536];
CreateGpuTexture();
CreateGdiResources();
}
private void CreateGpuTexture()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
Texture = new Texture2D(captureWidth, captureHeight, (TextureFormat)14, false);
((Texture)Texture).wrapMode = (TextureWrapMode)1;
((Texture)Texture).filterMode = (FilterMode)1;
}
private void CreateGdiResources()
{
screenDc = WindowsNative.GetDC(IntPtr.Zero);
if (screenDc == IntPtr.Zero)
{
throw new InvalidOperationException("GetDC failed.");
}
overlayDc = WindowsNative.CreateCompatibleDC(screenDc);
cursorDc = WindowsNative.CreateCompatibleDC(screenDc);
if (overlayDc == IntPtr.Zero || cursorDc == IntPtr.Zero)
{
throw new InvalidOperationException("CreateCompatibleDC failed.");
}
overlayBitmap = CreateAlphaBitmap(overlayDc, captureWidth, captureHeight, out overlayBits);
cursorBitmap = CreateAlphaBitmap(cursorDc, 128, 128, out cursorBits);
}
private static IntPtr CreateAlphaBitmap(IntPtr dc, int width, int height, out IntPtr bits)
{
WindowsNative.BITMAPINFO pbmi = default(WindowsNative.BITMAPINFO);
pbmi.bmiHeader.biSize = MarshalSizeOf(typeof(WindowsNative.BITMAPINFOHEADER));
pbmi.bmiHeader.biWidth = width;
pbmi.bmiHeader.biHeight = -height;
pbmi.bmiHeader.biPlanes = 1;
pbmi.bmiHeader.biBitCount = 32;
pbmi.bmiHeader.biCompression = 0;
IntPtr intPtr = WindowsNative.CreateDIBSection(dc, ref pbmi, 0u, out bits, IntPtr.Zero, 0u);
if (intPtr == IntPtr.Zero)
{
throw new InvalidOperationException("CreateDIBSection failed.");
}
WindowsNative.SelectObject(dc, intPtr);
ClearBits(bits, width * height * 4);
return intPtr;
}
private static void ClearBits(IntPtr bits, int byteCount)
{
if (bits == IntPtr.Zero)
{
return;
}
int[] array = new int[256];
int num = byteCount;
IntPtr destination = bits;
while (num > 0)
{
int num2 = num;
if (num2 > array.Length * 4)
{
num2 = array.Length * 4;
}
Marshal.Copy(array, 0, destination, num2 / 4);
destination = new IntPtr(destination.ToInt64() + num2);
num -= num2;
}
}
public bool CaptureFrame()
{
ClearPixelBuffer();
if (!WindowsNative.GetCursorPos(out var lpPoint))
{
UploadTexture();
return false;
}
if (!IsPointOnMonitor(lpPoint))
{
UploadTexture();
return true;
}
WindowsNative.CURSORINFO pci = default(WindowsNative.CURSORINFO);
pci.cbSize = MarshalSizeOf(typeof(WindowsNative.CURSORINFO));
if (!WindowsNative.GetCursorInfo(ref pci))
{
UploadTexture();
return false;
}
if ((pci.flags & 1) == 0)
{
UploadTexture();
return true;
}
if (!WindowsNative.GetIconInfo(pci.hCursor, out var piconinfo))
{
UploadTexture();
return false;
}
try
{
DrawCursorToOverlay(lpPoint, pci.hCursor, piconinfo);
}
finally
{
ReleaseIconInfo(piconinfo);
}
UploadTexture();
return true;
}
private void DrawCursorToOverlay(WindowsNative.POINT cursorPoint, IntPtr cursorHandle, WindowsNative.ICONINFO iconInfo)
{
ClearBits(cursorBits, cursorPixels.Length);
WindowsNative.DrawIconEx(cursorDc, 0, 0, cursorHandle, 0, 0, 0u, IntPtr.Zero, 3u);
Marshal.Copy(cursorBits, cursorPixels, 0, cursorPixels.Length);
int x = cursorPoint.X;
WindowsNative.RECT rECT = monitorRect;
int num = x - rECT.Left;
int y = cursorPoint.Y;
WindowsNative.RECT rECT2 = monitorRect;
int num2 = y - rECT2.Top;
int drawX = ScaleToTexture(num - iconInfo.xHotspot, monitorRect.Width, captureWidth);
int drawY = ScaleToTexture(num2 - iconInfo.yHotspot, monitorRect.Height, captureHeight);
CompositeCursorPixels(drawX, drawY);
}
private static int ScaleToTexture(int monitorValue, int monitorSize, int textureSize)
{
if (monitorSize <= 0)
{
return 0;
}
return (int)((long)monitorValue * (long)textureSize / monitorSize);
}
private void CompositeCursorPixels(int drawX, int drawY)
{
int num = captureWidth * 4;
int num2 = 512;
for (int i = 0; i < 128; i++)
{
int num3 = drawY + i;
if (num3 < 0 || num3 >= captureHeight)
{
continue;
}
int num4 = i * num2;
int num5 = num3 * num;
for (int j = 0; j < 128; j++)
{
int num6 = drawX + j;
if (num6 >= 0 && num6 < captureWidth)
{
int num7 = num4 + j * 4;
byte b = cursorPixels[num7 + 3];
if (b == 0)
{
b = GetCursorAlphaFromRgb(cursorPixels, num7);
}
if (b != 0)
{
int destIndex = num5 + num6 * 4;
BlendPixel(destIndex, num7, b);
}
}
}
}
}
private static byte GetCursorAlphaFromRgb(byte[] pixels, int index)
{
byte b = pixels[index];
byte b2 = pixels[index + 1];
byte b3 = pixels[index + 2];
if (b3 > 0 || b2 > 0 || b > 0)
{
return byte.MaxValue;
}
return 0;
}
private void BlendPixel(int destIndex, int srcIndex, byte alpha)
{
float num = (float)(int)alpha / 255f;
float num2 = 1f - num;
overlayPixels[destIndex] = (byte)((float)(int)cursorPixels[srcIndex] * num + (float)(int)overlayPixels[destIndex] * num2);
overlayPixels[destIndex + 1] = (byte)((float)(int)cursorPixels[srcIndex + 1] * num + (float)(int)overlayPixels[destIndex + 1] * num2);
overlayPixels[destIndex + 2] = (byte)((float)(int)cursorPixels[srcIndex + 2] * num + (float)(int)overlayPixels[destIndex + 2] * num2);
overlayPixels[destIndex + 3] = (byte)((float)(int)alpha + (float)(int)overlayPixels[destIndex + 3] * num2);
}
private bool IsPointOnMonitor(WindowsNative.POINT point)
{
int x = point.X;
WindowsNative.RECT rECT = monitorRect;
int result;
if (x >= rECT.Left)
{
int x2 = point.X;
WindowsNative.RECT rECT2 = monitorRect;
if (x2 < rECT2.Right)
{
int y = point.Y;
WindowsNative.RECT rECT3 = monitorRect;
if (y >= rECT3.Top)
{
int y2 = point.Y;
WindowsNative.RECT rECT4 = monitorRect;
result = ((y2 < rECT4.Bottom) ? 1 : 0);
goto IL_0069;
}
}
}
result = 0;
goto IL_0069;
IL_0069:
return (byte)result != 0;
}
private void ClearPixelBuffer()
{
for (int i = 0; i < overlayPixels.Length; i++)
{
overlayPixels[i] = 0;
}
}
private void UploadTexture()
{
Texture.LoadRawTextureData(overlayPixels);
Texture.Apply(false, false);
}
private static void ReleaseIconInfo(WindowsNative.ICONINFO iconInfo)
{
if (iconInfo.hbmColor != IntPtr.Zero)
{
WindowsNative.DeleteObject(iconInfo.hbmColor);
}
if (iconInfo.hbmMask != IntPtr.Zero)
{
WindowsNative.DeleteObject(iconInfo.hbmMask);
}
}
private static int MarshalSizeOf(Type type)
{
return Marshal.SizeOf(type);
}
public void Dispose()
{
if (overlayBitmap != IntPtr.Zero)
{
WindowsNative.DeleteObject(overlayBitmap);
overlayBitmap = IntPtr.Zero;
}
if (cursorBitmap != IntPtr.Zero)
{
WindowsNative.DeleteObject(cursorBitmap);
cursorBitmap = IntPtr.Zero;
}
if (overlayDc != IntPtr.Zero)
{
WindowsNative.DeleteDC(overlayDc);
overlayDc = IntPtr.Zero;
}
if (cursorDc != IntPtr.Zero)
{
WindowsNative.DeleteDC(cursorDc);
cursorDc = IntPtr.Zero;
}
if (screenDc != IntPtr.Zero)
{
WindowsNative.ReleaseDC(IntPtr.Zero, screenDc);
screenDc = IntPtr.Zero;
}
if ((Object)(object)Texture != (Object)null)
{
Object.Destroy((Object)(object)Texture);
Texture = null;
}
}
}
public enum WindowsCursorControlMode
{
Relative,
Absolute
}
public class WindowsCursorController : MonoBehaviour
{
[SerializeField]
private float x = 0f;
[SerializeField]
private float y = 0f;
[SerializeField]
private WindowsCursorControlMode controlMode = WindowsCursorControlMode.Relative;
[SerializeField]
private bool activeOnStart = true;
private bool isActive;
public float X
{
get
{
return x;
}
set
{
x = value;
}
}
public float Y
{
get
{
return y;
}
set
{
y = value;
}
}
private void Start()
{
isActive = activeOnStart;
}
private void Update()
{
if (isActive)
{
ApplyMovement();
}
}
public void ApplyMovement()
{
if (controlMode == WindowsCursorControlMode.Absolute)
{
WindowsCursorDriver.SetPosition(Mathf.RoundToInt(x), Mathf.RoundToInt(y));
}
else
{
WindowsCursorDriver.MoveBy(x, y);
}
}
public void SetActive(bool value)
{
isActive = value;
}
public void SetDelta(float newX, float newY)
{
x = newX;
y = newY;
}
public void SetAbsolutePosition(float screenX, float screenY)
{
controlMode = WindowsCursorControlMode.Absolute;
x = screenX;
y = screenY;
WindowsCursorDriver.SetPosition(Mathf.RoundToInt(x), Mathf.RoundToInt(y));
}
}
public static class WindowsCursorDriver
{
public static bool TryGetPosition(out int x, out int y)
{
x = 0;
y = 0;
if (!IsWindows())
{
Debug.Log((object)"NotWindows");
return false;
}
if (!WindowsNative.GetCursorPos(out var lpPoint))
{
Debug.Log((object)"Failed getting Windows cursor pos");
return false;
}
x = lpPoint.X;
y = lpPoint.Y;
return true;
}
public static bool SetPosition(int x, int y)
{
if (!IsWindows())
{
return false;
}
return WindowsNative.SetCursorPos(x, y);
}
public static bool MoveBy(float deltaX, float deltaY)
{
if (!TryGetPosition(out var x, out var y))
{
Debug.Log((object)"Failed getting cursor pos");
return false;
}
int x2 = x + Mathf.RoundToInt(deltaX);
int y2 = y + Mathf.RoundToInt(deltaY);
return SetPosition(x2, y2);
}
private static bool IsWindows()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
return (int)Application.platform == 2 || (int)Application.platform == 7;
}
}
internal static class WindowsInputNative
{
[StructLayout(LayoutKind.Explicit, Size = 40)]
internal struct INPUT
{
[FieldOffset(0)]
public uint type;
[FieldOffset(8)]
public KEYBDINPUT ki;
}
internal struct KEYBDINPUT
{
public ushort wVk;
public ushort wScan;
public uint dwFlags;
public uint time;
public IntPtr dwExtraInfo;
}
internal const uint INPUT_KEYBOARD = 1u;
internal const uint KEYEVENTF_EXTENDEDKEY = 1u;
internal const uint KEYEVENTF_KEYUP = 2u;
internal const uint KEYEVENTF_SCANCODE = 8u;
internal const uint MAPVK_VK_TO_VSC = 0u;
internal const uint MAPVK_VSC_TO_VK = 1u;
internal const int SW_SHOW = 5;
internal const uint WM_KEYDOWN = 256u;
internal const uint WM_KEYUP = 257u;
internal const uint WM_SYSKEYDOWN = 260u;
internal const uint WM_SYSKEYUP = 261u;
internal const int InputStructureSize = 40;
[DllImport("user32.dll", SetLastError = true)]
internal static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
[DllImport("user32.dll")]
internal static extern uint MapVirtualKey(uint uCode, uint uMapType);
[DllImport("user32.dll")]
internal static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
internal static extern bool SetForegroundWindow(IntPtr hWnd);
[DllImport("user32.dll")]
internal static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
[DllImport("user32.dll")]
internal static extern bool IsWindow(IntPtr hWnd);
[DllImport("user32.dll")]
internal static extern bool IsIconic(IntPtr hWnd);
[DllImport("user32.dll")]
internal static extern bool AllowSetForegroundWindow(int dwProcessId);
[DllImport("user32.dll")]
internal static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
[DllImport("user32.dll")]
internal static extern uint GetCurrentThreadId();
[DllImport("user32.dll", SetLastError = true)]
internal static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
internal static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
internal static extern bool PostMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
internal static extern IntPtr SendMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
[DllImport("kernel32.dll")]
internal static extern uint GetLastError();
internal static bool SendKeyboardScanCode(ushort scanCode, bool isExtendedKey, bool keyDown)
{
uint num = MapVirtualKey(scanCode, 1u);
INPUT iNPUT = default(INPUT);
iNPUT.type = 1u;
iNPUT.ki.wVk = (ushort)((num != 0) ? ((ushort)num) : 0);
iNPUT.ki.wScan = scanCode;
iNPUT.ki.time = 0u;
iNPUT.ki.dwExtraInfo = IntPtr.Zero;
iNPUT.ki.dwFlags = 8u;
if (isExtendedKey)
{
iNPUT.ki.dwFlags |= 1u;
}
if (!keyDown)
{
iNPUT.ki.dwFlags |= 2u;
}
uint num2 = SendInput(1u, new INPUT[1] { iNPUT }, 40);
return num2 == 1;
}
}
public enum SystemKeyDeliveryMode
{
ForegroundWindow,
FocusTargetThenSendInput,
DirectToWindow
}
public static class WindowsSystemKeyOutput
{
public static bool SendPhysicalKeyPress(PhysicalScanCode scanCode)
{
return SendPhysicalKeyPress(scanCode, SystemKeyDeliveryMode.ForegroundWindow, IntPtr.Zero, restoreUnityFocus: true);
}
public static bool SendPhysicalKeyPress(PhysicalScanCode scanCode, SystemKeyDeliveryMode deliveryMode, IntPtr targetWindow, bool restoreUnityFocus)
{
ushort scanCode2 = (ushort)scanCode;
bool isExtended = PhysicalKeySimulator.IsExtendedScanCodePublic(scanCode);
if (!TryScanCodeToVirtualKey(scanCode2, isExtended, out var virtualKey))
{
Debug.LogWarning((object)("WindowsSystemKeyOutput: could not map scan code 0x" + scanCode2.ToString("X2")));
return false;
}
return SendVirtualKeyPress(virtualKey, scanCode2, isExtended, deliveryMode, targetWindow, restoreUnityFocus);
}
public static bool SendPhysicalKeyPressToProcess(string processName, PhysicalScanCode scanCode, SystemKeyDeliveryMode deliveryMode, bool restoreUnityFocus)
{
IntPtr intPtr = FindMainWindowForProcess(processName);
if (intPtr == IntPtr.Zero)
{
Debug.LogWarning((object)("WindowsSystemKeyOutput: process window not found: " + processName));
return false;
}
return SendPhysicalKeyPress(scanCode, deliveryMode, intPtr, restoreUnityFocus);
}
public static bool SendPhysicalKeyPressToWindowTitle(string windowTitle, PhysicalScanCode scanCode, SystemKeyDeliveryMode deliveryMode, bool restoreUnityFocus)
{
IntPtr intPtr = WindowsInputNative.FindWindow(null, windowTitle);
if (intPtr == IntPtr.Zero)
{
Debug.LogWarning((object)("WindowsSystemKeyOutput: window title not found: " + windowTitle));
return false;
}
return SendPhysicalKeyPress(scanCode, deliveryMode, intPtr, restoreUnityFocus);
}
public static bool SendKeyCodePress(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return SendKeyCodePress(keyCode, SystemKeyDeliveryMode.ForegroundWindow, IntPtr.Zero, restoreUnityFocus: true);
}
public static bool SendKeyCodePress(KeyCode keyCode, SystemKeyDeliveryMode deliveryMode, IntPtr targetWindow, bool restoreUnityFocus)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
if (!TryResolveKeyCode(keyCode, out var virtualKey, out var scanCode, out var isExtended))
{
Debug.LogWarning((object)("WindowsSystemKeyOutput: unsupported KeyCode " + keyCode));
return false;
}
return SendVirtualKeyPress(virtualKey, scanCode, isExtended, deliveryMode, targetWindow, restoreUnityFocus);
}
public static bool SendKeyCodePressToProcess(KeyCode keyCode, string processName, SystemKeyDeliveryMode deliveryMode, bool restoreUnityFocus)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
IntPtr intPtr = FindMainWindowForProcess(processName);
if (intPtr == IntPtr.Zero)
{
Debug.LogWarning((object)("WindowsSystemKeyOutput: process window not found: " + processName));
return false;
}
return SendKeyCodePress(keyCode, deliveryMode, intPtr, restoreUnityFocus);
}
public static bool SendKeyCodeDown(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if (!PhysicalKeySimulator.TryGetScanCodeFromUnityKeyCode(keyCode, out var scanCode, out var isExtended))
{
return false;
}
return SendInputScanCode(scanCode, isExtended, keyDown: true);
}
public static bool SendKeyCodeUp(KeyCode keyCode)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if (!PhysicalKeySimulator.TryGetScanCodeFromUnityKeyCode(keyCode, out var scanCode, out var isExtended))
{
return false;
}
return SendInputScanCode(scanCode, isExtended, keyDown: false);
}
public static bool TryResolveKeyCode(KeyCode keyCode, out ushort virtualKey, out ushort scanCode, out bool isExtended)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
virtualKey = 0;
scanCode = 0;
isExtended = false;
if (!PhysicalKeySimulator.TryGetScanCodeFromUnityKeyCode(keyCode, out scanCode, out isExtended))
{
return false;
}
return TryScanCodeToVirtualKey(scanCode, isExtended, out virtualKey);
}
public static bool SendVirtualKeyPress(ushort virtualKey, SystemKeyDeliveryMode deliveryMode, IntPtr targetWindow, bool restoreUnityFocus)
{
if (!PhysicalKeySimulator.TryGetScanCodeFromVirtualKey(virtualKey, out var scanCode, out var isExtended))
{
return false;
}
return SendVirtualKeyPress(virtualKey, scanCode, isExtended, deliveryMode, targetWindow, restoreUnityFocus);
}
public static bool SendVirtualKeyPress(ushort virtualKey, ushort scanCode, bool isExtended, SystemKeyDeliveryMode deliveryMode, IntPtr targetWindow, bool restoreUnityFocus)
{
if (!IsWindowsPlatform())
{
return false;
}
return deliveryMode switch
{
SystemKeyDeliveryMode.ForegroundWindow => SendInputKeyPress(scanCode, isExtended),
SystemKeyDeliveryMode.FocusTargetThenSendInput => SendInputToTargetWindow(targetWindow, virtualKey, scanCode, isExtended, restoreUnityFocus),
SystemKeyDeliveryMode.DirectToWindow => PostMessageKeyPress(targetWindow, virtualKey, scanCode, isExtended),
_ => false,
};
}
public static IntPtr FindWindowByTitle(string windowTitle)
{
if (string.IsNullOrEmpty(windowTitle))
{
return IntPtr.Zero;
}
return WindowsInputNative.FindWindow(null, windowTitle);
}
public static IntPtr FindMainWindowForProcess(string processName)
{
if (string.IsNullOrEmpty(processName))
{
return IntPtr.Zero;
}
Process[] processesByName = Process.GetProcessesByName(processName);
foreach (Process process in processesByName)
{
if (process != null)
{
IntPtr mainWindowHandle = process.MainWindowHandle;
if (mainWindowHandle != IntPtr.Zero)
{
return mainWindowHandle;
}
}
}
return IntPtr.Zero;
}
public static bool TryFocusWindow(IntPtr windowHandle)
{
if (windowHandle == IntPtr.Zero || !WindowsInputNative.IsWindow(windowHandle))
{
return false;
}
if (WindowsInputNative.IsIconic(windowHandle))
{
WindowsInputNative.ShowWindow(windowHandle, 5);
}
uint lpdwProcessId;
uint windowThreadProcessId = WindowsInputNative.GetWindowThreadProcessId(windowHandle, out lpdwProcessId);
uint currentThreadId = WindowsInputNative.GetCurrentThreadId();
WindowsInputNative.AllowSetForegroundWindow((int)lpdwProcessId);
bool flag = false;
if (windowThreadProcessId != currentThreadId)
{
flag = WindowsInputNative.AttachThreadInput(currentThreadId, windowThreadProcessId, fAttach: true);
}
bool result = WindowsInputNative.SetForegroundWindow(windowHandle);
if (flag)
{
WindowsInputNative.AttachThreadInput(currentThreadId, windowThreadProcessId, fAttach: false);
}
return result;
}
private static bool SendInputKeyPress(ushort scanCode, bool isExtended)
{
if (!SendInputScanCode(scanCode, isExtended, keyDown: true))
{
return false;
}
return SendInputScanCode(scanCode, isExtended, keyDown: false);
}
private static bool SendInputToTargetWindow(IntPtr targetWindow, ushort virtualKey, ushort scanCode, bool isExtended, bool restoreUnityFocus)
{
if (targetWindow == IntPtr.Zero || !WindowsInputNative.IsWindow(targetWindow))
{
Debug.LogWarning((object)"WindowsSystemKeyOutput: invalid target window handle.");
return false;
}
IntPtr unityWindowHandle = GetUnityWindowHandle();
if (!TryFocusWindow(targetWindow))
{
Debug.LogWarning((object)"WindowsSystemKeyOutput: failed to focus target window.");
return false;
}
bool result = SendInputKeyPress(scanCode, isExtended);
if (restoreUnityFocus && unityWindowHandle != IntPtr.Zero)
{
TryFocusWindow(unityWindowHandle);
}
return result;
}
private static bool PostMessageKeyPress(IntPtr targetWindow, ushort virtualKey, ushort scanCode, bool isExtended)
{
if (targetWindow == IntPtr.Zero || !WindowsInputNative.IsWindow(targetWindow))
{
Debug.LogWarning((object)"WindowsSystemKeyOutput: invalid target window handle.");
return false;
}
bool flag = virtualKey == 18 || virtualKey == 91 || virtualKey == 92;
uint msg = ((!flag) ? 256u : 260u);
uint msg2 = ((!flag) ? 257u : 261u);
IntPtr lParam = BuildKeyLParam(scanCode, isExtended, keyUp: false);
IntPtr lParam2 = BuildKeyLParam(scanCode, isExtended, keyUp: true);
bool flag2 = WindowsInputNative.PostMessage(targetWindow, msg, new IntPtr(virtualKey), lParam);
bool flag3 = WindowsInputNative.PostMessage(targetWindow, msg2, new IntPtr(virtualKey), lParam2);
return flag2 && flag3;
}
private static IntPtr BuildKeyLParam(ushort scanCode, bool isExtended, bool keyUp)
{
int num = 1;
num |= scanCode << 16;
if (isExtended)
{
num |= 0x1000000;
}
if (keyUp)
{
num |= 0x40000000;
num |= int.MinValue;
}
return new IntPtr(num);
}
private static bool SendInputScanCode(ushort scanCode, bool isExtendedKey, bool keyDown)
{
if (!WindowsInputNative.SendKeyboardScanCode(scanCode, isExtendedKey, keyDown))
{
Debug.LogWarning((object)("WindowsSystemKeyOutput SendInput failed. Error=" + WindowsInputNative.GetLastError()));
return false;
}
return true;
}
private static bool TryScanCodeToVirtualKey(ushort scanCode, bool isExtended, out ushort virtualKey)
{
virtualKey = 0;
uint num = WindowsInputNative.MapVirtualKey(scanCode, 1u);
if (num == 0)
{
return false;
}
virtualKey = (ushort)num;
return true;
}
private static IntPtr GetUnityWindowHandle()
{
return WindowsInputNative.GetForegroundWindow();
}
private static bool IsWindowsPlatform()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Invalid comparison between Unknown and I4
if ((int)Application.platform != 2 && (int)Application.platform != 7)
{
Debug.LogWarning((object)"WindowsSystemKeyOutput only works on Windows.");
return false;
}
return true;
}
}
}
