public static GameObject Create(GameObject prefab, Vector3 pos, Quaternion rot, Transform parent)
        {
            if (parent == null) return Create(prefab, pos, rot);

            prefab.AddOrGetComponent<EarlyParentSetter>().Init(parent);
            return UnityEngine.Object.Instantiate(prefab, pos, rot) as GameObject;
        }

 internal static void CalculateAnchorSnapValues(Transform parentSpace, Transform self, RectTransform gui, int minmaxX, int minmaxY)
 {
   for (int mainAxis = 0; mainAxis < 2; ++mainAxis)
   {
     RectTransformSnapping.s_SnapGuides[mainAxis].Clear();
     parentSpace.GetComponent<RectTransform>().GetWorldCorners(RectTransformSnapping.s_Corners);
     for (int index = 0; index < RectTransformSnapping.kSidesAndMiddle.Length; ++index)
     {
       float alongMainAxis = RectTransformSnapping.kSidesAndMiddle[index];
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(alongMainAxis, new Vector3[2]
       {
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 0.0f),
         RectTransformSnapping.GetInterpolatedCorner(RectTransformSnapping.s_Corners, mainAxis, alongMainAxis, 1f)
       }));
     }
     foreach (Transform transform in parentSpace)
     {
       if (!((Object) transform == (Object) self))
       {
         RectTransform component = transform.GetComponent<RectTransform>();
         if ((bool) ((Object) component))
         {
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMin[mainAxis], new Vector3[0]));
           RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(component.anchorMax[mainAxis], new Vector3[0]));
         }
       }
     }
     int num = mainAxis != 0 ? minmaxY : minmaxX;
     if (num == 0)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMax[mainAxis], new Vector3[0]));
     if (num == 1)
       RectTransformSnapping.s_SnapGuides[mainAxis].AddGuide(new SnapGuide(gui.anchorMin[mainAxis], new Vector3[0]));
   }
 }

 public MapData(Transform parent, string mapName, int width, int height)
 {
     this.ParentTransform = parent;
     this.Name = mapName;
     this.Width = width;
     this.Height = height;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Trackar.WheelDummy"/> class.
        /// </summary>
        /// <param name="col">Col.</param>
        /// <param name="joint">Joint.</param>
        /// <param name="model">Model.</param>
        /// <param name="config">WheelDummyConfigContainer.</param>
        public WheelDummy(WheelCollider col, Transform joint, GameObject model, WheelDummyConfigContainer config)
        {
            if (col == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null WheelCollider");
                col = new WheelCollider ();
            }
            if(joint == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null Joint");
                joint = new GameObject ().transform; // lol gg unity
            }
            if(model == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null Model");
                model = new GameObject ();
            }
            if(config == null)
            {
                Debuggar.Error ("WheelDummy: Attempted spawn with null WheelDummyConfigContainer");
                config = new WheelDummyConfigContainer ();
            }

            Collider = col;
            Joint = joint;
            WheelModel = model;
            Susp = config.SuspConfig;

            Collider.enabled = true;
            Collider.brakeTorque = config.RollingResistance;
            Debuggar.Message ("WheelDummy: brakeTorque is " + Collider.brakeTorque.ToString () + " RollingResistance is " + config.RollingResistance.ToString ());

            Debuggar.Message ("WheelDummy: Spawned");
        }

 public void DoAction(SetQuestStateAction action, Transform actor)
 {
     if ((action != null) && !string.IsNullOrEmpty(action.questName)) {
         QuestLog.SetQuestState(action.questName, action.questState);
         if (!string.IsNullOrEmpty(action.alertMessage)) DialogueManager.ShowAlert(action.alertMessage);
     }
 }

 private void TryActions(SetQuestStateAction[] actions, Transform actor)
 {
     if (actions == null) return;
     foreach (SetQuestStateAction action in actions) {
         if (action != null && action.condition != null && action.condition.IsTrue(actor)) DoAction(action, actor);
     }
 }

 public static void ActiveRecursively(Transform obj, bool active)
 {
     foreach (Transform child in obj) {
         InfiniteRunnerStarterPackUtility.ActiveRecursively(child, active);
     }
     obj.gameObject.SetActive(active);
 }

        public override Status Update () {
            // Get the point transform
            if (m_PointTransform == null || m_PointTransform.gameObject != point.Value)
                m_PointTransform = point.Value != null ? point.Value.transform : null;

            // Validate members
            if (m_PointTransform == null)
                return Status.Error;

            // OverlapPoint
            Collider2D collider2D = Physics2D.OverlapPoint(m_PointTransform.position, layers);

            // Is there a collider2D inside the rectangle?
            if (collider2D != null) {
                // Store result
                storeGameObject.Value = collider2D.gameObject;

                // Tick child?
                if (child != null) {
                    child.OnTick();
                    return child.status;
                }
                else
                    return Status.Success;
            }
            else {
                // Store result
                storeGameObject.Value = null;
                return Status.Failure;
            }
        }

 public WidgetData(string layer, string name, Transform widget, string type)
 {
     this.layerName = layer;
     this.widgetName = name;
     this.widgetObject = widget;
     this.widgetType = type;
 }

        public void SetLookAt(Transform lookAtObject, LookAtAxis axis)
        {
            if (m_transformComponent == null)
                m_transformComponent = this.GetComponent<Transform>();

            if (m_transformComponent != null)
            {
                Vector3 currentLookAtAxis = Vector3.zero;
                switch (axis)
                {
                case LookAtAxis.Up:
                    currentLookAtAxis = m_transformComponent.up;
                    break;
                case LookAtAxis.Down:
                    currentLookAtAxis = -m_transformComponent.up;
                    break;
                case LookAtAxis.Right:
                    currentLookAtAxis = m_transformComponent.right;
                    break;
                case LookAtAxis.Left:
                    currentLookAtAxis = -m_transformComponent.right;
                    break;
                case LookAtAxis.Forward:
                    currentLookAtAxis = m_transformComponent.forward;
                    break;
                }

                m_transformComponent.LookAt(LookAtObject, currentLookAtAxis);
            }
        }

        /*
         * Constructor
         * Input: The owning part's transform.
         * Purpose: This constructor will start up the owning part's camera object. The idea behind this
         * was to allow for multiple telescopes on the same craft.
         */
        public CactEyeCamera(Transform Position)
        {
            this.CameraTransform = Position;

            CameraWidth = (int)(Screen.width*0.4f);
            CameraHeight = (int)(Screen.height*0.4f);

            ScopeRenderTexture = new RenderTexture(CameraWidth, CameraHeight, 24);
            ScopeRenderTexture.Create();

            FullResolutionTexture = new RenderTexture(Screen.width, Screen.height, 24);
            FullResolutionTexture.Create();

            ScopeTexture2D = new Texture2D(CameraWidth, CameraHeight);
            FullTexture2D = new Texture2D(Screen.width, Screen.height);

            CameraSetup(0, "GalaxyCamera"); //As of KSP 1.0, the GalaxyCamera object was added. Thanks to MOARDv for figuring this one out.
            CameraSetup(1, "Camera ScaledSpace");
            CameraSetup(2, "Camera 01");
            CameraSetup(3, "Camera 00");
            CameraSetup(4, "Camera VE Underlay");
            CameraSetup(5, "Camera VE Overlay");

            skyboxRenderers = (from Renderer r in (FindObjectsOfType(typeof(Renderer)) as IEnumerable<Renderer>) where (r.name == "XP" || r.name == "XN" || r.name == "YP" || r.name == "YN" || r.name == "ZP" || r.name == "ZN") select r).ToArray<Renderer>();
            if (skyboxRenderers == null)
            {
                Debug.Log("CactEye 2: Logical Error: skyboxRenderers is null!");
            }

            scaledSpaceFaders = FindObjectsOfType(typeof(ScaledSpaceFader)) as ScaledSpaceFader[];
            if (scaledSpaceFaders == null)
            {
                Debug.Log("CactEye 2: Logical Error: scaledSpaceFaders is null!");
            }
        }

 /// <inheritdoc />
 public void ApplyTransform(Transform target)
 {
     if (DeltaPosition != Vector3.zero) target.position += DeltaPosition;
     if (!Mathf.Approximately(DeltaRotation, 0f))
         target.rotation = Quaternion.Euler(0, 0, DeltaRotation)*target.rotation;
     if (!Mathf.Approximately(DeltaScale, 1f)) target.localScale *= DeltaScale;
 }

		void CaptureTransform(Transform transform, string path, AnimationClip clip)
		{
			path += transform.name;

			//Debug.Log(path);

			if (position.Value)
			{
				CapturePosition(transform, path, clip);
			}

			if (rotation.Value)
			{
				CaptureRotation(transform, path, clip);
			}

			if (scale.Value)
			{
				CaptureScale(transform, path, clip);
			}

			foreach (Transform child in transform)
			{
				CaptureTransform(child, path + "/", clip);
			}
		}

 private static void ExportAnimations(Transform transform, BabylonIAnimatable animatable)
 {
     var animator = transform.gameObject.GetComponent<Animator>();
     if (animator != null)
     {
         AnimatorController ac = animator.runtimeAnimatorController as AnimatorController;
         if (ac == null)
         {
             return;
         }
         var layer = ac.layers[0];
         if (layer == null)
         {
             return;
         }
         AnimatorStateMachine sm = layer.stateMachine;
         if (sm.states.Length > 0)
         {
             var state = sm.states[0].state; // We only support the first one
             AnimationClip clip = state.motion as AnimationClip;
             if (clip != null)
             {
                 ExportAnimationClip(clip, true, animatable);
             }
         }
     }
     else
     {
         var animation = transform.gameObject.GetComponent<Animation>();
         if (animation != null && animation.clip != null)
         {
             ExportAnimationClip(animation.clip, animation.playAutomatically, animatable);
         }
     }
 }

        public override Status Update () {
            // Get the transform
            if (m_Transform == null || m_Transform.gameObject != gameObject.Value)
                m_Transform = gameObject.Value != null ? gameObject.Value.transform : null;

            // Validate members?
            if  (m_Transform == null)
                return Status.Error;

            // Get the desiredTranslation
            Vector3 desiredTranslation =  !translation.isNone ? translation.Value : Vector3.zero;

            // Override values?
            if (!x.isNone) desiredTranslation.x = x.Value;
            if (!y.isNone) desiredTranslation.y = y.Value;
            if (!z.isNone) desiredTranslation.z = z.Value;

            // Translate per second?
            if (perSecond)
                m_Transform.Translate(desiredTranslation * this.owner.deltaTime, relativeTo);
            else
                m_Transform.Translate(desiredTranslation, relativeTo);

            return Status.Success;
        }

 public AnimatedNode(AttachNode node, Transform node_transform, Part part)
 {
     this.node = node;
     this.part = part;
     nT        = node_transform;
     pT        = part.partTransform;
 }

 private void SetStatsValue(Transform t, float value)
 {
     RectTransform r = t.GetComponent<RectTransform>();
     var size = r.rect.size.x - r.offsetMax.x; // + car value -
     var val = size - ((size / 10) * value);
     r.offsetMax = new Vector2(-val, r.offsetMax.y);
 }

 public void WaterTileBeingRendered(Transform tr, Camera currentCam)
 {
     if (currentCam && edgeBlend)
     {
         currentCam.depthTextureMode |= DepthTextureMode.Depth;
     }
 }

        public override Status Update () {
            // Get the transform1
            if (m_Transform1 == null || m_Transform1.gameObject != gameObject1.Value)
                m_Transform1 = gameObject1.Value != null ? gameObject1.Value.transform : null;

            // Get the transform2
            if (m_Transform2 == null || m_Transform2.gameObject != gameObject2.Value)
                m_Transform2 = gameObject2.Value != null ? gameObject2.Value.transform : null;

            // Validate members
            if (m_Transform1 == null || m_Transform2 == null)
                return Status.Error;

            // Store distance
            if (relativeTo == Space.World)
                storeDistance.Value = m_Transform1.position - m_Transform2.position;
            else
                storeDistance.Value = m_Transform1.localPosition - m_Transform2.localPosition;

            storeX.Value = storeDistance.Value.x;
            storeY.Value = storeDistance.Value.y;
            storeZ.Value = storeDistance.Value.z;

            return Status.Success;
        }

 private static void GetDirectParticleSystemChildrenRecursive(Transform transform, List<ParticleSystem> particleSystems)
 {
     IEnumerator enumerator = transform.GetEnumerator();
     try
     {
         while (enumerator.MoveNext())
         {
             Transform current = (Transform) enumerator.Current;
             ParticleSystem component = current.gameObject.GetComponent<ParticleSystem>();
             if (component != null)
             {
                 particleSystems.Add(component);
                 GetDirectParticleSystemChildrenRecursive(current, particleSystems);
             }
         }
     }
     finally
     {
         IDisposable disposable = enumerator as IDisposable;
         if (disposable == null)
         {
         }
         disposable.Dispose();
     }
 }