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);
}
