void UpdateAbsorbingTgt(bool bAbsorbing) { for (int i = 0; i < 2; i++) { Animator an = _Anims [i]; Lyu.SoftArmCtrl armCtrl = an.GetComponent <Lyu.SoftArmCtrl> (); MiroV1AbsorbPoint absorbPt = _AbsorbPoss [i]; if (bAbsorbing && absorbPt._emitter != null) { Transform emTF = absorbPt._emitter.transform; armCtrl._Tgt = absorbPt._emitter.transform; //print ("absorbPt._emitter:" + absorbPt._emitter); GameObject ENBallPref = _ENAbsorbPrefabs [i]; TargetTransform tgtTf = ENBallPref.GetComponent <TargetTransform> (); var LRFollow = ENBallPref.GetComponent <SA_FollowLR> (); tgtTf._Target = absorbPt._emitter.transform; LRFollow.SetLineRenderer(_LRs [i]); absorbPt._emitter._ENAbsorbPrefab = ENBallPref; } else { armCtrl.SetTargetTF(_DefaultTgts [i]); } } }
public void RemoveFromOptimizer(Transform optimizerTransform) { if (SourceParentTransform != null && TargetTransform != null) { TargetTransform.SetParent(SourceParentTransform, true); } }
protected override void Manipulate() { if (_axis == Axis.Y) { float angle = YAngle(); float deltaAngle = angle - _priorAngle; TargetTransform.Rotate(new Vector3(0, deltaAngle, 0), Space.World); _priorAngle = angle; } else if (_axis == Axis.X) { float angle = XAngle(); float deltaAngle = angle - _priorAngle; if (_rotateAxis == RotateAxis.LocalX) { TargetTransform.Rotate(new Vector3(deltaAngle, 0, 0), Space.Self); } else if (_rotateAxis == RotateAxis.LocalZ) { TargetTransform.Rotate(new Vector3(0, 0, deltaAngle), Space.Self); } else if (_rotateAxis == RotateAxis.Screen) { Vector3 cameraDirection = _eventCamera.EventCameraRef.transform.position - TargetTransform.position; Vector3 crossDirection = Vector3.Cross(cameraDirection, Vector3.up); TargetTransform.RotateAround(TargetTransform.position, crossDirection, deltaAngle); } _priorAngle = angle; } }
public override void Undo() { if (m_SplittedTransform != null) { Element.RemoveTransition(m_SplittedTransform); TargetTransform.Merge(m_SplittedTransform); } }
/// <summary> /// Nudges the transform in the specified rotation. /// </summary> /// <param name="rotation"> /// The direction to nudge in. /// </param> public void Nudge(NudgeRotation rotation) { // Determine angle float angle = (rotation == NudgeRotation.Left ? -rotationAmount : rotationAmount); // Update the rotation TargetTransform.Rotate(upDirection.ToVector(), angle, space); }
private void PlaceTargetAtStart(TargetTransform target, bool sendAgain) { target.transform.localPosition = startBounds.localPosition; if (sendAgain) { targetsReadyToSend.Add(target); } }
public Vector3 GetTargetVector(bool useOffset = true) { Vector3 targetPoint = Vector3.zero; switch (_targetType) { case TargetType.Transform: if (TargetTransform != null) { if (useOffset) { if (useLocalOffset) { targetPoint = TargetTransform.position + TargetTransform.TransformDirection(PositionOffset); } else { targetPoint = TargetTransform.position + PositionOffset; } } else { targetPoint = TargetTransform.position; } } break; case TargetType.Vector: if (useOffset) { targetPoint = new Vector3(TargetVector.x + PositionOffset.x, TargetVector.y + PositionOffset.y, TargetVector.z + PositionOffset.z); } else { targetPoint = TargetVector; } break; case TargetType.MainCamera: if (useOffset) { targetPoint = Camera.main.transform.position + Camera.main.transform.TransformDirection(PositionOffset); } else { targetPoint = Camera.main.transform.position; } break; } return(targetPoint); }
private void TrySendTarget() { TargetTransform target = GetAvailableTarget(); if (target != null) { target.Move(farBounds.localPosition, farBounds.localPosition, PlaceTargetAtStart); } }
// Update is called once per frame void Update() { TargetTransform tgtTF = GetComponent <TargetTransform> (); /* * MiroModelV1 model = * tgtTF._Target.GetComponent<MiroModelV1> (); */ }
public void HandTargets(List <TargetBase> targets) { for (int i = 0; i < targets.Count; ++i) { TargetTransform trans = GetOrSpawnTargetTransform(); trans.HandTarget(targets[i]); } Reset(); }
void SetEmitTarget(GameObject bullet, Transform tgt) { TargetTransform ttf = bullet.GetComponent <TargetTransform> (); if (ttf == null) { ttf = bullet.AddComponent <TargetTransform> (); } ttf._Target = tgt; }
/// <summary> /// Nudges the transform in the specified direction. /// </summary> /// <param name="direction"> /// The direction to nudge in. /// </param> public void Nudge(RefinementDirection direction) { // Figure out which actual direction RefinementDirection actualDireciton = direction.RelativeTo(forwardDirection); // Create the offset Vector3 offset = actualDireciton.ToVector() * directionAmount; // Update the position using the correct coordinate space (local vs world) TargetTransform.Translate(offset, space); }
public override void Do() { ElementTransform trans; TargetTransform.Split(Time, out trans); if (m_SplittedTransform != null) { trans.CopyFrom(m_SplittedTransform); } m_SplittedTransform = trans; }
private TargetTransform GetAvailableTarget() { TargetTransform target = null; if (targetsReadyToSend.Count > 0) { target = targetsReadyToSend[0]; targetsReadyToSend.RemoveAt(0); } return(target); }
override protected void _Calculate() { TargetTransform tgtTF = GetComponent <TargetTransform> (); Transform tgt = tgtTF._Target; MiroV1BlackDotBase bdot = tgt.GetComponent <MiroV1BlackDotBase> (); if (bdot != null && bdot._HP > 0) { bdot.Break(); } }
public void TranslateTargetPositionRotationRecursive(Vector3 deltaPosition, Vector3 deltaDirection) { TargetTransform.Translate(deltaPosition, Space.World); TargetTransform.forward = TargetTransform.forward + deltaDirection; ItemDrop dropItemMod = GetComponent <ItemDrop>(); if (dropItemMod != null) { for (int i = 0; i < dropItemMod.ChildItemDragList.Count; ++i) { dropItemMod.ChildItemDragList[i].TranslateTargetPositionRotationRecursive(deltaPosition, deltaDirection); } } }
private TargetTransform GetOrSpawnTargetTransform() { for (int i = 0; i < targetRoots.Count; ++i) { if (!targetRoots[i].HasTarget) { return(targetRoots[i]); } } //We haven't sent a root, so need to spawn a new one GameObject newTrans = Instantiate(targetTransformPrefab, targetSpawnRoot, false); TargetTransform target = newTrans.GetComponent <TargetTransform>(); targetRoots.Add(target); targetsReadyToSend.Add(target); return(target); }
void CreateDebugSphere() { TargetPool targetPool = FindObjectOfType <TargetPool>(); if (sphereTargets.Any()) { foreach (Target target in sphereTargets) { targetPool.Return(target); } } for (int i = 0; i < (pitchCount - 1); i++) { TargetPosition targetPos = TargetTransform.CalculateTargetTransform(i + 1, (0f, 0f, 0f)); TargetData targetData = new TargetData(TargetBehavior.Standard, TargetHandType.Left, 0, targetPos); Target newTarget = targetPool.Take(targetData); sphereTargets.Add(newTarget); } }
public static void DrawTargetBone(TargetTransform target, Vector3 direction) { if (target.transform == null) { return; } if (target.confidence.rotation > 0.8F) { Debug.DrawRay(target.transform.position, target.transform.rotation * direction * target.length, Color.green); } else if (target.confidence.rotation > 0.6F) { Debug.DrawRay(target.transform.position, target.transform.rotation * direction * target.length, Color.yellow); } else if (target.confidence.rotation > 0F) { Debug.DrawRay(target.transform.position, target.transform.rotation * direction * target.length, Color.red); } //else // Debug.DrawRay(target.transform.position, target.transform.rotation * direction * target.length, Color.black); }
public void Start() { if (!TargetTransform) { Debug.LogError("No Target Transform for rope!"); return; } OriginTransform = transform; //_line = GetComponent<LineRenderer>(); //_line.SetPosition(0, OriginTransform.position); //_line.SetPosition(1, TargetTransform.position); _springJoint = GetComponent <SpringJoint2D>(); _springJoint.enabled = true; _springJoint.connectedBody = TargetTransform.GetComponent <Rigidbody2D>(); _fixedJoint = GetComponent <FixedJoint2D>(); _fixedJoint.enabled = true; if (transform.parent) { _fixedJoint.connectedBody = transform.parent.GetComponent <Rigidbody2D>(); } }
public override void OnInspectorGUI() { TargetTransform script = (TargetTransform)target; script.parentTransform = (Transform)EditorGUILayout.ObjectField("Parent Transform", script.parentTransform, typeof(Transform)); script.isPosition = EditorGUILayout.ToggleLeft("Position", script.isPosition); if (script.isPosition) { script.position = EditorGUILayout.Vector3Field("", script.position); } script.isRotation = EditorGUILayout.ToggleLeft("Rotation", script.isRotation); if (script.isRotation) { script.rotation = EditorGUILayout.Vector3Field("", script.rotation); } script.isScale = EditorGUILayout.ToggleLeft("Scale", script.isScale); if (script.isScale) { script.scale = EditorGUILayout.Vector3Field("", script.scale); } }
/// <summary> /// Executes the next step in the refinement process. /// </summary> private void NextStep() { // If we're already on the last step, just finish up if (currentStep == RayRefinementStep.Refinement) { FinishRefinement(); return; } // Increment the step currentStep++; // Execute switch (currentStep) { case RayRefinementStep.ModelOrigin: // Create the target CreateTarget(originPrefab, ref modelOrigin, currentStep.ToString()); // Parent the target modelOrigin.transform.SetParent(TargetTransform, worldPositionStays: true); break; case RayRefinementStep.ModelDirection: // Create the target CreateTarget(directionPrefab, ref modelDirection, currentStep.ToString()); // Parent the target modelDirection.transform.SetParent(TargetTransform, worldPositionStays: true); // Add line renderer modelLine = AddLine(modelDirection); break; case RayRefinementStep.PlacementOrigin: // Hide meshes? if (autoHideMeshes) { modelLine.enabled = false; this.gameObject.SetMeshesEnabled(enabled: false, inChildren: true); } // Create the target CreateTarget(originPrefab, ref placementOrigin, currentStep.ToString()); break; case RayRefinementStep.PlacementDirection: // Create the target CreateTarget(directionPrefab, ref placementDirection, currentStep.ToString()); // Add line renderer placementLine = AddLine(placementDirection); break; case RayRefinementStep.Refinement: // Re-show meshes? if (autoHideMeshes) { modelLine.enabled = true; this.gameObject.SetMeshesEnabled(enabled: true, inChildren: true); } // Get transform positions Vector3 modelOriginWorld = modelOrigin.transform.position; Vector3 modelDirectionWorld = modelDirection.transform.position; Vector3 placementOriginWorld = placementOrigin.transform.position; Vector3 placementDirectionWorld = placementDirection.transform.position; // Calculate the model angle float modelAngle = Mathf.Atan2(modelDirectionWorld.x - modelOriginWorld.x, modelDirectionWorld.z - modelOriginWorld.z) * Mathf.Rad2Deg; // Calculate the placement angle float placementAngle = Mathf.Atan2(placementDirectionWorld.x - placementOriginWorld.x, placementDirectionWorld.z - placementOriginWorld.z) * Mathf.Rad2Deg; // Calculate the model -> placement position offset Vector3 offset = placementOriginWorld - modelOriginWorld; // Calculate the model -> placement rotation offset float rotation = (placementAngle - modelAngle); // Update parent position to align origins TargetTransform.position += offset; // Update parent rotation, but around placement origin TargetTransform.RotateAround(placementOriginWorld, Vector3.up, rotation); // Finish refinement FinishRefinement(); break; default: Debug.LogError($"Unknown {nameof(RayRefinementStep)}: {currentStep}"); break; } }
void SetENBallTarget(GameObject newBall) { TargetTransform TgtTF = newBall.GetComponent <TargetTransform> (); TgtTF._Target = transform; }
public void AddToOptimizer(Transform optimizerTransform) { TargetTransform?.SetParent(optimizerTransform, true); }