[InitializeOnLoadMethod]
private static void Initialize()
{
    void OnPlayModeStateChanged(PlayModeStateChange mode)
    {
        if (mode == PlayModeStateChange.EnteredPlayMode)
        {
            Debug.Log("Entered PlayMode");
        }
    }
    EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
}

using UnityEditor;

public static class ActiveGameView
{
    [InitializeOnLoadMethod]
    private statc void Initialize()
    {
        EditorApplication.playModeStateChanged += OnPlayModeStateChanged
    }

    private static void OnPlayModeStateChanged(PlayModeStateChange mode)
    {
        if (mode == PlayModeStateChange.EnteredPlayMode)
        {
            EditorApplication.ExecuteMenuItem("Window/General/Game");
        }
    }
}

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using UnityEditor;

public static class ActiveGameView
{
    private const int TargetDisplay = 0;

    [InitializeOnLoadMethod]
    private static void Initialize()
    {
        EditorApplication.playModeStateChanged += OnPlayModeStateChanged;
    }

    private static GameView GetGameView(GUIView view)
    {
        if (!(view is DockArea dockArea))
        {
            return null;
        }

        if (!(dockArea.actualView is GameView gameView))
        {
            return null;
        }

        return gameView;
    }

    private static int GetTargetDisplay(this GameView gameView)
    {
        if (gameView == null)
        {
            return -1;
        }

        var flags = BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
        var propertyInfo = typeof(GameView).GetProperty("targetDisplay", flags);
        if (propertyInfo == null)
        {
            return -1;
        }

        var val = propertyInfo.GetValue(gameView);
        if (!(val is int display))
        {
            return -1;
        }

        return display;
    }

    private static void OnPlayModeStateChanged(PlayModeStateChange mode)
    {
        if (mode != PlayModeStateChange.EnteredPlayMode)
        {
            return;
        }

        var views = new List<GUIView>();
        GUIViewDebuggerHelper.GetViews(views);
        var gameView1 = views.Select(GetGameView)
            .FirstOrDefault(e => TargetDisplay == e.GetTargetDisplay());
        if (gameView1 == null)
        {
            return;
        }

        gameView1.Focus();
    }
}

using(JsonReader reader = new JsonTextReader(new StringReader(j1.ToString()))) {
    reader.DateParseHandling = DateParseHandling.None;
    JObject o = JObject.Load(reader);
}

var obj = JsonConvert.DeserializeObject(jsonStr, new JsonSerializerSettings
{
    DateParseHandling = DateParseHandling.None
});

using System;
using System.Text.RegularExpressions;
using Newtonsoft.Json.Linq;
					
public class Program
{
	public static void Main()
	{
		var root = JObject.Parse(@"{""updated_at"":""2020-09-04T01:23:45Z""}");
		var token = root.SelectToken("$");
		Console.WriteLine(token);
		Console.WriteLine("----------");
		var u = Regex.Replace(token.ToString(), @".*updated_at.*""(\d.*)"".*", "$1");
		Console.WriteLine(u);
	}
}

{
  "updated_at": "2020-09-04T01:23:45Z"
}
----------
{
2020-09-04T01:23:45Z
}

var dialog = Dialog.Open(dialogPrefab, DialogButtonType.Close, "title", "message", true);
dialog.Result.Title = "new title";
dialog.Result.Message = "new message";
dialog.Invoke("SetTitleAndMessage", 0f);

// 取得
var bs = EditorUserBuildSettings.GetPlatformSettings("WindowsStoreApps", "BuildConfiguration");

// 設定
EditorUserBuildSettings.SetPlatformSettings("WindowsStoreApps", "BuildConfiguration", "Release");

bool IsInFrustum(Vector3 targetPosition)
{
    var cam = Camera.main;
    var pv = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
    var pos = pv * targetPosition;
    return (pos.z >= 0 && pos.z <= pos.w
        && pos.x >= -pos.w && pos.x <= pos.w
        && pos.y >= -pos.w && pos.y <= pos.w);
}

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using Unity.Mathematics;
using UnityEngine;

[BurstCompile]
public struct CullingJob : IJobParallelFor
{
    [ReadOnly] [DeallocateOnJobCompletion] public NativeArray<Matrix4x4> Pv;
    [ReadOnly] [DeallocateOnJobCompletion] public NativeArray<Vector3> TargetPositions;
    [WriteOnly] public NativeArray<bool> CullingResult;

    public void Execute(int index)
    {
        CullingResult[index] = IsInFrustum(TargetPositions[index]);
    }

    private bool IsInFrustum(Vector3 targetPosition)
    {
        var pos = Pv[0] * targetPosition;
        return (pos.z >= 0 && pos.z <= pos.w
            && pos.x >= -pos.w && pos.x <= pos.w
            && pos.y >= -pos.w && pos.y <= pos.w);
    }
}

using System.Linq;
using Unity.Collections;
using UnityEngine;

public class TestCulling : Monobehaviour
{
    [SerializeField] private Transform[] targetTransforms;

    private void Update()
    {
        var cam = Camera.main;
        var pv = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
        var nativePv = new NativeArray<Matrix4x4>(new [] { pv }, Allocater.JobTemp);
        var positions = targetTransforms.Select(t => t.position).ToArray();
        var nativePositions = new NativeArray<Vector3>(target, Allocator.JobTemp);
        using var nativeResult = new NativeArray<bool>(positions.Length, Allocator.JobTemp);
        var handle = new CullingJob
        {
            Pv = nativePv,
            TargetPositions = nativePositions,
            CullingResult = nativeResult
        }.Schedule(targetTransforms.Length, 32);
        handle.Complete();

        // 視錐台の外のGameObjectを非アクティブにする
        for (var i = 0; i < nativeResult.Length; i++)
        {
            targetTransforms[i].SetActive(nativeResult[i]);
        }
    }
}

using UnityEngine;

[RequireComponent(typeof(Camera))]
public class ManualCameraRenderer : MonoBehaviour
{
    public int fps = 20;
    private float _elapsed;
    private Camera _cam;

    private void Start()
    {
        _cam = GetComponent<Camera>();
        _cam.enabled = false;
    }

    private void Update()
    {
        _elapsed += Time.deltaTime;
        if (_elapsed > 1f / fps)
        {
            _elapsed = 0;
            _cam.Render();
        }
    }
}

#include <atomic>
#include <random>
#include <thread>
#include <chrono>

#ifdef _WIN32
#define UNITYCALLCONV __stdcall
#define UNITYEXPORT __declspec(dllexport)
#else
#define UNITYCALLCONV
#define UNITYEXPORT
#endif

extern "C" {
    std::thread getNumberThread;  // threadの情報を保持するための変数</span>
    std::atomic<int> latestData;  // 最後に取得できた値を保持するための変数</span>
    std::atomic<bool> exitFlag;   // threadに終了を通知するためのフラグ</span>

    int getNumber() {
        std::this_thread::sleep_for(std::chrono::milliseconds((int)(100.0 * rand() / RAND_MAX)));
        return 777;
    }

    UNITYEXPORT void UNITYCALLCONV initThread() {
        latestData = 0;
        exitFlag = false;

        // getNumber()を繰り返し呼び出しlatestDataを更新し続けるthreadを作成・開始する
        getNumberThread = std::thread([] {
            while (!exitFlag) { latestData = getNumber(); }
        });
    }

    UNITYEXPORT int UNITYCALLCONV getLatestNumber() { return latestData; }

    UNITYEXPORT void UNITYCALLCONV terminateThread() {
        exitFlag = true;         // threadに終了を通知する
        getNumberThread.join();  // threadが終了するまで待つ
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Runtime.InteropServices;

public class NativePluginTest : MonoBehaviour
{
    [DllImport("mylib")]
    private static extern int getLatestNumber();
    [DllImport("mylib")]
    private static extern void initThread();
    [DllImport("mylib")]
    private static extern void terminateThread();

    void Start() {
        // getNumber用スレッドを開始
        initThread();
    }

    void Update() {
        // 最近取得した値を読み込む
        var num = getLatestNumber();
        Debug.Log(num);
    }

    void OnDestroy() {
        // getNumber用スレッドを終了
        terminateThread();
    }
}

#include <thread>
#include <functional>
#include <chrono>

extern "C"
{
    __declspec(dllexport) void StartAsyncTask(std::function<void()> callback)
    {
        std::thread([callback]() {
            // Do some long task here
            std::this_thread::sleep_for(std::chrono::seconds(10));
            callback();
        }).detach();
    }
}

using System.Runtime.InteropServices;
using System.Threading.Tasks;

public class NativePlugin
{
    [DllImport("NativePlugin")]
    public static extern void StartAsyncTask(IntPtr callback);

    public static Task StartTask(Action callback)
    {
        var tcs = new TaskCompletionSource<bool>();
        var callbackDelegate = new Action(() => {
            callback();
            tcs.SetResult(true);
        });
        var handle = GCHandle.Alloc(callbackDelegate);
        StartAsyncTask(GCHandle.ToIntPtr(handle));
        return tcs.Task;
    }
}

pubic class Test : Monobehaviour
{
    private async void Start()
    {
        await NativePlugin.StartTask(() => {
            Debug.Log("Task completed");
        });
    }
}

using Cysharp.Threading.Tasks;
using System.Threading;
using UnityEngine;

public static class AudioSourceExtension
{
    public static UniTask PlayOneShotAsync(this AudioSource self, AudioClip audioClip, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancallationToken cancellationToken = default)
    {
        self.PlayOneShot(audioClip);
        return UniTask.WaitWhile(() => self.isPlaying, timing, cancellationToken);
    }
}

[SerializedField] private AudioSource audioSource;
[SerializedField] private AudioClip audioClip;

public async UniTaskVoid OnClick()
{
    await audioSource.PlayOneShotAsync(audioClip, cancellationToken = this.GetCancellationTokenOnDestroy()).Forget();
}

using System.Threading;
using UnityEngine;

public static class AudioExtension
{
    public static async Awaitable PlayOneShotAsync(this AudioSource self, AudioClip audioClip, CancellationToken cancellationToken = default)
    {
        self.PlayOneShot(audioClip);
        while (self.isPlaying)
        {
            await Awaitable.FixedUpdateAsync(cancellationToken);
        }
    }
}

[SerializedField] private AudioSource audioSource;
[SerializedField] private AudioClip audioClip;

public async void OnClick()
{
    await audioSource.PlayOneShotAsync(audioClip, destroyCancellationToken);
}

using Leap;
using Leap.Unity;
using System.Collections;
using UnityEngine;
using UnityEngine.Events;

public class LeapConnectionDispatcher : MonoBehaviour
{
    [SerializeField]
    private LeapServiceProvider _provider;

    [SerializeField]
    public float _maxConnectingSecond = 3f;

    private Coroutine serviceCoroutine;
    private Coroutine initCoroutine;

    /// <summary>
    /// Ultra Leap Controller2が接続された時に呼ばれるイベント
    /// </summary>
    public UnityEvent OnConnectAction;

    /// <summary>
    /// Ultra Leap Controller2が切断された時に呼ばれるイベント
    /// </summary>
    public UnityEvent OnDisconnectAction;

    /// <summary>
    /// Ultra Leap Controller2のデーモンがインストールされていない時に呼ばれるイベント
    /// </summary>
    public UnityEvent OnNoServiceAction;

    /// <summary>
    /// 起動時にUltra Leap Controller2が未接続の時に呼ばれるイベント
    /// </summary>
    public UnityEvent OnEmptyDeviceOnConnectAction;


    private void Start()
    {
        SubscribeToService();
    }


    private void OnDestroy()
    {
        UnsubscribeFromService();
    }


    private void SubscribeToService()
    {
        if (serviceCoroutine is { })
        {
            return;
        }

        serviceCoroutine = StartCoroutine(ServiceCoroutine());
    }


    private IEnumerator ServiceCoroutine()
    {
        global::Leap.Controller controller = null;
        do
        {
            controller = _provider.GetLeapController();
            yield return null;
        } while (controller is null);

        controller.Init += OnInit;
        controller.DeviceLost += OnDeviceLost;
        _provider.OnDeviceChanged += OnDeviceChanged;
    }


    private void UnsubscribeFromService()
    {
        if (_provider.GetLeapController() is { } controller)
        {
            controller.Init -= OnInit;
            controller.DeviceLost -= OnDeviceLost;
            _provider.OnDeviceChanged -= OnDeviceChanged;
        }

        if (serviceCoroutine is { })
        {
            StopCoroutine(serviceCoroutine);
            serviceCoroutine = null;
        }

        if (initCoroutine is { })
        {
            StopCoroutine(initCoroutine);
            initCoroutine = null;
        }
    }


    private void OnInit(object sender, LeapEventArgs e)
    {
        initCoroutine = StartCoroutine(InitCoroutine());
    }


    private IEnumerator InitCoroutine()
    {
        var controller = _provider.GetLeapController();
        var start = Time.time;
        do
        {
            yield return null;

            if (Time.time - start > _maxConnectingSecond)
            {
                if (!controller.IsServiceConnected)
                {
                    Debug.LogWarning("Daemon/Service is not connected");
                    OnNoServiceAction?.Invoke();
                    yield break;
                }
                if (!_provider.IsConnected())
                {
                    Debug.LogWarning("Ultra Leap Controller2 is not connected");
                    OnEmptyDeviceOnConnectAction?.Invoke();
                    yield break;
                }
                break;
            }
        } while (!_provider.IsConnected());

        OnConnectAction?.Invoke();
    }


    /// <summary>
    /// Ultra Leap Controller2が無効になった時に呼ばれる
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void OnDeviceLost(object sender, DeviceEventArgs e)
    {
        Debug.Log(nameof(OnDeviceLost));
        OnDisconnectAction?.Invoke();
    }


    /// <summary>
    /// デバイスが変更されたら呼ばれる
    /// </summary>
    /// <param name="d"></param>
    private void OnDeviceChanged(Device d)
    {
        UnsubscribeFromService();
        SubscribeToService();
    }
}

using Leap.Unity.HandsModule;

public class HandController
{
    [SerializeField]
    private HandBinder handBinder;

    [SerializeField]
    private float handScale = 1f;

    private void Start()
    {
        // 手の各ボーンの位置をトラッキング位置に追従しない
        handBinder.SetPositions = false;

        // 手の各Scaleのオフセットを調整する
        handBinder.BoundHand.scaleOffset *= handScale;
        foreach (var finger in handBinder.BoundHand.fingers)
        {
            finger.fingerTipScaleOffset *= handScale;
        }
    }
}