C# Transform.FindOrCreate方法代码示例

        public GameObject[] generatePanels(Transform parent, Vector3 pivot)
        {
            //each panelEdgeGroup should now contain the vertical edge loops for each vertical panel grouping
            //from here, need to generate meshes for panels depending upon splitPanels setting
            int len = panelGroups.Length;
            GameObject[] gos = generatePanels(parent);
            float newX, newZ;
            for (int i = 0; i < len; i++)
            {
                float yRot = panelGroups[i].getPivotRotation();
                float dist = Mathf.Sqrt(pivot.x * pivot.x + pivot.z * pivot.z);

                newX = Mathf.Cos(yRot * Mathf.Deg2Rad)*dist;
                newZ = Mathf.Sin(yRot * Mathf.Deg2Rad)*dist;
                Vector3 newPivot = new Vector3(newX, pivot.y, newZ);

                GameObject pivotObject = parent.FindOrCreate("FairingPanelPivot-"+i).gameObject;
                pivotObject.transform.parent = parent;
                pivotObject.transform.rotation = parent.transform.rotation;
                pivotObject.transform.localPosition = newPivot + offset;
                pivotObject.transform.Rotate(new Vector3(0, 1, 0), -yRot + 90f, Space.Self);

                gos[i].transform.parent = pivotObject.transform;
                gos[i] = pivotObject;
            }
            return gos;
        }

        public GameObject[] generatePanels(Transform parent)
        {
            //each panelEdgeGroup should now contain the vertical edge loops for each vertical panel grouping
            //from here, need to generate meshes for panels depending upon splitPanels setting
            int len = panelGroups.Length;
            GameObject[] gos = new GameObject[panels];
            for (int i = 0; i < len; i++)
            {
                gos[i] = parent.FindOrCreate("FairingPanel-"+i).gameObject;
                MeshFilter mf = gos[i].GetComponent<MeshFilter>();
                if (mf == null) { mf = gos[i].AddComponent<MeshFilter>(); }
                mf.mesh = panelGroups[i].generatePanels(offset, outsideUV, insideUV, edgesUV);

                MeshRenderer mr = gos[i].GetComponent<MeshRenderer>();
                if (mr == null) { mr = gos[i].AddComponent<MeshRenderer>(); }
                gos[i].transform.parent = parent;
                gos[i].transform.localPosition = Vector3.zero;
                gos[i].transform.rotation = parent.rotation;
            }
            return gos;
        }

        public void setupModel(Part part, Transform baseTransform, Transform targetRotator)
        {
            this.partTransform = part.transform;

            String suffix = (main ? "-main-" : "-drogue-") + index;

            retractedTarget = targetRotator.FindOrCreate("ParachuteRetractedTarget" + suffix).gameObject;
            retractedTarget.transform.NestToParent(targetRotator);
            retractedTarget.transform.localPosition = new Vector3(-retractedUpVector.x, -retractedUpVector.z, retractedUpVector.y);

            semiDeployedTarget = targetRotator.FindOrCreate("ParachuteSemiDeployTarget" + suffix).gameObject;
            semiDeployedTarget.transform.NestToParent(targetRotator);
            semiDeployedTarget.transform.localPosition = new Vector3(-semiDeployedUpVector.x, -semiDeployedUpVector.z, semiDeployedUpVector.y);

            fullDeployedTarget = targetRotator.FindOrCreate("ParachuteFullDeployTarget" + suffix).gameObject;
            fullDeployedTarget.transform.NestToParent(targetRotator);
            fullDeployedTarget.transform.localPosition = new Vector3(-fullDeployedUpVector.x, -fullDeployedUpVector.z, fullDeployedUpVector.y);

            parachutePivot = baseTransform.FindOrCreate("ParachuteSpacingPivot" + suffix).gameObject;
            parachutePivot.transform.NestToParent(baseTransform);
            parachutePivot.transform.localPosition = new Vector3(localPosition.x, localPosition.y, -localPosition.z);//TODO -- why does this need to be inverted?

            Transform modelTransform = parachutePivot.transform.FindRecursive(modelName);
            if (modelTransform == null)
            {
                baseModel = SSTUUtils.cloneModel(modelName);
            }
            else
            {
                baseModel = modelTransform.gameObject;
            }
            baseModel.transform.NestToParent(parachutePivot.transform);
            if (!String.IsNullOrEmpty(texture))
            {
                SSTUUtils.setMainTextureRecursive(baseModel.transform, GameDatabase.Instance.GetTexture(texture, false));
            }

            Transform tr = baseModel.transform.FindRecursive(definition.capName);
            if (tr == null) { MonoBehaviour.print("ERROR: Could not locate transform for cap name: " + definition.capName); }
            capModel = tr.gameObject;
            tr = baseModel.transform.FindRecursive(definition.lineName);
            if (tr == null) { MonoBehaviour.print("ERROR: Could not locate transform for line name: " + definition.lineName); }
            lineModel = tr.gameObject;

            Vector3 lookDir = (-(parachutePivot.transform.position - semiDeployedTarget.transform.position));
            lookDir.Normalize();
            parachutePivot.transform.rotation = Quaternion.LookRotation(lookDir, part.transform.forward);
            prevWind = parachutePivot.transform.rotation;
            baseModel.transform.localRotation = Quaternion.AngleAxis(-90, Vector3.left);
        }