示例#1
0
        /// <summary>Constructs a joint node for the requested config.</summary>
        /// <param name="modelName">Name of the model in the hierarchy.</param>
        /// <returns>Pipe's end node.</returns>
        protected virtual ModelPipeEndNode LoadJointNode(string modelName)
        {
            var node = new ModelPipeEndNode(partModelTransform.Find(modelName));

            node.AlignTo(null); // Init mode objects state.
            return(node);
        }
示例#2
0
        /// <summary>Builds a model for the joint end basing on the configuration.</summary>
        /// <param name="node">The node to setup.</param>
        /// <param name="alignTo">
        /// The object to align the conenctor to. If it's <c>null</c>, then the model will be parked.
        /// </param>
        protected virtual void UpdateJointNode(ModelPipeEndNode node, Transform alignTo)
        {
            var config = node.config;
            var makeProceduralModels = alignTo != null || !config.parkPrefabOnly;

            // Return the models back to the owner part to make the search working properly.
            if (node.rootModel != null)
            {
                node.AlignToTransform(null);
            }

            node.parkRootObject = partModelTransform;

            // Create basic setup.
            var nodeName = ModelBasename + "-pipeNode" + node.name;

            node.rootModel = partModelTransform.Find(nodeName)
                             ?? new GameObject(nodeName).transform;
            node.rootModel.parent = partModelTransform;
            node.partAttach       = node.rootModel.Find(PartJointTransformName)
                                    ?? new GameObject(PartJointTransformName).transform;
            Hierarchy.MoveToParent(node.partAttach, node.rootModel,
                                   newPosition: Vector3.zero,
                                   newRotation: Quaternion.LookRotation(Vector3.back));
            node.pipeAttach = node.rootModel.Find(PipeJointTransformName)
                              ?? new GameObject(PipeJointTransformName).transform;
            Hierarchy.MoveToParent(node.pipeAttach, node.rootModel,
                                   newPosition: Vector3.zero,
                                   newRotation: Quaternion.LookRotation(Vector3.forward));

            // Add a pipe attachment sphere if set.
            const string sphereName = "pipeSphere";
            var          sphere     = node.pipeAttach.Find(sphereName);

            if (config.sphereDiameter > float.Epsilon && makeProceduralModels)
            {
                if (sphere == null)
                {
                    sphere = Meshes.CreateSphere(config.sphereDiameter, pipeMaterial, node.pipeAttach,
                                                 colliderType: Colliders.PrimitiveCollider.Shape).transform;
                    sphere.name     = sphereName;
                    sphere.rotation = Quaternion.LookRotation(node.partAttach.up, node.partAttach.forward);
                }
                sphere.GetComponent <Renderer>().sharedMaterial = pipeMaterial; // For performance.
                RescalePipeTexture(sphere, sphere.localScale.z * config.sphereDiameter * 2.0f);
            }
            else if (sphere != null)
            {
                Hierarchy.SafeDestory(sphere);
            }

            // Parking position, if defined.
            var parkObjectName = ModelBasename + "-park" + node.name;
            var parkAttach     = partModelTransform.Find(parkObjectName);

            if (config.parkAttachAt != null)
            {
                node.parkAttach = parkAttach ?? new GameObject(parkObjectName).transform;
                Hierarchy.MoveToParent(node.parkAttach, partModelTransform,
                                       newPosition: config.parkAttachAt.pos,
                                       newRotation: config.parkAttachAt.rot);
            }
            else if (parkAttach != null)
            {
                Hierarchy.SafeDestory(parkAttach);
            }

            // Place prefab between the part and the pipe if specified.
            if (!string.IsNullOrEmpty(config.modelPath))
            {
                // The prefab model can move to the part's model, so make a unique name for it.
                const string prefabName  = "prefabConnector";
                var          prefabModel = node.rootModel.Find(prefabName)
                                           ?? Hierarchy.FindTransformByPath(partModelTransform, config.modelPath);
                if (prefabModel != null)
                {
                    prefabModel.gameObject.SetActive(true);
                    prefabModel.name         = prefabName;
                    prefabModel.parent       = node.rootModel;
                    prefabModel.rotation     = node.partAttach.rotation * config.modelPartAttachAt.rot.Inverse();
                    prefabModel.position     = node.partAttach.TransformPoint(config.modelPartAttachAt.pos);
                    node.pipeAttach.rotation = prefabModel.rotation * config.modelPipeAttachAt.rot;
                    node.pipeAttach.position = prefabModel.TransformPoint(config.modelPipeAttachAt.pos);
                }
                else
                {
                    HostedDebugLog.Error(this, "Cannot find prefab model: {0}", config.modelPath);
                }
            }

            // The offset is intended for the sphere/arm models only.
            if (makeProceduralModels)
            {
                node.pipeAttach.localPosition += new Vector3(0, 0, config.sphereOffset);
            }

            // Add arm pipe.
            const string armName = "sphereArm";
            var          arm     = node.pipeAttach.Find(armName);

            if (config.armDiameter > float.Epsilon && config.sphereOffset > float.Epsilon &&
                makeProceduralModels)
            {
                if (arm == null)
                {
                    arm = Meshes.CreateCylinder(config.armDiameter, config.sphereOffset, pipeMaterial,
                                                node.pipeAttach,
                                                colliderType: Colliders.PrimitiveCollider.Shape).transform;
                    arm.name = armName;
                }
                arm.GetComponent <Renderer>().sharedMaterial = pipeMaterial; // For performance.
                arm.transform.localPosition = new Vector3(0, 0, -config.sphereOffset / 2);
                arm.transform.localRotation = Quaternion.LookRotation(Vector3.forward);
                RescalePipeTexture(arm.transform, arm.localScale.z * config.sphereOffset);
            }
            else if (arm != null)
            {
                Hierarchy.SafeDestory(arm);
            }

            // Adjust to the new target.
            node.AlignToTransform(alignTo);
        }
示例#3
0
 /// <inheritdoc/>
 public override void OnAwake()
 {
     base.OnAwake();
     sourceJointNode = new ModelPipeEndNode(SourceNodeName, sourceJointConfig);
     targetJointNode = new ModelPipeEndNode(TargetNodeName, targetJointConfig);
 }