C# Part.FindModelTransform方法代码示例

 public static void switchLight(Part p, String lightName, bool state)
 {
     Transform lightTransform = p.FindModelTransform(lightName);
     if (lightTransform != null) {
         Light light = lightTransform.GetComponent<Light>();
         if (light != null)
             light.intensity = (state ? 1 : 0);
     }
 }

 private bool LocateCamera(Part thatpart, string transformName)
 {
     Transform location = thatpart.FindModelTransform(transformName);
     if (location != null)
     {
         cameraTransform = location.gameObject;
         cameraPart = thatpart;
         return true;
     }
     return false;
 }

        public IntegratedIntakeEngineCrossSectionAdjuster(ModuleResourceIntake intake, Matrix4x4 worldToVesselMatrix)
        {
            this.part = intake.part;
            //ModuleResourceIntake intake = intake;

            intakeTrans = part.FindModelTransform(intake.intakeTransformName);
            vehicleBasisForwardVector = Vector3.forward;//intakeTrans.forward;

            foreach (AttachNode node in part.attachNodes)
                if (node.nodeType == AttachNode.NodeType.Stack && Vector3.Dot(node.position, (part.transform.worldToLocalMatrix * intakeTrans.localToWorldMatrix).MultiplyVector(Vector3.forward)) > 0)
                {
                    frontNode = node;
                    break;
                }

            thisToVesselMatrix = worldToVesselMatrix * intakeTrans.localToWorldMatrix;

            vehicleBasisForwardVector = thisToVesselMatrix.MultiplyVector(vehicleBasisForwardVector);

            intakeArea = INTAKE_AREA_SCALAR * intake.area;
        }

        public static Vector3 GuessUpVector(Part part)
        {
            // For intakes, use the intake vector
            if (part.Modules.Contains("ModuleResourceIntake"))
            {
                ModuleResourceIntake i = part.Modules["ModuleResourceIntake"] as ModuleResourceIntake;
                Transform intakeTrans = part.FindModelTransform(i.intakeTransformName);
                return part.transform.InverseTransformDirection(intakeTrans.forward);
            }
            // If surface attachable, and node normal is up, check stack nodes or use forward
            else if (part.srfAttachNode != null &&
                     part.attachRules.srfAttach &&
                     Mathf.Abs(part.srfAttachNode.orientation.normalized.y) > 0.9f)
            {
                // When the node normal is exactly Vector3.up, the editor orients forward along the craft axis
                Vector3 dir = Vector3.forward;
                bool first = true;

                foreach (AttachNode node in part.attachNodes)
                {
                    // Doesn't seem to ever happen, but anyway
                    if (node.nodeType == AttachNode.NodeType.Surface)
                        continue;

                    // If all node orientations agree, use that axis
                    if (first)
                    {
                        first = false;
                        dir = node.orientation.normalized;
                    }
                    // Conflicting node directions - bail out
                    else if (Mathf.Abs(Vector3.Dot(dir, node.orientation.normalized)) < 0.9f)
                        return Vector3.up;
                }

                if (debug)
                    MonoBehaviour.print(part.partInfo.title + ": Choosing axis " + dir + " for KJR surface attach" + (first ? "" : " from node") + ".");

                return dir;
            }
            else
            {
                return Vector3.up;
            }
        }

 public static BDArmor GetArmor(Collider collider, Part hitPart)
 {
     if (!hitPart)
         return null;
     var nodes = hitPart.partInfo.partConfig.GetNodes("BDARMOR");
     for (int i = 0; i < nodes.Length; i++)
     {
         var current = nodes[i];
         Transform transform;
         if (current.HasValue("ArmorRootTransform"))
             transform = hitPart.FindModelTransform(current.GetValue("ArmorRootTransform"));
         else
             transform = hitPart.partTransform;
         if (!transform)
         {
             Debug.LogError("Armor Transform not found!");
             return null;
         }
         if (collider.transform == transform || collider.transform.IsChildOf(transform))
         {
             return new BDArmor(nodes[i]);
         }
     }
     return null;
 }

        public static Vector3 GuessUpVector(Part part)
        {
            // For intakes, use the intake vector
            if (part.Modules.Contains("ModuleResourceIntake"))
            {
                ModuleResourceIntake i = part.Modules["ModuleResourceIntake"] as ModuleResourceIntake;
                Transform intakeTrans = part.FindModelTransform(i.intakeTransformName);
                return part.transform.InverseTransformDirection(intakeTrans.forward);
            }
            // If surface attachable, and node normal is up, check stack nodes or use forward
            else if (part.srfAttachNode != null &&
                     part.attachRules.srfAttach &&
                     Mathf.Abs(part.srfAttachNode.orientation.normalized.y) > 0.9f)
            {
                // When the node normal is exactly Vector3.up, the editor orients forward along the craft axis
                Vector3 dir = Vector3.forward;
                String dirname = null;

                foreach (AttachNode node in part.attachNodes)
                {
                    // Doesn't seem to ever happen, but anyway
                    if (node.nodeType == AttachNode.NodeType.Surface)
                        continue;

                    if(node.id.ToLowerInvariant() == "strut")
                        continue;

                    // If all node orientations agree, use that axis
                    String name = UpVectorFromDir(node.orientation);

                    if (dirname == null)
                    {
                        dirname = name;
                        dir = node.orientation;
                    }
                    // Conflicting node directions - bail out
                    else if (dirname != name)
                        return Vector3.up;
                }

                Debug.Log(part.partInfo.title + ": Choosing " + (dirname == null ? "heuristic forward" : dirname) + " axis for FAR drag model.");
                return dir;
            }
            else
            {
                return Vector3.up;
            }
        }

 private void ProcFairingHide(VesselElementViewOptions ol, VesselElementViewOption o, Part part)
 {
     MonoBehaviour.print("Hiding Procedural Fairing: " + part.ToString());
     var nct = part.FindModelTransform("nose_collider");
     if (!nct) return;
     var forward = EditorLogic.startPod.transform.forward;
     var right = EditorLogic.startPod.transform.right;
     if (Vector3.Dot(nct.right, -(forward + right).normalized) > 0f)
     {
         var renderer = part.GetComponentInChildren<Renderer>();
         if (renderer) renderer.enabled = false;
     }
 }

 private void ProcFairingExplode(VesselElementViewOptions ol, VesselElementViewOption o, Part part)
 {
     MonoBehaviour.print("Exploding Procedural Fairing: " + part.ToString());
     var nct = part.FindModelTransform("nose_collider");
     if (!nct) return;
     MeshFilter mf;
     Vector3 extents = (mf = part.gameObject.GetComponentInChildren<MeshFilter>()) ? mf.mesh.bounds.size : new Vector3(o.valueParam, o.valueParam, o.valueParam);
     part.transform.Translate(Vector3.Scale(nct.right, extents), Space.World);
 }

        private void ProcFairingHide(VesselElementViewOptions ol, VesselElementViewOption o, Part part)
        {
            if (hasMod("ProceduralFairings"))
            {
                var nct = part.FindModelTransform("nose_collider");
                if (!nct) return;
                var forward = EditorLogic.RootPart.transform.forward;
                var right = EditorLogic.RootPart.transform.right;

                if (Vector3.Dot(nct.right, -(forward).normalized) > 0f)
                {
                    var renderer = part.GetComponentInChildren<Renderer>();
                    if (renderer) renderer.enabled = false;
                }
            }
        }

 private void ProcFairingExplode(VesselElementViewOptions ol, VesselElementViewOption o, Part part)
 {
     if (hasMod("ProceduralFairings"))
     {
         var nct = part.FindModelTransform("nose_collider");
         if (!nct) return;
         this.procFairingOffset = o.valueParam;
         Vector3 extents = new Vector3(o.valueParam, o.valueParam, o.valueParam);
         part.transform.Translate(Vector3.Scale(nct.right, extents), Space.World);
     }
 }

        public Actuator(string configData, ActuatorType creatingType, Part thatPart)
        {
            savedNodePosition = faraway;

            type = creatingType;
            string remainder;
            if (configData.StartsWith ("!", StringComparison.Ordinal)) {
                inverted = true;
                remainder = configData.Substring (1).Trim ();
            } else {
                inverted = false;
                remainder = configData;
            }

            string[] tokens = remainder.Split (',');
            switch (type) {
            case ActuatorType.PartComponent:
                moduleID = remainder;
                JUtil.LogMessage (this, "Controlling PartComponent with moduleID {0}, {1}", moduleID, inverted ? "inverted" : "regular");
                break;
            case ActuatorType.PartComponentGroup:
                moduleID = remainder;
                JUtil.LogMessage (this, "Controlling PartComponentGroup with groupID {0}, {1}", moduleID, inverted ? "inverted" : "regular");
                break;
            case ActuatorType.PartModule:
                int moduleIndex = int.Parse (remainder.Split (',') [1]);
                var thoseModules = new List<PartModule> ();
                foreach (PartModule thatModule in thatPart.Modules) {
                    if (thatModule.ClassName == tokens [0].Trim ()) {
                        thoseModules.Add (thatModule);
                    }
                }
                if (moduleIndex < thoseModules.Count) {
                    controlledModule = thoseModules [moduleIndex];
                } else {
                    JUtil.LogErrorMessage (this, "Could not find PartModule named {2} number {0} in part {1}", moduleIndex, thatPart.name, tokens [0].Trim ());
                }
                JUtil.LogMessage (this, "Controlling PartModule named {0}, {1}", controlledModule.ClassName, inverted ? "inverted" : "regular");
                break;
            case ActuatorType.TransformTexture:

                if (tokens.Length == 3 || tokens.Length == 4) {
                    targetTransform = thatPart.FindModelTransform (tokens [0].Trim ());
                    if (targetTransform == null) {
                        throw new ArgumentException ("Could not find model transform.");
                    }
                    if (GameDatabase.Instance.ExistsTexture (tokens [1].Trim ()) && GameDatabase.Instance.ExistsTexture (tokens [2].Trim ())) {
                        falseString = tokens [1].Trim ();
                        trueString = tokens [2].Trim ();
                        JUtil.LogMessage (this, "Controlling texture on transform '{0}', {1}", tokens [0].Trim (), inverted ? "inverted" : "regular");
                    } else {
                        throw new ArgumentException ("Textures not found.");
                    }
                    if (tokens.Length == 4) {
                        textureLayer = tokens [3].Trim ();
                    }
                } else {
                    throw new ArgumentException ("Bad arguments.");
                }
                break;
            case ActuatorType.TransformShader:
                if (tokens.Length == 3) {
                    targetTransform = thatPart.FindModelTransform (tokens [0].Trim ());
                    if (targetTransform == null) {
                        throw new ArgumentException ("Could not find model transform.");
                    }
                    if (Shader.Find (tokens [1].Trim ()) && Shader.Find (tokens [2].Trim ())) {
                        falseString = tokens [1].Trim ();
                        trueString = tokens [2].Trim ();
                        JUtil.LogMessage (this, "Controlling shader on transform '{0}', {1}", tokens [0].Trim (), inverted ? "inverted" : "regular");
                    } else {
                        throw new ArgumentException ("Shaders not found.");
                    }
                } else {
                    throw new ArgumentException ("Bad arguments.");
                }
                break;
            case ActuatorType.StraightParameter:
                if (tokens.Length == 2) {
                    if (float.TryParse (tokens [1], out addToParameterWhenEnabled)) {
                        if (Array.IndexOf (knownStraightParameters, tokens [0].Trim ()) >= 0) {
                            nameOfParameter = tokens [0].Trim ();
                            originalParameterValue = GetParameter (nameOfParameter, thatPart);
                            JUtil.LogMessage (this, "Controlling parameter '{0}' on part {1}, {2}", nameOfParameter, thatPart.partName, inverted ? "inverted" : "regular");
                        } else {
                            throw new ArgumentException ("Bad arguments, unknown straight parameter " + tokens [0]);
                        }
                    } else {
                        throw new ArgumentException ("Bad argument, maxTemp must be a float.");
                    }
                } else {
                    throw new ArgumentException ("Bad arguments.");
                }
                break;
            case ActuatorType.Resource:
                if (tokens.Length == 2) {
                    if (float.TryParse (tokens [1], out maxAmount)) {
                        bool found = false;
                        resourceName = tokens [0].Trim ();
                        foreach (PartResourceDefinition thatResource in PartResourceLibrary.Instance.resourceDefinitions) {
//.........这里部分代码省略.........