Unity Note

List<string> sceneNames = new List<string>();
for (int i = 0; i < SceneManager.sceneCountInBuildSettings; i++)
{
    var scenePath = SceneUtility.GetScenePathByBuildIndex(i);
    sceneNames.Add(string.IsNullOrEmpty(scenePath) ? "null scene" : Path.GetFileNameWithoutExtension(scenePath));
}

var obj = new GameObject();
if (obj.transform!=null)
{
    Debug.Log("exist transform");
}
else
{
    Debug.Log("not exist");
}
// 上面的代码会输出 exist transform

public class Utils
{
    public static bool TraverseGObj(Func<GameObject, bool/* isBreak */> opt, bool includeInactive = false)
    {
        for (var sceneIdx = 0; sceneIdx < SceneManager.sceneCount; sceneIdx++)
        {
            var scene = SceneManager.GetSceneAt(sceneIdx);
            if (TraverseGObjInScene(scene, opt))
            {
                return true;
            }
        }
        return false;
    }

    static List<Transform> __temp_transList = new List<Transform>();
    public static bool TraverseGObjInScene(Scene scene, Func<GameObject, bool/* isBreak */> opt, bool includeInactive = false)
    {
        if (!scene.IsValid()) return false;

        var rootGObjs = scene.GetRootGameObjects();
        foreach (var gobj in rootGObjs)
        {
            if(!includeInactive && !gobj.activeSelf) continue;
            // GetComponentsInChildren include gobj self
            gobj.GetComponentsInChildren<Transform>(includeInactive, __temp_transList);
            foreach (var trans in __temp_transList)
            {
                if (opt(trans.gameObject)) return true;
            }
        }
        return false;
    }

    public static bool TraverseComp<TComp>(Func<TComp, bool /*isBreak*/> opt, bool includeInactive = false) where TComp : class
    {
        TraverseGObj((gobj) =>
        {
            var comps = gobj.GetComponents<TComp>();
            var comp = gobj.GetComponent<TComp>();
            return opt(comp);
        }, includeInactive);
        return false;
    }

    public static bool TraverseCompInScene<TComp>(Scene scene, Func<TComp, bool/* isBreak */> opt, bool includeInactive = false) where TComp : class
    {
        TraverseGObjInScene(scene, (gobj) =>
        {
            var comp = gobj.GetComponent<TComp>();
            return opt(comp);
        }, includeInactive);
        return false;
    }

    public static TComp Find<TComp>(bool includeInactive = false) where TComp : class
    {
        TComp retComp = null;
        TraverseComp<TComp>((comp) =>
        {
            if (comp != null)
            {
                retComp = comp;
                return true;
            }
            return false;
        });
        return retComp;
    }

    public static TComp FindInScene<TComp>(Scene scene, bool includeInactive = false) where TComp : class
    {
        TComp retComp = null;
        TraverseCompInScene<TComp>(scene,(comp) =>
        {
            if (comp != null)
            {
                retComp = comp;
                return true;
            }
            return false;
        }, includeInactive);
        return retComp;
    }
}

/*
UIScene 中的结构如下
-Canvas
--MainUI
---PlayerIcon
PlayerIcon.transform.root 返回的是 Canvas
*/

Vector2 originDir = new Vector2(0, 1);
Vector2 targetDir = new Vector2(1, 0);
Debug.Log("y->x  " + Vector2.Angle(originDir, targetDir).ToString());
targetDir = new Vector2(-1, 0);
Debug.Log("y->-x " + Vector2.Angle(originDir, targetDir).ToString());
targetDir = new Vector2(0, -1);
Debug.Log("y->-y " + Vector2.Angle(originDir, targetDir).ToString());
// 下面是输出结果：
// y->x  90
// y->-x 90
// y->-y 180

// 下面的代码是错误的 ERROR  应该使用 Vector2.SignedAngle 来获取正确的带符号的旋转角度
float rotation = Vector2.Angle(originDir,targetDir);
if (targetDir.x < originDir.x)
{
        rotation = -rotation;
}
//在 Unity 中 正的旋转度数表示 沿着旋转轴的方向看 是逆时针旋转，沿着旋转轴的反方向看 是 顺时针旋转。

// 设置 gObj 朝向前方向上 30 度方向
Vector3 dir = new Vector3(Math.Cos(30*Math.PI/180),Math.Cin(30*Math.PI/180),0);
gObj.transfrom.LookAt(Transform.TransformDirection(dir));

// unity c++ 层使用float 数组来表示矩阵
float m_Data[16];

// float 数组中矩阵以列主序存储, m12 表示 矩阵 1 行 2 列的元素
m_Data[0] // column0 - m00
m_Data[1] // column0 - m10
m_Data[2] // column0 - m20
m_Data[3] // column0 - m30

m_Data[4] // column1 - m01
m_Data[5] // column1 - m11
m_Data[6] // column1 - m21
m_Data[7] // column1 - m31

// 访问矩阵指定元素
Matrix4x4 mat;
mat.m12 == mat[1][2]  // 1 行 2 列的元素

Vector3 pos = new Vector3(10, 5, 20);
// TRS 表示先缩放后旋转再位移
Vector3 newPos1 = Matrix4x4.TRS(new Vector3(5,10,-5), Quaternion.Euler(45,45,45), Vector3.one).MultiplyPoint(pos);
Vector3 newPos2 = (Matrix4x4.Translate(new Vector3(5, 10, -5)) * Matrix4x4.Rotate(Quaternion.Euler(45, 45, 45))).MultiplyPoint(pos);
Debug.Log("newPos1==newPos2 " + (newPos1==newPos2));  // 输出 True

Matrix4x4[] bparr = smr.sharedMesh.bindposes;
Matrix4x4 l2p = bparr[testBoneParentIdx] * bparr[testBoneIdx].inverse;
Matrix4x4 p2l = l2p.inverse;
Matrix4x4 p2lS = Matrix4x4.Scale(p2l.lossyScale);
Matrix4x4 p2lR = Matrix4x4.Rotate(p2l.rotation);
Matrix4x4 p2lT = p2l * p2lS.inverse * p2lR.inverse;

// 先按照 a 旋转，然后按照 b 旋转，可以得到 c 表示的旋转
Quaternion c = a * b;
Debug.Log("c = " + c.eulerAngles);

// Quaternion 的乘积运算复合结合律
Quaternion d = a * b * c = a * (b * c);

Vector2 dir = new Vector2(1, 0);
Debug.Log("old dir = " + dir);
// 朝向 z 轴正方向观察时，逆时针旋转为正
dir = Quaternion.Euler(0, 0, 90) * dir;
Debug.Log("new dir = " + dir);

// old dir = (1,0)
// new dir = (0,1)

  Quaternion a = Quaternion.Euler(30, 30, 0);
  Quaternion b = Quaternion.Euler(10, 10, 30);
    // 旋转的叠加
    // 先按照 a 旋转，然后按照 b 旋转，可以得到 c 表示的旋转
  Quaternion c = a * b;
  Debug.Log("c = " + c.eulerAngles);
    // 旋转的差
    // 先按 c 旋转，然后按照 b 表示的旋转的反向旋转，可以得到 a 表示的旋转
  var tA = c * Quaternion.Inverse(b);
  // 错误的旋转差
  var tB = c * Quaternion.Inverse(a);
    // 旋转的差
    // 先按 a 表示的旋转的反向旋转，然后按照 c 旋转，可以得到 b 表示的旋转
  var tB1 = Quaternion.Inverse(a) * c;
  Debug.Log("tA==a " + (tA == a));   // 输出 True
  Debug.Log("tB==b " + (tB == b));   // 输出 False
  Debug.Log("tB1==b " + (tB1 == b)); // 输出 True

  // 将全局坐标系的旋转转化为本地坐标系旋转
  // this will transform WorldRotation to Target's local space
  Quaternion LocalRotation = Quaternion.Inverse(Target.transform.rotation) * WorldRotation;

  // 将本地旋转转化为全局旋转
  Quaternion WorldRot = Target.transform.rotation * LocalRot;

  // 下面是测试代码 transform 为 testNode1 和 testNode2 共同的父节点
  Vector3 pos = new Vector3(10, 5, 20);
  testNode1 = (Transform)GGameObject.Find(transform, "GObj1", typeof(Transform), true);
  testNode1.localPosition = pos;
  testNode2 = (Transform)GGameObject.Find(transform, "GObj2", typeof(Transform), true);
  testNode2.localPosition = pos;

  testNode1.localRotation = Quaternion.Euler(15, 10, 40);
  testNode2.rotation = transform.rotation * Quaternion.Euler(15, 10, 40);
  Debug.Log("1 testNode1.rotation == testNode2.rotation " + (testNode1.rotation == testNode2.rotation)); // print True

  testNode1.rotation = transform.rotation * Quaternion.Euler(25, 20, 50);
  testNode2.localRotation = Quaternion.Inverse(transform.rotation) * testNode1.rotation;
  Debug.Log("2 testNode1.rotation == testNode2.rotation " + (testNode1.rotation == testNode2.rotation)); // print True

  testNode1.localRotation *= Quaternion.Euler(15, 10, 40);
  testNode2.rotation *= Quaternion.Euler(15, 10, 40);
  Debug.Log("3 testNode1.rotation == testNode2.rotation " + (testNode1.rotation == testNode2.rotation)); // print True

var rot = Quaternion.AngleAxis(5 * Time.deltaTime, Vector3.up);
transform.rotation *= rot; // transform.localRotation *= rot; 使用 localRotation 也可以

public class Test:MonoBehaviour
{
    public int value2 = 10;

    public Test ()
    {
        Debug.Log ("Test value2 = " + value2.ToString ());

        value2 = 11;
    }

    void Awake ()
    {
        Debug.Log ("Awake value2 = " + value2.ToString ());
    }

    void Start ()
    {
        Debug.Log ("Start value2 = " + value2.ToString ());
    }
}
// Output
//Test value2 = 10    //构造函数中读的值为 初始化语句中赋的值
//Awake value2 = 120  //在编辑器中设置了 value2 的值为 120, 所以编辑器赋值在 Awake 之前执行的。
//Start value2 = 120

var obj = Resources.Load ("UI/Root_bg") as GameObject;
obj.transform.SetParent(rootUI);
// 上面代码会引发下面错误
// Setting the parent of a transform which resides in a prefab is disabled to prevent data corruption.

// 正确的做法如下：
// Instantiate 是 Object 的静态方法
var obj = Instantiate(Resources.Load("UI/Root_bg")) as GameObject;
obj.transform.SetParent(rootUI);

void Update()
{
    Vector3 forward = transform.TransformDirection(Vector3.forward) * 10;
    // Debug 绘制射线
    Debug.DrawRay(transform.position, forward, Color.green);

    // Debug 绘制线段
    Debug.DrawLine(Vector3.zero, new Vector3(0, 5, 0), color);
}

void OnDrawGizmosSelected()
{
    // Draws a 5 unit long red line in front of the object
    Gizmos.color = Color.red;
    Vector3 direction = transform.TransformDirection(Vector3.forward) * 5;
    Gizmos.DrawRay(transform.position, direction);
}

void OnDrawGizmosSelected()
{
    Gizmos.color = Color.red;
    Vector3 direction = transform.TransformDirection(Vector3.forward) * 5;

    // Vector3 center, float fov, float maxRange, float minRange, float aspect
    Gizmos.DrawFrustum(transform.position, 30, 1000, 0.1, 2);
}

// 指定 GFancyList 组件依赖 ScrollPositionController
[RequireComponent(typeof(ScrollPositionController))]
public class GFancyList

  [System.Serializable]
  public class WidgetSlotInfo
  {
      public string widgetSlotName;
      public List<string> widgetNameList;
  }

// Assets\Scenes\CustomVarNameAttribute.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CustomVarNameAttribute: PropertyAttribute
{
    public string name;
    public bool showVarName;
    public CustomVarNameAttribute(string name, bool showVarName=false)
    {
        this.name = name;
        this.showVarName = showVarName;
    }
}

// Assets\Scenes\Editor\CustomVarNameDrawer.cs
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;

[CustomPropertyDrawer(typeof(CustomVarNameAttribute))]
public class CustomVarNameDrawer : PropertyDrawer
{
    GUIContent _label = null;

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        if(_label == null)
        {
            var attri = attribute as CustomVarNameAttribute;
            string name = string.Empty;
            if(attri.showVarName)
            {
                name = string.Format("{0} [{1}]", attri.name , property.name);
            }
            else
            {
                name = attri.name;
            }
            _label = new GUIContent(name);
        }
        EditorGUI.PropertyField(position, property, _label);
    }
}

//
using UnityEngine;
public class Test : MonoBehaviour
{
    [CustomVarNameAttribute("测试")]
    public int test;
    [CustomVarNameAttribute("测试", true)]
    public int testName;
}

//
using UnityEngine;

public class CustomVarReadOnlyAttribute : PropertyAttribute
{
}

//
using UnityEditor;
using UnityEngine;

[CustomPropertyDrawer(typeof(CustomVarReadOnlyAttribute))]
public class CustomVarReadOnlyDrawer : PropertyDrawer
{
    public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
    {
        return EditorGUI.GetPropertyHeight(property, label, true);
    }

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        var originEnalbe = GUI.enabled;
        GUI.enabled = false;
        EditorGUI.PropertyField(position, property, label, true);
        GUI.enabled = originEnalbe;
    }
}

//
using UnityEngine;

public class Test : MonoBehaviour
{
    [CustomVarReadOnly]
    public int i = 0;

    [CustomVarReadOnly]
    public Vector3 t;
}

// GameView 中射线检测
// 从 main 摄像机所在位置发出一条指向鼠标位置的射线
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Input.GetMouseButtonDown(0))
{
    RaycastHit hit;
    //如果射线碰撞到对象，把返回信息储存到 hit 中
    if (Physics.Raycast(ray, out hit))
    {
        //如果碰撞的对象是 Cube，则销毁它
        if (hit.transform.gameObject.name == "Cube")
        {
            Destroy(hit.transform.gameObject);
        }
    }
}

// 编辑器 SceneView中的射线检测
SceneView.onSceneGUIDelegate += OnSceneGUI;
void OnSceneGUI(SceneView sceneView)
{
    if (Event.current.button == 1 && Event.current.type == EventType.MouseDown)
    {
        Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
        //Ray ray = sceneView.camera.ScreenPointToRay(Event.current.mousePosition);
        var hits = Physics.RaycastAll(ray);
        foreach (var hit in hits)
        {
            if (hit.transform.tag == selectedTag)
            {
                Selection.activeGameObject = hit.transform.gameObject;
                break;
            }
        }
    }
}

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    // In this example we show how to invoke a coroutine and
    // continue executing the function in parallel.

    private IEnumerator coroutine;

    void Start()
    {
        // - After 0 seconds, prints "Starting 0.0"
        // - After 0 seconds, prints "Before WaitAndPrint Finishes 0.0"
        // - After 2 seconds, prints "WaitAndPrint 2.0"
        print("Starting " + Time.time);

        // Start function WaitAndPrint as a coroutine.

        coroutine = WaitAndPrint(2.0f);
        StartCoroutine(coroutine);

        print("Before WaitAndPrint Finishes " + Time.time);
    }

    // every 2 seconds perform the print()
    private IEnumerator WaitAndPrint(float waitTime)
    {
        while (true)
        {
            yield return new WaitForSeconds(waitTime);
            print("WaitAndPrint " + Time.time);
        }
    }
}

// In this example we show how to invoke a coroutine and wait until it
// is completed

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{
    IEnumerator Start()
    {
        // - After 0 seconds, prints "Starting 0.0"
        // - After 2 seconds, prints "WaitAndPrint 2.0"
        // - After 2 seconds, prints "Done 2.0"
        print("Starting " + Time.time);

        // Start function WaitAndPrint as a coroutine. And wait until it is completed.
        // the same as yield return WaitAndPrint(2.0f);
        yield return StartCoroutine(WaitAndPrint(2.0f));
        print("Done " + Time.time);
    }

    // suspend execution for waitTime seconds
    IEnumerator WaitAndPrint(float waitTime)
    {
        yield return new WaitForSeconds(waitTime);
        print("WaitAndPrint " + Time.time);
    }
}

var projAbsPath = Path.GetDirectoryName(Application.dataPath);
var buildAbsPath = projAbsPath + "/build";

var w = Camera.main.pixelWidth;
var h = Camera.main.pixelHeight;

public static bool IsVisibleFrom(Bounds bounds, Camera camera)
{
    Plane[] planes = GeometryUtility.CalculateFrustumPlanes(camera);
    return GeometryUtility.TestPlanesAABB(planes, bounds);
}

// LeftBottom LeftUp RightUp RightBottom
Vector3[] frustumNearCorners = new Vector3[4];
Vector3[] frustumFarCorners = new Vector3[4];
void CalcFrustumCorners()
{
    // 0-leftBottom 1-leftTop 2-rightTop 3-rightBottom
    _camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _camera.nearClipPlane, Camera.MonoOrStereoscopicEye.Mono, frustumNearCorners);
    _camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _camera.farClipPlane, Camera.MonoOrStereoscopicEye.Mono, frustumFarCorners);

    for (int i = 0; i < 4; i++)
    {
        frustumNearCorners[i] = transform.TransformPoint(frustumNearCorners[i]);
        frustumFarCorners[i] = transform.TransformPoint(frustumFarCorners[i]);
    }
}

using UnityEngine;

public class TestPlane : MonoBehaviour
{
    [Range(1,100)]
    public float rayLength = 2;
    public Color[] _colors = new Color[6] {Color.red, Color.blue, Color.green, Color.cyan, Color.magenta, Color.yellow};
    void OnDrawGizmosSelected()
    {
        var oldColor = Gizmos.color;
        {
            Gizmos.color = Color.black;
            Gizmos.DrawSphere(Vector3.zero, 0.05f);
            // [0] = Left, [1] = Right, [2] = Down, [3] = Up, [4] = Near, [5] = Far
            Plane[] planes = GeometryUtility.CalculateFrustumPlanes(Camera.main);

            for (int i = 0; i < 6; ++i)
            {
                // Tips:
                // normal   是世界空间下，平面的法线方向
                // distance 是世界空间下，平面到原点的距离
                // distance < 0, 表示原点在平面法线相反方向的一侧
                // distance = 0, 表示原点在平面上
                // distance > 0, 表示原点在平面法线相同方向的一侧
                var origin = -planes[i].normal * planes[i].distance;
                var dir = planes[i].normal * rayLength;
                //Gizmos.color = _colors[i];
                //Gizmos.DrawRay(origin, dir);
                DrawArrow.ForGizmo(origin, dir, _colors[i], true, 0.05f);
            }
        }
        Gizmos.color = oldColor;
    }
}

  public static Material GetMaterial(Renderer render)
  {
      #if UNITY_EDITOR
      return render.material;
      #else
      return render.sharedMaterial;
      #endif
  }

// Tips: HandleUtility 为 UnityEditor下的类
Vector3 mousePosition = Event.current.mousePosition;
var screenPos = HandleUtility.GUIPointToScreenPixelCoordinate(mousePosition);

using UnityEngine;
using UnityEngine.UI;

public class TestResolution : MonoBehaviour
{
    public Text txt_Info;
    public InputField if_Size;
    public Button btn_ChangeSize;
    public Button btn_Update;

    int width
    {
        get
        {
            int idx = Screen.resolutions.Length - 1;
            // Portrait
            //return Screen.resolutions[idx].width;
            // Landscape
            return Screen.resolutions[idx].height;
        }
    }

    int height
    {
        get
        {
            int idx = Screen.resolutions.Length - 1;
            // Portrait
            //return Screen.resolutions[idx].height;
            // Landscape
            return Screen.resolutions[idx].width;
        }
    }


    private void Awake()
    {
        txt_Info.text = string.Format("mw{0}, mh{1}, cw{2}, ch{3}",
            width, height,
            Screen.currentResolution.width, Screen.currentResolution.height);
        btn_ChangeSize.onClick.AddListener(OnClickChangeSize);
        btn_Update.onClick.AddListener(OnClickUpdateInfo);
    }

    int newHeight
    {
        get
        {
            if(string.IsNullOrEmpty(if_Size.text))
            {
                return 480;
            }
            return int.Parse(if_Size.text);
        }
    }

    float ratio
    {
        get
        {
            return (float)newHeight / height;
        }
    }

    void OnClickChangeSize()
    {
        int newWidth = (int)(width * ratio);
        if (newHeight > 0 && height >= newHeight)
        {
            Screen.SetResolution(newWidth, newHeight, FullScreenMode.FullScreenWindow);
            OnClickUpdateInfo();
        }
        else
        {
            txt_Info.text = string.Format("ERROR: w{0} h{1} newW{2} newH{3}", width, height, newWidth, newHeight);
        }
    }

    void OnClickUpdateInfo()
    {
        txt_Info.text = string.Format("mw{0}, mh{1}, cw{2}, ch{3}, r{4:0.00}",
            width, height,
            Screen.currentResolution.width, Screen.currentResolution.height,
            ratio);
    }
}

  Texture2D WriteTexture2D()
  {
      int texSize = 100;
      var tex = new Texture2D(texSize, texSize);
      for(int i=0; i<texSize; i++)
      {
          for(int j=0; j<texSize; j++)
          {
              Color color = Color.black;
              color.r = (float)i / texSize;
              color.g = (float)j / texSize;
              tex.SetPixel(i, j, color);
          }
      }
      tex.Apply();
      string imgPath = Application.dataPath + "/../test.png";
      Debug.Log(imgPath);
      System.IO.File.WriteAllBytes(imgPath, tex.EncodeToPNG());
      return tex;
  }

  public static void DrawPng(int pngWidth, int pngHeight, string imgPath, Material mat=null)
  {
      if (pngWidth < 1 || pngHeight < 1)
      {
          Debug.LogWarning(string.Format("png size error! w={0} h={1}", pngWidth, pngHeight));
          return;
      }
      if( string.IsNullOrEmpty(imgPath))
      {
          Debug.LogError("imgName is nullOrEmpty");
          return;
      }

      Rect rect = new Rect(0, 0, pngWidth, pngHeight);
      RenderTexture rt = new RenderTexture(pngWidth, pngHeight, 0);
      Graphics.Blit(mat.mainTexture, rt, mat);

      RenderTexture.active = rt;
      Texture2D tex = new Texture2D((int)rt.width, (int)rt.height, TextureFormat.RGB24, false);
      tex.ReadPixels(rect, 0, 0);
      tex.Apply();
      RenderTexture.active = null;

      System.IO.File.WriteAllBytes(imgPath, tex.EncodeToPNG());
      GameObject.Destroy(rt);
  }

byte[] bytes = lipSp.texture.EncodeToPNG();
File.WriteAllBytes(Application.dataPath + "/../__TEST" +  ".png", bytes);

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

public class GTestHelper : MonoBehaviour
{
    static bool _is_inited = false;

    public Text text_fps;
    public Text text_sceneName;
    public Button btn_previous;
    public Button btn_next;

    public float fpsMeasuringDelta = 2.0f;

    private float timePassed;
    private int m_FrameCount = 0;
    private float m_FPS = 0.0f;

    private int curSceneIndex;

    private void Awake()
    {
        if (_is_inited == true)
        {
            GameObject.DestroyImmediate(gameObject);
            return;
        }

        _is_inited = true;
        SceneManager.sceneLoaded += OnSceneLoaded;
    }

    private void Start()
    {
        gameObject.name = "__GTestGObj_Canvas__";
        DontDestroyOnLoad(gameObject);
        timePassed = 0.0f;

        curSceneIndex = 0;
        SetSceneName();
        if (btn_next != null)
        {
            btn_next.onClick.AddListener(delegate ()
            {
                ChangeScene(true);
            });
        }
        if (btn_previous != null)
        {
            btn_previous.onClick.AddListener(delegate ()
            {
                ChangeScene(false);
            });
        }
    }

    private void Update()
    {
        m_FrameCount = m_FrameCount + 1;
        timePassed = timePassed + Time.deltaTime;

        if (timePassed > fpsMeasuringDelta)
        {
            m_FPS = m_FrameCount / timePassed;

            timePassed = 0.0f;
            m_FrameCount = 0;
            SetFPS();
        }
    }

    void SetFPS()
    {
        if (text_fps != null)
            text_fps.text = string.Format("FPS: {0}", m_FPS);

    }

    void SetSceneName()
    {
        if (text_sceneName != null)
        {
            var scene = SceneManager.GetActiveScene();
            text_sceneName.text = string.Format("Scene: {0}", scene.name);
        }
    }

    void ChangeScene(bool isNext)
    {
        if (isNext)
        {
            curSceneIndex = (curSceneIndex + 1) % SceneManager.sceneCountInBuildSettings;
        }
        else
        {
            curSceneIndex = curSceneIndex - 1;
            if (curSceneIndex < 0)
            {
                curSceneIndex = SceneManager.sceneCountInBuildSettings + curSceneIndex;
            }
        }

        SceneManager.LoadScene(curSceneIndex);
    }

    void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
    {
        SetSceneName();
    }
}

using UnityEngine;
using System.Collections;

public class MyGameClass : MonoBehaviour
{
    private static ILogger logger = Debug.unityLogger;
    private static string kTAG = "MyGameTag";

    void Start()
    {
        logger.logEnabled = Debug.isDebugBuild;

        logger.Log(kTAG, "This log will be displayed only in debug build");
    }
}

using UnityEngine;
using System.Collections;

public class MyGameClass : MonoBehaviour
{
    private static ILogger logger = Debug.unityLogger;
    private static string kTAG = "MyGameTag";

    void Start()
    {
        if (Debug.isDebugBuild)
            logger.filterLogType = LogType.Log;
        else
            logger.filterLogType = LogType.Warning;

        logger.Log(kTAG, "This log will be displayed only in debug build");
        logger.LogError(kTAG, "This log will be displayed in debug and release build");
    }
}

static bool _cancleOpt = false;
static IEnumerator ForeachObjInEachScene<ObjT>(bool includeInactive, System.Action<ObjT> opt)
    where ObjT : UnityEngine.Object
{
    _cancleOpt = false;
    var scenePaths = AssetDatabase.FindAssets("t:Scene", new string[] {
            "Assets"
        });

    for(int i=0; i<scenePaths.Length; i++)
    {
        var scenePath = AssetDatabase.GUIDToAssetPath(scenePaths[i]);
        float sceneProgress = (float)i / (float)scenePaths.Length;

        yield return EditorCoroutineUtility.StartCoroutineOwnerless(ForeachObjInScene<ObjT>(scenePath, includeInactive, scenePaths.Length, i, opt));
        if(_cancleOpt == true)
        {
            break;
        }
    }

    EditorUtility.ClearProgressBar();
    yield return null;
}
static IEnumerator ForeachObjInScene<ObjT>(string scenePath, bool includeInactive, int sceneCount, int curSceneIdx, System.Action<ObjT> opt)
    where ObjT : UnityEngine.Object
{
    if (opt == null) yield break;

    var scene = EditorSceneManager.OpenScene(scenePath);
    if (scene == null)
    {
        Debug.LogWarningFormat("scene not exist! {0}", scenePath);
    }

    var objArr = GameObject.FindObjectsOfType<ObjT>(includeInactive);
    for(int i=0; i<objArr.Length; i++)
    {
        var obj = objArr[i];
        float objProgress = (float)i / (float)objArr.Length;
        opt(obj);

        var info = string.Format("Progessing {0} sceneProgress:{1}/{2} objProgress:{3}/{4}",
                                 scenePath, curSceneIdx, sceneCount, i, objArr.Length);
        if(EditorUtility.DisplayCancelableProgressBar("Process Obj", info, objProgress))
        {
            _cancleOpt = true;
            yield break;
        }
        yield return null;
    }

    if (!EditorSceneManager.SaveScene(scene))
    {
        Debug.LogWarningFormat("Save Scene Failed! scene = {0}", scenePath);
    }
    if (!EditorSceneManager.CloseScene(scene, true))
    {
        Debug.LogWarningFormat("Close Scene Failed! scene = {0}", scenePath);
    }

    yield return null;
}

using UnityEngine;
public class RuntimeExecute
{
    [RuntimeInitializeOnLoadMethod]
    private static void OnRuntimeMethodLoad()
    {
        Debug.Log("运行时执行");
    }
}

using UnityEditor;
using UnityEngine;

[InitializeOnLoad]
public class EditorExecute
{
    static EditorHelper()
    {
        Debug.Log("启动编辑器时执行");
    }
}

using UnityEngine;
using UnityEditor;

using System.Linq;
using System.Collections;
using System.Collections.Generic;

public static class RefRefCheckerTools
{
    [MenuItem("Tools/Find Unused Assets", false, 101)]
    static private void FindUnusedAssets()
    {
        var artsPath = "Assets";

        Run(
            "t:Animation t:AnimatorController t:Font t:Material t:Mesh t:Model t:Sprite t:Texture t:VideoClip",
            new string[] {
                artsPath
            },
            "t:Scene t:Prefab",
            new string[] {
                artsPath
            }
        );
    }

    private static void Run(string srcPattern, string[] srcPaths, string dstPattern, string[] dstPaths)
    {
        var iterator = Match(srcPattern, srcPaths, dstPattern, dstPaths).GetEnumerator();
        EditorApplication.update = delegate ()
        {
            if (!iterator.MoveNext())
            {
                EditorUtility.ClearProgressBar();
                EditorApplication.update = null;
            }
        };
    }

    private static IEnumerable Match(string srcPattern, string[] srcPaths, string dstPattern, string[] dstPaths)
    {
        var files = AssetDatabase.FindAssets(dstPattern, dstPaths)
            .Select(item => AssetDatabase.GUIDToAssetPath(item))
            .ToArray();

        Debug.Log("total files count : " + files.Length);

        var fileGuilds = new Dictionary<string, int>();
        for (var i = 0; i < files.Length; i++)
        {
            var file = files[i];
            if (EditorUtility.DisplayCancelableProgressBar("Searching...", file, (float)i / (float)files.Length))
                yield break;

            var sceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(file);
            if (sceneAsset != null)
            {
                foreach (var assetPath in AssetDatabase.GetDependencies(file, false))
                {
                    var guid = AssetDatabase.AssetPathToGUID(assetPath);
                    var c = 0;
                    if (!fileGuilds.TryGetValue(guid, out c))
                        fileGuilds.Add(guid, 0);
                    fileGuilds[guid] += 1;
                }
            }
            else
            {
                foreach (var obj in AssetDatabase.LoadAllAssetsAtPath(file))
                {
                    if (obj != null)
                    {
                        SerializedObject so = new SerializedObject(obj);
                        var iter = so.GetIterator();
                        while (iter.Next(true))
                        {
                            if (iter.propertyType == SerializedPropertyType.ObjectReference && iter.objectReferenceInstanceIDValue != 0)
                            {
                                var assetPath = AssetDatabase.GetAssetPath(iter.objectReferenceInstanceIDValue);
                                if (!string.IsNullOrEmpty(assetPath))
                                {
                                    var guid = AssetDatabase.AssetPathToGUID(assetPath);
                                    var c = 0;
                                    if (!fileGuilds.TryGetValue(guid, out c))
                                        fileGuilds.Add(guid, 0);
                                    fileGuilds[guid] += 1;
                                }
                            }
                        }
                    }
                    else
                    {
                        Debug.LogError("obj is null! " + file);
                    }
                }
            }

            yield return null;
        }

        var count = 0;
        var guids = AssetDatabase.FindAssets(srcPattern, srcPaths);
        foreach (var item in guids)
        {
            if (!fileGuilds.ContainsKey(item))
            {
                var assetPath = AssetDatabase.GUIDToAssetPath(item);
                Debug.LogWarning(string.Format("Found unused asset {0}({1}).", assetPath, item), AssetDatabase.LoadAssetAtPath<Object>(assetPath));
                count++;
            }
        }
        Debug.LogWarning("Total unused asset count : " + count);
    }
}

void GetAllTextures(Material mat, List<Texture> textures)
{
    textures.Clear();
    Shader shader = mat.shader;
    for(int i=0; i<ShaderUtil.GetPropertyCount(shader); i++)
    {
        if(ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
        {
            var propName = ShaderUtil.GetPropertyName(shader, i);
            var tex = mat.GetTexture(propName);
            if(tex != null)
            {
                textures.Add(tex);
            }
        }
    }
}

// scene view
SceneView.RepaintAll();

// game view
System.Reflection.Assembly assembly = typeof(UnityEditor.EditorWindow).Assembly;
System.Type type = assembly.GetType( "UnityEditor.GameView" );
EditorWindow gameview = EditorWindow.GetWindow(type);
gameview.Repaint();

// https://docs.unity3d.com/ScriptReference/EditorApplication.ExecuteMenuItem.html
// Simple script that lets you create a new
// scene, create a cube and an empty game object in the scene
// Save the scene and close the editor

using UnityEditor;
using UnityEditor.SceneManagement;

public class ExampleClass
{
    [MenuItem("Examples/Execute menu items")]
    static void EditorPlaying()
    {
        var newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);

        EditorApplication.ExecuteMenuItem("GameObject/3D Object/Cube");
        EditorApplication.ExecuteMenuItem("GameObject/Create Empty");

        EditorSceneManager.SaveScene(newScene, "Assets/MyNewScene.unity");
        EditorApplication.Exit(0);
    }
}

  // Engine namespace code
  class GUtility
  {
      static public string FuncName = "";
      static public List<object> Args = new List<object>();
      static public void CallEditorFunc(string funcName, params object[] args)
      {
  #if UNITY_EDITOR
          FuncName = funcName;
          Args.Clear();
          Args.AddRange(args);
          UnityEditor.EditorApplication.ExecuteMenuItem("GFW/CallEditorFunc");
          FuncName = "";
          Args.Clear();
  #endif
      }
  }

  // Editor namespace code
  class GEditorUtility
  {
      [MenuItem("GFW/CallEditorFunc")]
      public static void CallEditorFunc()
      {
          switch(GUtility.FuncName)
          {
              case "ExportFbx":
                  if(GUtility.Args.Count<2)
                  {
                      Debug.LogError("ExportFbx args count < 2");
                      return;
                  }
                  ExportFbx((GameObject)GUtility.Args[0], (string)GUtility.Args[1]);
                  break;
          }
      }
  }

# cd 到 binary2text.exe 路径
cd C:\Program Files\Unity\Hub\Editor\2020.3.8f1c1\Editor\Data\Tools

# 对文件进行转换
.\binary2text.exe D:\TEMP\LightingData.asset