DisplayObject.cs

using System;
using System.Text;
using UnityEngine;
using FairyGUI.Utils;
using System.Collections.Generic;

namespace FairyGUI
{
    /// <summary>
    /// 
    /// </summary>
    public class DisplayObject : EventDispatcher, IBatchable
    {
        /// <summary>
        /// 
        /// </summary>
        public string name;

        /// <summary>
        /// 
        /// </summary>
        public Container parent { get; private set; }

        /// <summary>
        /// 
        /// </summary>
        public GameObject gameObject { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        public Transform cachedTransform { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        public NGraphics graphics { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        public NGraphics paintingGraphics { get; protected set; }

        /// <summary>
        /// 
        /// </summary>
        public event Action onPaint;

        /// <summary>
        /// 
        /// </summary>
        public GObject gOwner;

        /// <summary>
        /// 
        /// </summary>
        public uint id;

        bool _visible;
        bool _touchable;
        Vector2 _pivot;
        Vector3 _pivotOffset;
        Vector3 _rotation; //由于万向锁，单独旋转一个轴是会影响到其他轴的，所以这里需要单独保存
        Vector2 _skew;
        int _renderingOrder;
        float _alpha;
        bool _grayed;
        BlendMode _blendMode;
        IFilter _filter;
        Transform _home;
        string _cursor;
        bool _perspective;
        int _focalLength;
        Vector3 _pixelPerfectAdjustment;
        int _checkPixelPerfect;

        EventListener _onClick;
        EventListener _onRightClick;
        EventListener _onTouchBegin;
        EventListener _onTouchMove;
        EventListener _onTouchEnd;
        EventListener _onRollOver;
        EventListener _onRollOut;
        EventListener _onMouseWheel;
        EventListener _onAddedToStage;
        EventListener _onRemovedFromStage;
        EventListener _onKeyDown;
        EventListener _onClickLink;
        EventListener _onFocusIn;
        EventListener _onFocusOut;

        protected internal int _paintingMode; //1-滤镜，2-blendMode，4-transformMatrix, 8-cacheAsBitmap
        protected internal PaintingInfo _paintingInfo;
        protected Rect _contentRect;
        protected NGraphics.VertexMatrix _vertexMatrix;
        protected internal Flags _flags;

        internal static uint _gInstanceCounter;

        internal static HideFlags hideFlags = HideFlags.None;

        public DisplayObject()
        {
            id = _gInstanceCounter++;

            _alpha = 1;
            _visible = true;
            _touchable = true;
            _blendMode = BlendMode.Normal;
            _focalLength = 2000;
            _flags |= Flags.OutlineChanged;
            if (UIConfig.makePixelPerfect)
                _flags |= Flags.PixelPerfect;
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onClick
        {
            get { return _onClick ?? (_onClick = new EventListener(this, "onClick")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onRightClick
        {
            get { return _onRightClick ?? (_onRightClick = new EventListener(this, "onRightClick")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onTouchBegin
        {
            get { return _onTouchBegin ?? (_onTouchBegin = new EventListener(this, "onTouchBegin")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onTouchMove
        {
            get { return _onTouchMove ?? (_onTouchMove = new EventListener(this, "onTouchMove")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onTouchEnd
        {
            get { return _onTouchEnd ?? (_onTouchEnd = new EventListener(this, "onTouchEnd")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onRollOver
        {
            get { return _onRollOver ?? (_onRollOver = new EventListener(this, "onRollOver")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onRollOut
        {
            get { return _onRollOut ?? (_onRollOut = new EventListener(this, "onRollOut")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onMouseWheel
        {
            get { return _onMouseWheel ?? (_onMouseWheel = new EventListener(this, "onMouseWheel")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onAddedToStage
        {
            get { return _onAddedToStage ?? (_onAddedToStage = new EventListener(this, "onAddedToStage")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onRemovedFromStage
        {
            get { return _onRemovedFromStage ?? (_onRemovedFromStage = new EventListener(this, "onRemovedFromStage")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onKeyDown
        {
            get { return _onKeyDown ?? (_onKeyDown = new EventListener(this, "onKeyDown")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onClickLink
        {
            get { return _onClickLink ?? (_onClickLink = new EventListener(this, "onClickLink")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onFocusIn
        {
            get { return _onFocusIn ?? (_onFocusIn = new EventListener(this, "onFocusIn")); }
        }

        /// <summary>
        /// 
        /// </summary>
        public EventListener onFocusOut
        {
            get { return _onFocusOut ?? (_onFocusOut = new EventListener(this, "onFocusOut")); }

        }

        /// <summary>
        ///
        /// </summary>
        public EventListener onEnable
        {
            get
            {
                CreateEventComponent();
                return _onEnable ?? (_onEnable = new EventListener(this, "onEnable"));
            }
        }

        /// <summary>
        ///
        /// </summary>
        public EventListener onDisable
        {
            get
            {
                CreateEventComponent();
                return _onDisable ?? (_onDisable = new EventListener(this, "onDisable"));
            }
        }
        EventListener _onEnable;
        EventListener _onDisable;


        class DisplayObjectEvents : MonoBehaviour
        {
            public Action onEnable;
            public Action onDisable;

            void OnDisable()
            {
                onDisable?.Invoke();
            }

            void OnEnable()
            {
                onEnable?.Invoke();
            }
        }
        DisplayObjectEvents _events;
        protected void CreateEventComponent()
        {
            if (_events == null)
            {
                _events = gameObject.AddComponent<DisplayObjectEvents>();
                _events.onEnable = () => _onEnable?.Call();
                _events.onDisable = () => _onDisable?.Call();
            }
        }

        protected void CreateGameObject(string gameObjectName)
        {
            gameObject = new GameObject(gameObjectName);
            cachedTransform = gameObject.transform;
            if (Application.isPlaying)
            {
                UnityEngine.Object.DontDestroyOnLoad(gameObject);

                DisplayObjectInfo info = gameObject.AddComponent<DisplayObjectInfo>();
                info.displayObject = this;
            }
            gameObject.hideFlags = DisplayObject.hideFlags;
            gameObject.SetActive(false);
        }

        protected void SetGameObject(GameObject gameObject)
        {
            this.gameObject = gameObject;
            this.cachedTransform = gameObject.transform;
            _rotation = cachedTransform.localEulerAngles;

            _flags |= Flags.UserGameObject;
        }

        protected void DestroyGameObject()
        {
            if ((_flags & Flags.UserGameObject) == 0 && gameObject != null)
            {
                if (Application.isPlaying)
                    GameObject.Destroy(gameObject);
                else
                    GameObject.DestroyImmediate(gameObject);
                gameObject = null;
                cachedTransform = null;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float alpha
        {
            get { return _alpha; }
            set { _alpha = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool grayed
        {
            get { return _grayed; }
            set { _grayed = value; }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool visible
        {
            get { return _visible; }
            set
            {
                if (_visible != value)
                {
                    _visible = value;
                    _flags |= Flags.OutlineChanged;
                    if (parent != null && _visible)
                    {
                        gameObject.SetActive(true);
                        InvalidateBatchingState();
                        if (this is Container)
                            ((Container)this).InvalidateBatchingState(true);
                    }
                    else
                        gameObject.SetActive(false);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float x
        {
            get { return cachedTransform.localPosition.x; }
            set
            {
                SetPosition(value, -cachedTransform.localPosition.y, cachedTransform.localPosition.z);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float y
        {
            get { return -cachedTransform.localPosition.y; }
            set
            {
                SetPosition(cachedTransform.localPosition.x, value, cachedTransform.localPosition.z);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float z
        {
            get { return cachedTransform.localPosition.z; }
            set
            {
                SetPosition(cachedTransform.localPosition.x, -cachedTransform.localPosition.y, value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 xy
        {
            get { return new Vector2(this.x, this.y); }
            set { SetPosition(value.x, value.y, cachedTransform.localPosition.z); }
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector3 position
        {
            get { return new Vector3(this.x, this.y, this.z); }
            set { SetPosition(value.x, value.y, value.z); }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="xv"></param>
        /// <param name="yv"></param>
        public void SetXY(float xv, float yv)
        {
            SetPosition(xv, yv, cachedTransform.localPosition.z);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="xv"></param>
        /// <param name="yv"></param>
        /// <param name="zv"></param>
        public void SetPosition(float xv, float yv, float zv)
        {
            Vector3 v = new Vector3();
            v.x = xv;
            v.y = -yv;
            v.z = zv;
            if (v != cachedTransform.localPosition)
            {
                cachedTransform.localPosition = v;
                _flags |= Flags.OutlineChanged;
                if ((_flags & Flags.PixelPerfect) != 0)
                {
                    //总在下一帧再完成PixelPerfect，这样当物体在连续运动时，不会因为PixelPerfect而发生抖动。
                    _checkPixelPerfect = Time.frameCount;
                    _pixelPerfectAdjustment = Vector3.zero;
                }
            }
        }

        /// <summary>
        /// If the object position is align by pixel
        /// </summary>
        public bool pixelPerfect
        {
            get { return (_flags & Flags.PixelPerfect) != 0; }
            set
            {
                if (value)
                    _flags |= Flags.PixelPerfect;
                else
                    _flags &= ~Flags.PixelPerfect;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float width
        {
            get
            {
                EnsureSizeCorrect();
                return _contentRect.width;
            }
            set
            {
                if (!Mathf.Approximately(value, _contentRect.width))
                {
                    _contentRect.width = value;
                    _flags |= Flags.WidthChanged;
                    _flags &= ~Flags.HeightChanged;
                    OnSizeChanged();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float height
        {
            get
            {
                EnsureSizeCorrect();
                return _contentRect.height;
            }
            set
            {
                if (!Mathf.Approximately(value, _contentRect.height))
                {
                    _contentRect.height = value;
                    _flags &= ~Flags.WidthChanged;
                    _flags |= Flags.HeightChanged;
                    OnSizeChanged();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 size
        {
            get
            {
                EnsureSizeCorrect();
                return _contentRect.size;
            }
            set
            {
                SetSize(value.x, value.y);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="wv"></param>
        /// <param name="hv"></param>
        public void SetSize(float wv, float hv)
        {
            if (!Mathf.Approximately(wv, _contentRect.width))
                _flags |= Flags.WidthChanged;
            else
                _flags &= ~Flags.WidthChanged;
            if (!Mathf.Approximately(hv, _contentRect.height))
                _flags |= Flags.HeightChanged;
            else
                _flags &= ~Flags.HeightChanged;

            if ((_flags & Flags.WidthChanged) != 0 || (_flags & Flags.HeightChanged) != 0)
            {
                _contentRect.width = wv;
                _contentRect.height = hv;
                OnSizeChanged();
            }
        }

        virtual public void EnsureSizeCorrect()
        {
        }

        virtual protected void OnSizeChanged()
        {
            ApplyPivot();

            if (_paintingInfo != null)
                _paintingInfo.flag = 1;
            if (graphics != null)
                graphics.contentRect = _contentRect;
            _flags |= Flags.OutlineChanged;
        }

        /// <summary>
        /// 
        /// </summary>
        public float scaleX
        {
            get { return cachedTransform.localScale.x; }
            set
            {
                Vector3 v = cachedTransform.localScale;
                v.x = v.z = ValidateScale(value);
                cachedTransform.localScale = v;
                _flags |= Flags.OutlineChanged;
                ApplyPivot();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float scaleY
        {
            get { return cachedTransform.localScale.y; }
            set
            {
                Vector3 v = cachedTransform.localScale;
                v.y = ValidateScale(value);
                cachedTransform.localScale = v;
                _flags |= Flags.OutlineChanged;
                ApplyPivot();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="xv"></param>
        /// <param name="yv"></param>
        public void SetScale(float xv, float yv)
        {
            Vector3 v = new Vector3();
            v.x = v.z = ValidateScale(xv);
            v.y = ValidateScale(yv);
            cachedTransform.localScale = v;
            _flags |= Flags.OutlineChanged;
            ApplyPivot();
        }

        /// <summary>
        /// 在scale过小情况（极端情况=0），当使用Transform的坐标变换时，变换到世界，再从世界变换到本地，会由于精度问题造成结果错误。
        /// 这种错误会导致Batching错误，因为Batching会使用缓存的outline。
        /// 这里限制一下scale的最小值作为当前解决方案。
        /// 这个方案并不完美，因为限制了本地scale值并不能保证对世界scale不会过小。
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private float ValidateScale(float value)
        {
            if (value >= 0 && value < 0.001f)
                value = 0.001f;
            else if (value < 0 && value > -0.001f)
                value = -0.001f;
            return value;
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 scale
        {
            get { return cachedTransform.localScale; }
            set
            {
                SetScale(value.x, value.y);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float rotation
        {
            get
            {
                //和Unity默认的旋转方向相反
                return -_rotation.z;
            }
            set
            {
                _rotation.z = -value;
                _flags |= Flags.OutlineChanged;
                if (_perspective)
                    UpdateTransformMatrix();
                else
                {
                    cachedTransform.localEulerAngles = _rotation;
                    ApplyPivot();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float rotationX
        {
            get
            {
                return _rotation.x;
            }
            set
            {
                _rotation.x = value;
                _flags |= Flags.OutlineChanged;
                if (_perspective)
                    UpdateTransformMatrix();
                else
                {
                    cachedTransform.localEulerAngles = _rotation;
                    ApplyPivot();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public float rotationY
        {
            get
            {
                return _rotation.y;
            }
            set
            {
                _rotation.y = value;
                _flags |= Flags.OutlineChanged;
                if (_perspective)
                    UpdateTransformMatrix();
                else
                {
                    cachedTransform.localEulerAngles = _rotation;
                    ApplyPivot();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 skew
        {
            get { return _skew; }
            set
            {
                _skew = value;
                _flags |= Flags.OutlineChanged;

                if (!Application.isPlaying) //编辑期间不支持！！
                    return;

                UpdateTransformMatrix();
            }
        }

        /// <summary>
        /// 当对象处于ScreenSpace，也就是使用正交相机渲染时，对象虽然可以绕X轴或者Y轴旋转，但没有透视效果。设置perspective，可以模拟出透视效果。
        /// </summary>
        public bool perspective
        {
            get
            {
                return _perspective;
            }
            set
            {
                if (_perspective != value)
                {
                    _perspective = value;
                    if (_perspective)//屏蔽Unity自身的旋转变换
                        cachedTransform.localEulerAngles = Vector3.zero;
                    else
                        cachedTransform.localEulerAngles = _rotation;

                    ApplyPivot();
                    UpdateTransformMatrix();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int focalLength
        {
            get { return _focalLength; }
            set
            {
                if (value <= 0)
                    value = 1;

                _focalLength = value;
                if (_vertexMatrix != null)
                    UpdateTransformMatrix();
            }
        }

        void UpdateTransformMatrix()
        {
            Matrix4x4 matrix = Matrix4x4.identity;
            if (_skew.x != 0 || _skew.y != 0)
                ToolSet.SkewMatrix(ref matrix, _skew.x, _skew.y);
            if (_perspective)
                matrix *= Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(_rotation), Vector3.one);
            if (matrix.isIdentity)
                _vertexMatrix = null;
            else if (_vertexMatrix == null)
                _vertexMatrix = new NGraphics.VertexMatrix();

            //组件的transformMatrix是通过paintingMode实现的，因为全部通过矩阵变换的话，和unity自身的变换混杂在一起，无力理清。
            if (_vertexMatrix != null)
            {
                _vertexMatrix.matrix = matrix;
                _vertexMatrix.cameraPos = new Vector3(_pivot.x * _contentRect.width, -_pivot.y * _contentRect.height, _focalLength);

                if (graphics == null)
                    EnterPaintingMode(4, null);
            }
            else
            {
                if (graphics == null)
                    LeavePaintingMode(4);
            }

            if (_paintingMode > 0)
            {
                paintingGraphics.vertexMatrix = _vertexMatrix;
                _paintingInfo.flag = 1;
            }
            else if (graphics != null)
                graphics.vertexMatrix = _vertexMatrix;

            _flags |= Flags.OutlineChanged;
        }

        /// <summary>
        /// 
        /// </summary>
        public Vector2 pivot
        {
            get { return _pivot; }
            set
            {
                Vector3 deltaPivot = new Vector2((value.x - _pivot.x) * _contentRect.width, (_pivot.y - value.y) * _contentRect.height);
                Vector3 oldOffset = _pivotOffset;

                _pivot = value;
                UpdatePivotOffset();
                Vector3 v = cachedTransform.localPosition;
                v += oldOffset - _pivotOffset + deltaPivot;
                cachedTransform.localPosition = v;
                _flags |= Flags.OutlineChanged;
            }
        }

        void UpdatePivotOffset()
        {
            float px = _pivot.x * _contentRect.width;
            float py = _pivot.y * _contentRect.height;

            //注意这里不用处理skew，因为在顶点变换里有对pivot的处理
            Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, cachedTransform.localRotation, cachedTransform.localScale);
            _pivotOffset = matrix.MultiplyPoint(new Vector3(px, -py, 0));

            if (_vertexMatrix != null)
                _vertexMatrix.cameraPos = new Vector3(_pivot.x * _contentRect.width, -_pivot.y * _contentRect.height, _focalLength);
        }

        void ApplyPivot()
        {
            if (_pivot.x != 0 || _pivot.y != 0)
            {
                Vector3 oldOffset = _pivotOffset;

                UpdatePivotOffset();
                Vector3 v = cachedTransform.localPosition;

                if ((_flags & Flags.PixelPerfect) != 0)
                {
                    v -= _pixelPerfectAdjustment;
                    _checkPixelPerfect = Time.frameCount;
                    _pixelPerfectAdjustment = Vector3.zero;
                }

                v += oldOffset - _pivotOffset;
                cachedTransform.localPosition = v;
                _flags |= Flags.OutlineChanged;
            }
        }

        /// <summary>
        /// This is the pivot position
        /// </summary>
        public Vector3 location
        {
            get
            {
                Vector3 pos = this.position;
                pos.x += _pivotOffset.x;
                pos.y -= _pivotOffset.y;
                pos.z += _pivotOffset.z;
                return pos;
            }

            set
            {
                this.SetPosition(value.x - _pivotOffset.x, value.y + _pivotOffset.y, value.z - _pivotOffset.z);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Material material
        {
            get
            {
                if (graphics != null)
                    return graphics.material;
                else
                    return null;
            }
            set
            {
                if (graphics != null)
                    graphics.material = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public string shader
        {
            get
            {
                if (graphics != null)
                    return graphics.shader;
                else
                    return null;
            }
            set
            {
                if (graphics != null)
                    graphics.shader = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int renderingOrder
        {
            get
            {
                return _renderingOrder;
            }
        }

        virtual public void SetRenderingOrder(UpdateContext context, bool inBatch)
        {
            if ((_flags & Flags.GameObjectDisposed) != 0)
            {
                DisplayDisposedWarning();
                return;
            }

            _renderingOrder = context.renderingOrder + 1;
            if (graphics != null)
                graphics.SetRenderingOrder(context, inBatch);
            else
                context.renderingOrder++;

            if (_paintingMode > 0)
                paintingGraphics.renderingOrder = _renderingOrder;
        }

        /// <summary>
        /// 
        /// </summary>
        public int layer
        {
            get
            {
                if (_paintingMode > 0)
                    return paintingGraphics.gameObject.layer;
                else
                    return gameObject.layer;
            }
            set
            {
                SetLayer(value, false);
            }
        }

        /// <summary>
        /// If the object can be focused?
        /// </summary>
        public bool focusable
        {
            get { return (_flags & Flags.NotFocusable) == 0; }
            set
            {
                if (value)
                    _flags &= ~Flags.NotFocusable;
                else
                    _flags |= Flags.NotFocusable;
            }
        }

        /// <summary>
        /// If the object can be navigated by TAB?
        /// </summary>
        public bool tabStop
        {
            get { return (_flags & Flags.TabStop) != 0; }
            set
            {
                if (value)
                    _flags |= Flags.TabStop;
                else
                    _flags &= ~Flags.TabStop;
            }
        }

        /// <summary>
        /// If the object focused?
        /// </summary>
        public bool focused
        {
            get
            {
                return Stage.inst.focus == this || (this is Container) && ((Container)this).IsAncestorOf(Stage.inst.focus);
            }
        }

        internal bool _AcceptTab()
        {
            if (_touchable && _visible
                && ((_flags & Flags.TabStop) != 0 || (_flags & Flags.TabStopChildren) != 0)
                && (_flags & Flags.NotFocusable) == 0)
            {
                Stage.inst.SetFocus(this, true);
                return true;
            }
            else
                return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <value></value>
        public string cursor
        {
            get { return _cursor; }
            set
            {
                _cursor = value;
                if (Application.isPlaying
                    && (this == Stage.inst.touchTarget || (this is Container) && ((Container)this).IsAncestorOf(Stage.inst.touchTarget)))
                {
                    Stage.inst._ChangeCursor(_cursor);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool isDisposed
        {
            get { return (_flags & Flags.Disposed) != 0 || gameObject == null; }
        }

        internal void InternalSetParent(Container value)
        {
            if (parent != value)
            {
                if (value == null && (parent._flags & Flags.Disposed) != 0)
                    parent = value;
                else
                {
                    parent = value;
                    UpdateHierarchy();
                }
                _flags |= Flags.OutlineChanged;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Container topmost
        {
            get
            {
                DisplayObject currentObject = this;
                while (currentObject.parent != null)
                    currentObject = currentObject.parent;
                return currentObject as Container;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Stage stage
        {
            get
            {
                return topmost as Stage;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public Container worldSpaceContainer
        {
            get
            {
                Container wsc = null;
                DisplayObject currentObject = this;
                while (currentObject.parent != null)
                {
                    if ((currentObject is Container) && ((Container)currentObject).renderMode == RenderMode.WorldSpace)
                    {
                        wsc = (Container)currentObject;
                        break;
                    }
                    currentObject = currentObject.parent;
                }

                return wsc;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool touchable
        {
            get { return _touchable; }
            set
            {
                if (_touchable != value)
                {
                    _touchable = value;
                    if (this is Container)
                    {
                        ColliderHitTest hitArea = ((Container)this).hitArea as ColliderHitTest;
                        if (hitArea != null)
                            hitArea.collider.enabled = value;
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <value></value>
        public bool touchDisabled
        {
            get { return (_flags & Flags.TouchDisabled) != 0; }
        }

        /// <summary>
        /// 进入绘画模式，整个对象将画到一张RenderTexture上，然后这种贴图将代替原有的显示内容。
        /// 可以在onPaint回调里对这张纹理进行进一步操作，实现特殊效果。
        /// </summary>
        public void EnterPaintingMode()
        {
            EnterPaintingMode(16384, null, 1);
        }

        /// <summary>
        /// 进入绘画模式，整个对象将画到一张RenderTexture上，然后这种贴图将代替原有的显示内容。
        /// 可以在onPaint回调里对这张纹理进行进一步操作，实现特殊效果。
        /// 可能有多个地方要求进入绘画模式，这里用requestorId加以区别，取值是1、2、4、8、16以此类推。1024内内部保留。用户自定义的id从1024开始。
        /// </summary>
        /// <param name="requestId">请求者id</param>
        /// <param name="extend">纹理四周的留空。如果特殊处理后的内容大于原内容，那么这里的设置可以使纹理扩大。</param>
        public void EnterPaintingMode(int requestorId, Margin? extend)
        {
            EnterPaintingMode(requestorId, extend, 1);
        }

        /// <summary>
        /// 进入绘画模式，整个对象将画到一张RenderTexture上，然后这种贴图将代替原有的显示内容。
        /// 可以在onPaint回调里对这张纹理进行进一步操作，实现特殊效果。
        /// 可能有多个地方要求进入绘画模式，这里用requestorId加以区别，取值是1、2、4、8、16以此类推。1024内内部保留。用户自定义的id从1024开始。
        /// </summary>
        /// <param name="requestorId">请求者id</param>
        /// <param name="extend">扩展纹理。如果特殊处理后的内容大于原内容，那么这里的设置可以使纹理扩大。</param>
        /// <param name="scale">附加一个缩放系数</param>
        public void EnterPaintingMode(int requestorId, Margin? extend, float scale)
        {
            bool first = _paintingMode == 0;
            _paintingMode |= requestorId;
            if (first)
            {
                if (_paintingInfo == null)
                {
                    _paintingInfo = new PaintingInfo()
                    {
                        captureDelegate = Capture,
                        scale = 1
                    };
                }

                if (paintingGraphics == null)
                {
                    if (graphics == null)
                        paintingGraphics = new NGraphics(this.gameObject);
                    else
                    {
                        GameObject go = new GameObject(this.gameObject.name + " (Painter)");
                        go.layer = this.gameObject.layer;
                        go.transform.SetParent(cachedTransform, false);
                        go.hideFlags = DisplayObject.hideFlags;
                        paintingGraphics = new NGraphics(go);
                    }
                }
                else
                    paintingGraphics.enabled = true;
                paintingGraphics.vertexMatrix = null;

                if (this is Container)
                {
                    ((Container)this).SetChildrenLayer(CaptureCamera.hiddenLayer);
                    ((Container)this).UpdateBatchingFlags();
                }
                else
                    this.InvalidateBatchingState();

                if (graphics != null)
                    _SetLayerDirect(CaptureCamera.hiddenLayer);
            }
            if (extend != null)
                _paintingInfo.extend = (Margin)extend;
            _paintingInfo.scale = scale;
            _paintingInfo.flag = 1;
        }

        /// <summary>
        /// 离开绘画模式
        /// </summary>
        /// <param name="requestId"></param>
        public void LeavePaintingMode(int requestorId)
        {
            if (_paintingMode == 0 || (_flags & Flags.Disposed) != 0)
                return;

            _paintingMode ^= requestorId;
            if (_paintingMode == 0)
            {
                paintingGraphics.enabled = false;

                if (this is Container)
                {
                    ((Container)this).SetChildrenLayer(this.layer);
                    ((Container)this).UpdateBatchingFlags();
                }
                else
                    this.InvalidateBatchingState();

                if (graphics != null)
                    _SetLayerDirect(paintingGraphics.gameObject.layer);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool paintingMode
        {
            get { return _paintingMode > 0; }
        }

        /// <summary>
        /// 将整个显示对象（如果是容器，则容器包含的整个显示列表）静态化，所有内容被缓冲到一张纹理上。
        /// DC将保持为1。CPU消耗将降到最低。但对象的任何变化不会更新。
        /// 当cacheAsBitmap已经为true时，再次调用cacheAsBitmap=true将会刷新对象一次。
        /// </summary>
        public bool cacheAsBitmap
        {
            get { return (_flags & Flags.CacheAsBitmap) != 0; }
            set
            {
                if (value)
                {
                    _flags |= Flags.CacheAsBitmap;
                    EnterPaintingMode(8, null, UIContentScaler.scaleFactor);
                }
                else
                {
                    _flags &= ~Flags.CacheAsBitmap;
                    LeavePaintingMode(8);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="extend"></param>
        /// <param name="scale"></param>
        /// <returns></returns>
        public Texture2D GetScreenShot(Margin? extend, float scale)
        {
            EnterPaintingMode(8, null, scale);
            UpdatePainting();
            Capture();

            Texture2D output;
            if (paintingGraphics.texture == null)
                output = new Texture2D(1, 1, TextureFormat.RGBA32, false, true);
            else
            {
                RenderTexture rt = (RenderTexture)paintingGraphics.texture.nativeTexture;
                output = new Texture2D(rt.width, rt.height, TextureFormat.RGBA32, false, true);
                RenderTexture old = RenderTexture.active;
                RenderTexture.active = rt;
                output.ReadPixels(new Rect(0, 0, rt.width, rt.height), 0, 0);
                output.Apply();
                RenderTexture.active = old;
            }

            LeavePaintingMode(8);

            return output;
        }

        /// <summary>
        /// 
        /// </summary>
        public IFilter filter
        {
            get
            {
                return _filter;
            }

            set
            {
                if (!Application.isPlaying) //编辑期间不支持！！
                    return;

                if (value == _filter)
                    return;

                if (_filter != null)
                    _filter.Dispose();

                if (value != null && value.target != null)
                    value.target.filter = null;

                _filter = value;
                if (_filter != null)
                    _filter.target = this;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public BlendMode blendMode
        {
            get { return _blendMode; }
            set
            {
                _blendMode = value;
                InvalidateBatchingState();

                if (graphics == null)
                {
                    if (_blendMode != BlendMode.Normal)
                    {
                        if (!Application.isPlaying) //Not supported in edit mode！
                            return;

                        EnterPaintingMode(2, null);
                        paintingGraphics.blendMode = _blendMode;
                    }
                    else
                        LeavePaintingMode(2);
                }
                else
                    graphics.blendMode = _blendMode;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="targetSpace"></param>
        /// <returns></returns>
        virtual public Rect GetBounds(DisplayObject targetSpace)
        {
            EnsureSizeCorrect();

            if (targetSpace == this) // optimization
            {
                return _contentRect;
            }
            else if (targetSpace == parent && _rotation.z == 0)
            {
                return new Rect(cachedTransform.localPosition.x, -cachedTransform.localPosition.y,
                    _contentRect.width * cachedTransform.localScale.x, _contentRect.height * cachedTransform.localScale.y);
            }
            else
                return TransformRect(_contentRect, targetSpace);
        }

        internal DisplayObject InternalHitTest()
        {
            if (_visible && (!HitTestContext.forTouch || _touchable))
                return HitTest();
            else
                return null;
        }

        internal DisplayObject InternalHitTestMask()
        {
            if (_visible)
                return HitTest();
            else
                return null;
        }

        virtual protected DisplayObject HitTest()
        {
            Rect rect = GetBounds(this);
            if (rect.width == 0 || rect.height == 0)
                return null;

            Vector2 localPoint = WorldToLocal(HitTestContext.worldPoint, HitTestContext.direction);
            if (rect.Contains(localPoint))
                return this;
            else
                return null;
        }

        /// <summary>
        /// 将舞台坐标转换为本地坐标
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public Vector2 GlobalToLocal(Vector2 point)
        {
            Container wsc = this.worldSpaceContainer;

            if (wsc != null)//I am in a world space
            {
                Camera cam = wsc.GetRenderCamera();
                Vector3 worldPoint;
                Vector3 direction;
                Vector3 screenPoint = new Vector3();
                screenPoint.x = point.x;
                screenPoint.y = Screen.height - point.y;

                if (wsc.hitArea is MeshColliderHitTest)
                {
                    Ray ray = cam.ScreenPointToRay(screenPoint);
                    RaycastHit hit;
                    if (((MeshColliderHitTest)wsc.hitArea).collider.Raycast(ray, out hit, 100))
                    {
                        point = new Vector2(hit.textureCoord.x * _contentRect.width, (1 - hit.textureCoord.y) * _contentRect.height);
                        worldPoint = Stage.inst.cachedTransform.TransformPoint(point.x, -point.y, 0);
                        direction = Vector3.back;
                    }
                    else //当射线没有击中模型时，无法确定本地坐标
                        return new Vector2(float.NaN, float.NaN);
                }
                else
                {
                    screenPoint.z = cam.WorldToScreenPoint(this.cachedTransform.position).z;
                    worldPoint = cam.ScreenToWorldPoint(screenPoint);
                    Ray ray = cam.ScreenPointToRay(screenPoint);
                    direction = Vector3.zero - ray.direction;
                }

                return this.WorldToLocal(worldPoint, direction);
            }
            else //I am in stage space
            {
                Vector3 worldPoint = Stage.inst.cachedTransform.TransformPoint(point.x, -point.y, 0);
                return this.WorldToLocal(worldPoint, Vector3.back);
            }
        }

        /// <summary>
        /// 将本地坐标转换为舞台坐标
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public Vector2 LocalToGlobal(Vector2 point)
        {
            Container wsc = this.worldSpaceContainer;

            Vector3 worldPoint = this.cachedTransform.TransformPoint(point.x, -point.y, 0);
            if (wsc != null)
            {
                if (wsc.hitArea is MeshColliderHitTest) //Not supported for UIPainter, use TransfromPoint instead.
                    return new Vector2(float.NaN, float.NaN);

                Vector3 screePoint = wsc.GetRenderCamera().WorldToScreenPoint(worldPoint);
                return new Vector2(screePoint.x, Stage.inst.size.y - screePoint.y);
            }
            else
            {
                point = Stage.inst.cachedTransform.InverseTransformPoint(worldPoint);
                point.y = -point.y;
                return point;
            }
        }

        /// <summary>
        /// 转换世界坐标点到等效的本地xy平面的点。等效的意思是他们在屏幕方向看到的位置一样。
        /// 返回的点是在对象的本地坐标空间，且z=0
        /// </summary>
        /// <param name="worldPoint"></param>
        /// <param name="direction"></param>
        /// <returns></returns>
        public Vector3 WorldToLocal(Vector3 worldPoint, Vector3 direction)
        {
            Vector3 localPoint = this.cachedTransform.InverseTransformPoint(worldPoint);
            if (localPoint.z != 0) //如果对象绕x轴或y轴旋转过，或者对象是在透视相机，那么z值可能不为0，
            {
                //将世界坐标的摄影机方向在本地空间上投射，求出与xy平面的交点
                direction = this.cachedTransform.InverseTransformDirection(direction);
                float distOnLine = Vector3.Dot(Vector3.zero - localPoint, Vector3.forward) / Vector3.Dot(direction, Vector3.forward);
                if (float.IsInfinity(distOnLine))
                    return Vector2.zero;

                localPoint = localPoint + direction * distOnLine;
            }
            else if (_vertexMatrix != null)
            {
                Vector3 center = _vertexMatrix.cameraPos;
                center.z = 0;
                center -= _vertexMatrix.matrix.MultiplyPoint(center);

                Matrix4x4 mm = _vertexMatrix.matrix.inverse;

                localPoint -= center;
                localPoint = mm.MultiplyPoint(localPoint);

                Vector3 camPos = mm.MultiplyPoint(_vertexMatrix.cameraPos);
                Vector3 vec = localPoint - camPos;
                float lambda = -camPos.z / vec.z;
                localPoint = camPos + lambda * vec;
                localPoint.z = 0;
            }
            localPoint.y = -localPoint.y;

            return localPoint;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="localPoint"></param>
        /// <returns></returns>
        public Vector3 LocalToWorld(Vector3 localPoint)
        {
            localPoint.y = -localPoint.y;
            if (_vertexMatrix != null)
            {
                Vector3 center = _vertexMatrix.cameraPos;
                center.z = 0;
                center -= _vertexMatrix.matrix.MultiplyPoint(center);

                localPoint = _vertexMatrix.matrix.MultiplyPoint(localPoint);
                localPoint += center;

                Vector3 camPos = _vertexMatrix.cameraPos;
                Vector3 vec = localPoint - camPos;
                float lambda = -camPos.z / vec.z;
                localPoint = camPos + lambda * vec;
                localPoint.z = 0;
            }

            return this.cachedTransform.TransformPoint(localPoint);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="point"></param>
        /// <param name="targetSpace">null if to world space</param>
        /// <returns></returns>
        public Vector2 TransformPoint(Vector2 point, DisplayObject targetSpace)
        {
            if (targetSpace == this)
                return point;

            point = LocalToWorld(point);
            if (targetSpace != null)
                point = targetSpace.WorldToLocal(point, Vector3.back);

            return point;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="rect"></param>
        /// <param name="targetSpace">null if to world space</param>
        /// <returns></returns>
        public Rect TransformRect(Rect rect, DisplayObject targetSpace)
        {
            if (targetSpace == this)
                return rect;

            if (targetSpace == parent && _rotation.z == 0) // optimization
            {
                Vector3 vec = cachedTransform.localScale;
                return new Rect((this.x + rect.x) * vec.x, (this.y + rect.y) * vec.y,
                    rect.width * vec.x, rect.height * vec.y);
            }
            else
            {
                Vector4 vec4 = new Vector4(float.MaxValue, float.MaxValue, float.MinValue, float.MinValue);

                TransformRectPoint(rect.xMin, rect.yMin, targetSpace, ref vec4);
                TransformRectPoint(rect.xMax, rect.yMin, targetSpace, ref vec4);
                TransformRectPoint(rect.xMin, rect.yMax, targetSpace, ref vec4);
                TransformRectPoint(rect.xMax, rect.yMax, targetSpace, ref vec4);

                return Rect.MinMaxRect(vec4.x, vec4.y, vec4.z, vec4.w);
            }
        }

        protected void TransformRectPoint(float px, float py, DisplayObject targetSpace, ref Vector4 vec4)
        {
            Vector2 v = TransformPoint(new Vector2(px, py), targetSpace);

            if (vec4.x > v.x) vec4.x = v.x;
            if (vec4.z < v.x) vec4.z = v.x;
            if (vec4.y > v.y) vec4.y = v.y;
            if (vec4.w < v.y) vec4.w = v.y;
        }

        /// <summary>
        /// 
        /// </summary>
        public void RemoveFromParent()
        {
            if (parent != null)
                parent.RemoveChild(this);
        }

        /// <summary>
        /// 
        /// </summary>
        public void InvalidateBatchingState()
        {
            if (parent != null)
                parent.InvalidateBatchingState(true);
        }

        virtual public void Update(UpdateContext context)
        {
            if (_checkPixelPerfect != 0)
            {
                if (_rotation == Vector3.zero)
                {
                    Vector3 v = cachedTransform.localPosition;
                    v.x = Mathf.Round(v.x);
                    v.y = Mathf.Round(v.y);
                    _pixelPerfectAdjustment = v - cachedTransform.localPosition;
                    if (_pixelPerfectAdjustment != Vector3.zero)
                        cachedTransform.localPosition = v;
                }
                _checkPixelPerfect = 0;
            }

            if (graphics != null)
                graphics.Update(context, context.alpha * _alpha, context.grayed | _grayed);

            if (_paintingMode != 0)
            {
                UpdatePainting();

                //如果是容器，Capture要等到Container.Update的最后执行，因为容器中可能也有需要Capture的内容，要等他们完成后再进行容器的Capture。
                if (!(this is Container))
                {
                    if ((_flags & Flags.CacheAsBitmap) == 0 || _paintingInfo.flag != 2)
                        UpdateContext.OnEnd += _paintingInfo.captureDelegate;
                }

                paintingGraphics.Update(context, 1, false);
            }

            if (_filter != null)
                _filter.Update();

            Stats.ObjectCount++;
        }

        void UpdatePainting()
        {
            NTexture paintingTexture = paintingGraphics.texture;
            if (paintingTexture != null && paintingTexture.disposed) //Texture可能已被Stage.MonitorTexture销毁
            {
                paintingTexture = null;
                _paintingInfo.flag = 1;
            }

            if (_paintingInfo.flag == 1)
            {
                _paintingInfo.flag = 0;

                //从优化考虑，决定使用绘画模式的容器都需要明确指定大小，而不是自动计算包围。这在UI使用上并没有问题，因为组件总是有固定大小的
                Margin extend = _paintingInfo.extend;
                paintingGraphics.contentRect = new Rect(-extend.left, -extend.top, _contentRect.width + extend.left + extend.right, _contentRect.height + extend.top + extend.bottom);
                int textureWidth = Mathf.RoundToInt(paintingGraphics.contentRect.width * _paintingInfo.scale);
                int textureHeight = Mathf.RoundToInt(paintingGraphics.contentRect.height * _paintingInfo.scale);
                if (paintingTexture == null || paintingTexture.width != textureWidth || paintingTexture.height != textureHeight)
                {
                    if (paintingTexture != null)
                        paintingTexture.Dispose();
                    if (textureWidth > 0 && textureHeight > 0)
                    {
                        paintingTexture = new NTexture(CaptureCamera.CreateRenderTexture(textureWidth, textureHeight, UIConfig.depthSupportForPaintingMode));
                        Stage.inst.MonitorTexture(paintingTexture);
                    }
                    else
                        paintingTexture = null;
                    paintingGraphics.texture = paintingTexture;
                }
            }

            if (paintingTexture != null)
                paintingTexture.lastActive = Time.time;
        }

        void Capture()
        {
            if (paintingGraphics.texture == null)
                return;

            Vector2 offset = new Vector2(_paintingInfo.extend.left, _paintingInfo.extend.top);
            CaptureCamera.Capture(this, (RenderTexture)paintingGraphics.texture.nativeTexture, paintingGraphics.contentRect.height, offset);

            _paintingInfo.flag = 2; //2表示已完成一次Capture
            if (onPaint != null)
                onPaint();
        }

        /// <summary>
        /// 为对象设置一个默认的父Transform。当对象不在显示列表里时，它的GameObject挂到哪里。
        /// </summary>
        public Transform home
        {
            get { return _home; }
            set
            {
                _home = value;
                if (value != null && cachedTransform.parent == null)
                    cachedTransform.SetParent(value, false);
            }
        }

        void UpdateHierarchy()
        {
            if ((_flags & Flags.GameObjectDisposed) != 0)
                return;

            if ((_flags & Flags.UserGameObject) != 0)
            {
                //we dont change transform parent of this object
                if (gameObject != null)
                {
                    if (parent != null && visible)
                        gameObject.SetActive(true);
                    else
                        gameObject.SetActive(false);
                }
            }
            else if (parent != null)
            {
                cachedTransform.SetParent(parent.cachedTransform, false);

                if (_visible)
                    gameObject.SetActive(true);

                int layerValue = parent.gameObject.layer;
                if (parent._paintingMode != 0)
                    layerValue = CaptureCamera.hiddenLayer;
                SetLayer(layerValue, true);
            }
            else if ((_flags & Flags.Disposed) == 0 && this.gameObject != null && !StageEngine.beingQuit)
            {
                if (Application.isPlaying)
                {
                    if (gOwner == null || gOwner.parent == null)//如果gOwner还有parent的话，说明只是暂时的隐藏
                    {
                        cachedTransform.SetParent(_home, false);
                        if (_home == null)
                            UnityEngine.Object.DontDestroyOnLoad(this.gameObject);
                    }
                }

                gameObject.SetActive(false);
            }
        }

        virtual protected bool SetLayer(int value, bool fromParent)
        {
            if ((_flags & Flags.LayerSet) != 0) //setted
            {
                if (fromParent)
                    return false;
            }
            else if ((_flags & Flags.LayerFromParent) != 0) //inherit from parent
            {
                if (!fromParent)
                    _flags |= Flags.LayerSet;
            }
            else
            {
                if (fromParent)
                    _flags |= Flags.LayerFromParent;
                else
                    _flags |= Flags.LayerSet;
            }

            if (_paintingMode > 0)
                paintingGraphics.gameObject.layer = value;
            else if (gameObject.layer != value)
            {
                _SetLayerDirect(value);

                if (this is Container)
                {
                    int cnt = ((Container)this).numChildren;
                    for (int i = 0; i < cnt; i++)
                    {
                        DisplayObject child = ((Container)this).GetChildAt(i);
                        child.SetLayer(value, true);
                    }
                }
            }

            return true;
        }

        virtual internal void _SetLayerDirect(int value)
        {
            gameObject.layer = value;

            if (graphics != null && graphics.subInstances != null)
            {
                foreach (var g in graphics.subInstances)
                {
                    g.gameObject.layer = value;
                }
            }
        }

        virtual public void Dispose()
        {
            if ((_flags & Flags.Disposed) != 0)
                return;

            _flags |= Flags.Disposed;
            RemoveFromParent();
            RemoveEventListeners();
            if (graphics != null)
                graphics.Dispose();
            if (_filter != null)
                _filter.Dispose();
            if (paintingGraphics != null)
            {
                if (paintingGraphics.texture != null)
                    paintingGraphics.texture.Dispose();

                paintingGraphics.Dispose();
                if (paintingGraphics.gameObject != this.gameObject)
                {
                    if (Application.isPlaying)
                        UnityEngine.Object.Destroy(paintingGraphics.gameObject);
                    else
                        UnityEngine.Object.DestroyImmediate(paintingGraphics.gameObject);
                }
            }
            DestroyGameObject();
        }

        internal void DisplayDisposedWarning()
        {
            if ((_flags & Flags.DisposedWarning) == 0)
            {
                _flags |= Flags.DisposedWarning;

                StringBuilder sb = new StringBuilder();
                sb.Append("DisplayObject is still in use but GameObject was disposed. (");
                if (gOwner != null)
                {
                    sb.Append("type=").Append(gOwner.GetType().Name).Append(", x=").Append(gOwner.x).Append(", y=").Append(gOwner.y).Append(", name=").Append(gOwner.name);
                    if (gOwner.packageItem != null)
                        sb.Append(", res=" + gOwner.packageItem.name);
                }
                else
                {
                    sb.Append("id=").Append(id).Append(", type=").Append(this.GetType().Name).Append(", name=").Append(name);
                }
                sb.Append(")");
                Debug.LogError(sb.ToString());
            }
        }

        BatchElement _batchElement;
        virtual public BatchElement AddToBatch(List<BatchElement> batchElements, bool force)
        {
            if (graphics != null || force)
            {
                if (_batchElement == null)
                    _batchElement = new BatchElement(this, null);
                _batchElement.material = material;
                _batchElement.breakBatch = (_flags & Flags.SkipBatching) != 0;
                batchElements.Add(_batchElement);

                if (graphics != null && graphics.subInstances != null)
                {
                    foreach (var g in graphics.subInstances)
                    {
                        var m = g.material;
                        if (m != null)
                        {
                            var subBatchElement = g._batchElement;
                            if (subBatchElement == null)
                                subBatchElement = new BatchElement(g, _batchElement.bounds);
                            subBatchElement.material = m;
                            batchElements.Add(subBatchElement);
                        }
                    }
                }

                return _batchElement;
            }
            else
                return null;
        }

        protected internal class PaintingInfo
        {
            public Action captureDelegate; //缓存这个delegate，可以防止Capture状态下每帧104B的GC
            public Margin extend;
            public float scale;
            public int flag;
        }

        [Flags]
        public enum Flags
        {
            Disposed = 1,
            UserGameObject = 2,
            TouchDisabled = 4,
            OutlineChanged = 8,
            UpdatingSize = 0x10,
            WidthChanged = 0x20,
            HeightChanged = 0x40,
            PixelPerfect = 0x80,
            LayerSet = 0x100,
            LayerFromParent = 0x200,
            NotFocusable = 0x400,
            TabStop = 0x800,
            TabStopChildren = 0x1000,
            FairyBatching = 0x2000,
            BatchingRequested = 0x4000,
            BatchingRoot = 0x8000,
            SkipBatching = 0x10000,
            CacheAsBitmap = 0x20000,
            GameObjectDisposed = 0x40000,
            DisposedWarning = 0x80000
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class DisplayObjectInfo : MonoBehaviour
    {
        /// <summary>
        /// 
        /// /// </summary>
        [System.NonSerialized]
        public DisplayObject displayObject;

        private void OnDestroy()
        {
            if (displayObject != null)
                displayObject._flags |= DisplayObject.Flags.GameObjectDisposed;
        }
    }
}