unity源碼解析GameObject

原創 梁工123 2018-09-01 23:12
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine.Internal;
using UnityEngineInternal;

namespace UnityEngine
{
    public sealed class GameObject : Object
    {
        public extern bool isStatic
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            set;
        }

        internal extern bool isStaticBatchable
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Transform 組件的接口
        public extern Transform transform
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Rigidbody 組件的接口
        public extern Rigidbody rigidbody
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Rigidbody2D 組件的接口
        public extern Rigidbody2D rigidbody2D
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Camera 組件的接口
        public extern Camera camera
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Light 組件的接口
        public extern Light light
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Animation 組件的接口
        public extern Animation animation
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得ConstantForce 組件的接口
        public extern ConstantForce constantForce
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Renderer 組件的接口
        public extern Renderer renderer
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得AudioSource 組件的接口
        public extern AudioSource audio
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得GUIText 組件的接口
        public extern GUIText guiText
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得NetworkView 組件的接口
        public extern NetworkView networkView
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得GUIElement 組件的接口
        [Obsolete("Please use guiTexture instead")]
        public extern GUIElement guiElement
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得GUITexture組件的接口
        public extern GUITexture guiTexture
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Collider 組件的接口
        public extern Collider collider
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得Collider2D 組件的接口
        public extern Collider2D collider2D
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;

        }


        public extern HingeJoint hingeJoint
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得ParticleEmitter 組件的接口
        public extern ParticleEmitter particleEmitter
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }
//提供了獲得ParticleSystem 組件的接口
        public extern ParticleSystem particleSystem
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }

        public extern int layer
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            set;
        }

        [Obsolete("GameObject.active is obsolete. Use GameObject.SetActive(), GameObject.activeSelf or GameObject.activeInHierarchy.")]
        public extern bool active
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            set;
        }

        public extern bool activeSelf
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }

        public extern bool activeInHierarchy
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
        }

        public extern string tag
        {
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            get;
            [WrapperlessIcall]
            [MethodImpl(MethodImplOptions.InternalCall)]
            set;
        }

        public GameObject gameObject
        {
            get
            {
                return this;
            }
        }
//構造函數
        public GameObject(string name)
        {
            GameObject.Internal_CreateGameObject(this, name);
        }
//構造函數
        public GameObject()
        {
            GameObject.Internal_CreateGameObject(this, null);
        }
//構造函數，並且添加一個組件
        public GameObject(string name, params Type[] components)
        {
            GameObject.Internal_CreateGameObject(this, name);
            for (int i = 0; i < components.Length; i++)
            {
                Type componentType = components[i];
                this.AddComponent(componentType);
            }
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void SampleAnimation(AnimationClip animation, float time);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern GameObject CreatePrimitive(PrimitiveType type);

        [WrapperlessIcall, TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern Component GetComponent(Type type);
//獲得組件
        public T GetComponent<T>() where T : Component
        {
            return this.GetComponent(typeof(T)) as T;
        }

        public Component GetComponent(string type)
        {
            return this.GetComponentByName(type);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        private extern Component GetComponentByName(string type);

        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
        public Component GetComponentInChildren(Type type) //這個需要注意，是一個遞歸方法，從子節點查找組件，找到立即返回，如果最後都沒有找到則返回空
        {
            if (this.activeInHierarchy)
            {
                Component component = this.GetComponent(type);
                if (component != null)
                {
                    return component;
                }
            }
            Transform transform = this.transform;
            if (transform != null)
            {
                foreach (Transform transform2 in transform)
                {
                    Component componentInChildren = transform2.gameObject.GetComponentInChildren(type);
                    if (componentInChildren != null)
                    {
                        return componentInChildren;
                    }
                }
            }
            return null;
        }
//調用了上面的方法
        public T GetComponentInChildren<T>() where T : Component
        {
            return this.GetComponentInChildren(typeof(T)) as T;
        }

        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]

//這個方法，優先從自己身上找到該組件，如果找不到則從父節點出發，將遞歸所有的父節點，如果所有父節點都沒有，則返回空

      public Component GetComponentInParent(Type type)

        {
            if (this.activeInHierarchy)
            {
                Component component = this.GetComponent(type);
                if (component != null)
                {
                    return component;
                }
            }
            Transform parent = this.transform.parent;
            if (parent != null)
            {
                while (parent != null)
                {
                    if (parent.gameObject.activeInHierarchy)
                    {
                        Component component2 = parent.gameObject.GetComponent(type);
                        if (component2 != null)
                        {
                            return component2;
                        }
                    }
                    parent = parent.parent;
                }
            }
            return null;
        }
//同上
        public T GetComponentInParent<T>() where T : Component
        {
            return this.GetComponentInParent(typeof(T)) as T;
        }
//調用了外部方法，因爲沒有開源，只能根據名字來猜測，獲得父節點以及以上節點中的指定組件，includeInactive是否包括非active成員，將這些組件放到result列表裏
        public void GetComponentsInParent<T>(bool includeInactive, List<T> results) where T : Component
        {
            this.GetComponentsForListInternal(typeof(T), typeof(T), true, includeInactive, true, results);
        }

        [CanConvertToFlash]

        public Component[] GetComponents(Type type)

        {

//GetComponentsInternal(Type type, bool isGenericTypeArray, bool recursive, bool includeInactive, bool reverse);

            return this.GetComponentsInternal(type, false, false, true, false);
        }

        public T[] GetComponents<T>() where T : Component
        {
            return (T[])this.GetComponentsInternal(typeof(T), true, false, true, false);
        }

        public void GetComponents(Type type, List<Component> results)
        {
            this.GetComponentsForListInternal(type, typeof(Component), false, true, false, results);
        }

        public void GetComponents<T>(List<T> results) where T : Component
        {
            this.GetComponentsForListInternal(typeof(T), typeof(T), false, true, false, results);
        }

        [ExcludeFromDocs]
        public Component[] GetComponentsInChildren(Type type)
        {
            bool includeInactive = false;
            return this.GetComponentsInChildren(type, includeInactive);
        }

        public Component[] GetComponentsInChildren(Type type, [DefaultValue("false")] bool includeInactive)
        {
            return this.GetComponentsInternal(type, false, true, includeInactive, false);
        }

        public T[] GetComponentsInChildren<T>(bool includeInactive) where T : Component
        {
            return (T[])this.GetComponentsInternal(typeof(T), true, true, includeInactive, false);
        }

        public void GetComponentsInChildren<T>(bool includeInactive, List<T> results) where T : Component
        {
            this.GetComponentsForListInternal(typeof(T), typeof(T), true, includeInactive, false, results);
        }

        public T[] GetComponentsInChildren<T>() where T : Component
        {
            return this.GetComponentsInChildren<T>(false);
        }

        public void GetComponentsInChildren<T>(List<T> results) where T : Component
        {
            this.GetComponentsInChildren<T>(false, results);
        }

        [ExcludeFromDocs]
        public Component[] GetComponentsInParent(Type type)
        {
            bool includeInactive = false;
            return this.GetComponentsInParent(type, includeInactive);
        }

        public Component[] GetComponentsInParent(Type type, [DefaultValue("false")] bool includeInactive)
        {
            return this.GetComponentsInternal(type, false, true, includeInactive, true);
        }

        public T[] GetComponentsInParent<T>(bool includeInactive) where T : Component
        {
            return (T[])this.GetComponentsInternal(typeof(T), true, true, includeInactive, true);
        }

        public T[] GetComponentsInParent<T>() where T : Component
        {
            return this.GetComponentsInParent<T>(false);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        private extern void GetComponentsForListInternal(Type searchType, Type listElementType, bool recursive, bool includeInactive, bool reverse, object resultList);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        private extern Component[] GetComponentsInternal(Type type, bool isGenericTypeArray, bool recursive, bool includeInactive, bool reverse);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void SetActive(bool value);

        [Obsolete("gameObject.SetActiveRecursively() is obsolete. Use GameObject.SetActive(), which is now inherited by children."), WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void SetActiveRecursively(bool state);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern bool CompareTag(string tag);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern GameObject FindGameObjectWithTag(string tag);
//靜態方法，全局查找tag對應的gameobject
        public static GameObject FindWithTag(string tag)
        {
            return GameObject.FindGameObjectWithTag(tag);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern GameObject[] FindGameObjectsWithTag(string tag);

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void SendMessageUpwards(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);

        [ExcludeFromDocs]//觸發該物體以及父物體的methodName方法
        public void SendMessageUpwards(string methodName, object value)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            this.SendMessageUpwards(methodName, value, options);
        }

        [ExcludeFromDocs]//觸發該物體以及父物體的methodName方法
        public void SendMessageUpwards(string methodName)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            object value = null;
            this.SendMessageUpwards(methodName, value, options);
        }

        public void SendMessageUpwards(string methodName, SendMessageOptions options)
        {
            this.SendMessageUpwards(methodName, null, options);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void SendMessage(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);

        [ExcludeFromDocs]
        public void SendMessage(string methodName, object value)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            this.SendMessage(methodName, value, options);
        }

        [ExcludeFromDocs]
        public void SendMessage(string methodName)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            object value = null;
            this.SendMessage(methodName, value, options);
        }

        public void SendMessage(string methodName, SendMessageOptions options)
        {
            this.SendMessage(methodName, null, options);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void BroadcastMessage(string methodName, [DefaultValue("null")] object parameter, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);

        [ExcludeFromDocs]//跟SendMessageUpwards相反，是觸發該物體以及子物體methodName方法
        public void BroadcastMessage(string methodName, object parameter)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            this.BroadcastMessage(methodName, parameter, options);
        }

        [ExcludeFromDocs]
        public void BroadcastMessage(string methodName)
        {
            SendMessageOptions options = SendMessageOptions.RequireReceiver;
            object parameter = null;
            this.BroadcastMessage(methodName, parameter, options);
        }

        public void BroadcastMessage(string methodName, SendMessageOptions options)
        {
            this.BroadcastMessage(methodName, null, options);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern Component AddComponent(string className);
//添加組件
        [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
        public Component AddComponent(Type componentType)
        {
            return this.Internal_AddComponentWithType(componentType);
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        private extern Component Internal_AddComponentWithType(Type componentType);

        public T AddComponent<T>() where T : Component
        {
            return this.AddComponent(typeof(T)) as T;
        }

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        private static extern void Internal_CreateGameObject([Writable] GameObject mono, string name);

        [Obsolete("gameObject.PlayAnimation is not supported anymore. Use animation.Play"), WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void PlayAnimation(AnimationClip animation);

        [Obsolete("gameObject.StopAnimation is not supported anymore. Use animation.Stop"), WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public extern void StopAnimation();

        [WrapperlessIcall]
        [MethodImpl(MethodImplOptions.InternalCall)]
        public static extern GameObject Find(string name);
    }
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Unity3d softInput decomplied java code

package com.unity3d.player; import android.app.Dialog; import android.content.Context; import android.content.res.Reso

延澈左 2020-07-08 09:56:18

Fedora安裝Unity Editor詳細步驟

本文固定鏈接，轉載請評論點贊，麼麼噠 一、起因： 最近一直在用Unity開發Linux版本的應用或者說遊戲。Linux是Fedora版本的。Unity官方很早就開始說要專門針對Linux做編輯器了。於是就萌生了要在Fedora上裝

CattleDrinkRedWine 2020-07-08 09:14:00

Unity4.5動畫控制狀態切換監聽腳本

在Mecanim動畫由狀態機控制的情況下，監聽動畫狀態變化的代碼。可以根據需要，刪減其中的方法。 using UnityEngine; using System.Collections; using System.Collections.

延澈左 2020-07-08 09:12:32

[Unity3D]灰度圖像Shader

昨天是清明節，也是深切哀悼新冠肺炎疫情犧牲烈士和逝世同胞的公祭日，致敬英雄，逝者安息！希望疫情早日過去！！！ 看到許多網頁，以及一些朋友的微信頭像都變成了黑白色的，於是在想，複雜嗎？是如何實現的？ 當輸出的RGB值相同的時候，就變

延澈左 2020-07-08 09:12:32

[Unity3D]簡單的事件管理器

一個簡單的事件管理器 任意一個枚舉就可以定義事件類型。 using System.Collections.Generic; using System; public enum GameEvent { StartGame,

延澈左 2020-07-08 09:12:32

[Unity3d]保存相機當前渲染內容或者RenderTexture到本地小工具

項目中，遇到需要將相機當前渲染的內容或者是RenderTexture保存到本地的需求，查看渲染結果是否正確。因此，寫了一個簡單的小工具，按F4就可以保存到Assets上一級目錄。 先直接貼代碼，有時間再詳細解釋 使用方式是直接

延澈左 2020-07-08 09:12:32

Unity Shader CG 屬性類型和語義總結

UnityShader中屬性的類型： _Color("Color",Color)=(1,1,1,1) _Vector("Vector",Vector)=(1,2,3,4) _Int("Int",Int)=34234 _Float("Flo

Tian_kaifu 2020-07-08 03:52:20

Unity中的貝塞爾曲線思路及實現（轉）

轉https://blog.csdn.net/GhostOrange/article/details/53613372   說到貝塞爾曲線，大家肯定不會陌生，很多插件都有它的身影，但是想要一窺它的細節總覺得有點困難，因爲一到網上查詢都是什

晴雨阳-_-!!! 2020-07-08 03:31:30

Unity Quaternion用法小結

AngleAxis方法和SetAngleAxis方法 官方例子。 Before： After： Quaternion的靜態方法，是用來構造一個Rotation的。 分析：軸，如果設置爲Vector.Down,那麼單頭會向左側旋轉。

幼发拉底河上的无头女尸 2020-07-08 01:22:35

【unity】使用Android手機真機調試unity項目

一、準備 1.手機和USB數據線 2.android SDK（請自己百度下載） 二、連接 用數據線將手機和電腦連接，手機端在開發者選項裏打開USB調試 三、設置項目 在unity點擊File–Build settings，先選擇A

冰冷的希望 2020-07-08 01:22:12

【unity】解決3d max導出的fbx在unity貼圖丟失的問題

這兩天一直在爲貼圖問題困擾，研究了許久，終於找到了解決方法，分享給大家，希望能幫到大家可以減少入坑時間 1.貼圖文件夾 我們在給3d max貼圖的時候，一定要把圖片資源都放在同一個文件夾裏，不要讓貼圖文件散落在各個不同路徑下。而且

冰冷的希望 2020-07-08 01:22:12

【unity】標準資源包裏的第一人稱角色控制器FPSController在手機端旋轉視圖

在unity中導入標準資源包，可以拖拽一個FPSController到場景中漫遊，十分方便，但是調整方向是靠鼠標滑動的，到了手機端沒有鼠標，對於新手的我不知道怎麼處理，最後是通過在屏幕上放置四個按鈕控制方向 1.修改MouseLo

冰冷的希望 2020-07-08 01:22:12

【unity】加載場景進度條

在遊戲中切換場景是很有用處的，尤其是大場景，加載時間很長，我們可以顯示一個進度條異步加載，提高用戶體驗 1.新建場景 新建兩個場景，分別是“LoadScene”和“NewScene”，其中LoadScene用來顯示進度條 新建好之

冰冷的希望 2020-07-08 01:22:12

談一下unity3d的光照

其實學習shader的話，搞unity開發，就是《unity 3d shaderLab開發實戰詳解》。unity在opengl的基礎上又封裝了了一個表面着色器，本id其實並不怎麼喜歡寫表面着色器，因爲以前學習opengl的時候都沒有聽說過

梁工123 2020-07-08 01:20:12

模擬實時光照下的陰影

在3d遊戲中，實時光照是一個特別大的消耗，不僅是因爲對於顏色的計算，還有消耗在繪製實時陰影，對於手機遊戲無疑是一個很大的開銷，但是吧，沒有實時光照的影子，就顯得很呆板，這裏就說明一下3d遊戲中繪製陰影的原理。 太陽光可以看做是一個平行光

梁工123 2020-07-08 01:20:12