private Vector3 NewWanderTarget(StateController controller)
{
Bounds territory = controller.gameObject.GetComponent <Crab>().territory;
float wanderThreshold = 8;
if (controller.GetComponent <Crab>().isTrained)
{
wanderThreshold = 2;
}
float wanderStep = 5;
// Randomly select an angle between 45 and 135 degrees (but in radians)
float angle = Random.Range(Mathf.PI / 4, Mathf.PI * 3 / 4);
Vector3 tempTarget = new Vector3(controller.transform.position.x + Mathf.Cos(angle) * wanderStep, controller.transform.position.y, controller.transform.position.z + Mathf.Sin(angle) * wanderStep);
int i = Random.Range(1, 4);
if (!territory.Contains(tempTarget))
{
tempTarget = new Vector3(controller.transform.position.x + Mathf.Cos(angle + (Mathf.PI * i / 2)) * wanderStep, controller.transform.position.y, controller.transform.position.z + Mathf.Sin(angle + (Mathf.PI * i / 2)) * wanderStep);
if (Vector3.Distance(tempTarget, territory.ClosestPoint(tempTarget)) > wanderThreshold)
{
tempTarget = territory.ClosestPoint(tempTarget);
}
}
controller.target = tempTarget;
return(controller.target);
}
public static GameObject GetCloserHand(GameObject agent, GameObject obj)
{
GameObject leftGrasper = agent.GetComponent <FullBodyBipedIK>().references.leftHand.gameObject;
GameObject rightGrasper = agent.GetComponent <FullBodyBipedIK>().references.rightHand.gameObject;
GameObject grasper;
Bounds bounds = Helper.GetObjectWorldSize((obj as GameObject));
// which hand is closer?
float leftToGoalDist =
(leftGrasper.transform.position - bounds.ClosestPoint(leftGrasper.transform.position)).magnitude;
float rightToGoalDist =
(rightGrasper.transform.position - bounds.ClosestPoint(rightGrasper.transform.position)).magnitude;
if (leftToGoalDist < rightToGoalDist)
{
grasper = leftGrasper;
}
else
{
grasper = rightGrasper;
}
// Debug.Log (grasper);
return(grasper);
}
/// <summary>
/// must be called on initialization
///
/// this must be called whenever an actors colder changes
/// (including when an actor is scaled)
/// </summary>
private void updateEquipPoints()
{
Bounds bounds = collider.bounds;
Vector3 centerPoint = bounds.center;
float offset = 0.1f;
equipPoint_Above = transform.InverseTransformPoint(bounds.ClosestPoint(centerPoint + new Vector3(0, 20f)) + new Vector3(0, offset));
equipPoint_Right = transform.InverseTransformPoint(bounds.ClosestPoint(centerPoint + new Vector3(20f, 0)) + new Vector3(offset, 0));
equipPoint_Below = transform.InverseTransformPoint(bounds.ClosestPoint(centerPoint + new Vector3(0, -20f)) + new Vector3(0, -offset));
equipPoint_Left = transform.InverseTransformPoint(bounds.ClosestPoint(centerPoint + new Vector3(-20f, 0)) + new Vector3(-offset, 0));
equipPoint_OnTopOf = transform.InverseTransformPoint(centerPoint);
}
private void moveEditCameraTargetToDirectorPostion()
{
Vector3 position = director.DefaultTarget.position;
if (boundsForCameraTarget.Contains(position))
{
EditCameraTarget.transform.position = position;
}
else
{
EditCameraTarget.transform.position = boundsForCameraTarget.ClosestPoint(position);
}
}
private void Update()
{
for (int i = 0; i < rats.Length; i++)
{
if (rats[i].enabled)
{
rats[i].transform.position = Vector3.MoveTowards(
rats[i].transform.position, end[i],
timeManager.WorldDeltaTime * 5f);
float dist = Vector3.Distance(rats[i].transform.position, end[i]);
if (dist < 0.2f)
{
rats[i].enabled = false;
}
}
else
{
//once every n seconds
const int n = 4;
if (Random.value < timeManager.WorldDeltaTime / n)
{
rats[i].enabled = true;
rats[i].transform.position = bounds.ClosestPoint(
bounds.center +
(Random.insideUnitSphere - Random.insideUnitSphere).normalized
* bounds.size.magnitude);
//a vector pointing from the start to a random point in the bounds
Vector3 line = (rats[i].transform.position - bounds.center).normalized *
bounds.size.magnitude + new Vector3(
bounds.extents.x * (Random.value - 0.5f),
0,
bounds.extents.z * (Random.value - 0.5f)) * 20;
end[i] = bounds.ClosestPoint(rats[i].transform.position + line);
line = rats[i].transform.position - end[i];
rats[i].transform.rotation = Quaternion.Euler(
rats[i].transform.rotation.eulerAngles.x,
(-Mathf.Atan2(line.z, line.x) * Mathf.Rad2Deg) + 90,
rats[i].transform.rotation.eulerAngles.z);
// rats[i].transform.rotation = Quaternion.LookRotation(line);
}
}
}
}
private bool MovingTowardsBounds()
{
if ((((Vector2)aiBase.transform.position + aiBase.aiMovement.direction) +
(Vector2)playArea.ClosestPoint(aiBase.transform.position)).magnitude <
((Vector2)aiBase.transform.position +
(Vector2)playArea.ClosestPoint(aiBase.transform.position)).magnitude)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Unity callback. Called once per frame after all Update calls.
/// </summary>
void LateUpdate()
{
foreach (Transform child in transform)
{
child.localPosition = _bounds.ClosestPoint(child.localPosition);
}
}
private void Move(BasicStateMachine controller)
{
Bounds b = controller.moveBounds.bounds;
if (controller.moveToPoint == new Vector2(-999, -999))
{
float xpos = Random.Range(b.min.x, b.max.x);
float ypos = Random.Range(b.min.y, b.max.y);
controller.moveToPoint = new Vector2(xpos, ypos);
}
controller.movement = Vector2.MoveTowards(controller.thisTransform.position, controller.moveToPoint, controller.moveSpeed * Time.fixedDeltaTime);
controller.movement = b.ClosestPoint(controller.movement);
controller.rigidBody.MovePosition(controller.movement);
if (controller.thisTransform.position.x < controller.moveToPoint.x)
{
controller.moveDirection = 1;
}
else
{
controller.moveDirection = -1;
}
}
/// <summary>
/// Return objects that are within <paramref name="maxDistance"/> of the specified position.
/// </summary>
/// <param name="position">The position.</param>
/// <param name="maxDistance">Maximum distance from the position to consider.</param>
/// <param name="result">List result.</param>
/// <returns>Objects within range.</returns>
public void GetNearby(ref Vector3 position, float maxDistance, List <T> result)
{
// Does the node intersects with the sphere of center = position and radius = maxDistance?
float sqrMaxDistance = maxDistance * maxDistance;
if ((bounds.ClosestPoint(position) - position).sqrMagnitude > sqrMaxDistance)
{
return;
}
// Check against any objects in this node
for (int i = 0; i < objects.Count; i++)
{
if ((position - objects[i].Pos).sqrMagnitude <= sqrMaxDistance)
{
result.Add(objects[i].Obj);
}
}
// Check children
if (children != null)
{
for (int i = 0; i < 8; i++)
{
children[i].GetNearby(ref position, maxDistance, result);
}
}
}
void FixedUpdate()
{
// If player input has said to accelerate on last Update(), accelerate.
if (currentlyAccelerating)
{
// Calculate mass.
float differentialEmittedMass = massSliderProgress * maxEmittedMassPerSecondFraction * _rigidbody.mass * Time.fixedDeltaTime;
float newMass = _rigidbody.mass - differentialEmittedMass;
// Add the emitted mass to the score.
score += differentialEmittedMass;
// Get mouse position to target.
Vector3 targetDirection = GetMouseTargetDirection();
// Calculate velocity.
Vector3 newVelocity = (_rigidbody.mass * _rigidbody.velocity - differentialEmittedMass * targetDirection * emissionSpeed) / newMass;
// Apply mass and velocity.
_rigidbody.mass = newMass;
_rigidbody.velocity = newVelocity;
}
// If player is not in bounds, apply spring force to return player to bounds.
if (!playerBounds.Contains(transform.position))
{
// Get normalized direction vector from player to closest point on bounds and scale by spring stiffness.
Vector3 springForce = springStiffness * Vector3.Normalize(playerBounds.ClosestPoint(transform.position) - transform.position);
_rigidbody.AddForce(springForce);
}
}
// Update is called once per frame
void LateUpdate()
{
Bounds bounds = BlobManager.OverallGooBounds;
float screenRatio = Screen.width / (float)Screen.height;
float largerSide = Mathf.Max(bounds.size.x, bounds.size.z * screenRatio);
float heightAbove = Mathf.Atan(_camera.fieldOfView * 0.5f) * largerSide;
_transform.position = bounds.center + Vector3.up * heightAbove;
_transform.rotation = Quaternion.LookRotation(bounds.center - transform.position, Vector3.forward);
bounds.Encapsulate(Vector3.down);
Vector3 near = bounds.ClosestPoint(_transform.position);
Vector3 far = bounds.center - (near - bounds.center);
float nearPos = Vector3.Dot((near - transform.position), _transform.forward);
float farPos = Vector3.Dot((far - transform.position), _transform.forward);
_camera.nearClipPlane = Mathf.Min(nearPos, farPos) - 1f;
_camera.farClipPlane = Mathf.Max(nearPos, farPos) + 1f;
}
// private
private void OnUpdate(Vector3 cameraPosition)
{
// check if we need to populate or depopulate
// TODO: manage populate/depopulate
// get proper distance to the camera
var boundsPoint = Bounds.ClosestPoint(cameraPosition);
var distance = Vector3.Distance(boundsPoint, cameraPosition);
if (!IsPopulated && CanPopulate)
{
// try populate
if (distance < Bounds.size.x * 2.0f)
{
Populate();
}
}
if (IsPopulated && CanDepopulate)
{
// try depopulate
if (distance > Bounds.size.x * 2.25f + Size * 4.0f)
{
Depopulate();
}
}
}
public static bool IsHited(BoxCollider2D bulletCollider, BoxCollider2D fishCollider, out float x, out float y, out float z)
{
x = 0;
y = 0;
z = 0;
bool bHited = false;
if (bulletCollider == null || fishCollider == null)
{
return(bHited);
}
Bounds bulletBounds = bulletCollider.bounds;
Vector3 target_old_center = fishCollider.bounds.center;
Vector3 targetCenter = new Vector3(target_old_center.x, target_old_center.y, bulletBounds.center.z);
Bounds target_new_bounds = new Bounds(targetCenter, fishCollider.bounds.size);
bHited = bulletBounds.Intersects(target_new_bounds);
Vector3 collision_pos = bulletBounds.ClosestPoint(targetCenter);
collision_pos.z = bulletCollider.bounds.center.z;
x = collision_pos.x;
y = collision_pos.y;
z = collision_pos.z;
return(bHited);
}
/// <summary>
/// 获取一个滚动物体在区域内的位置。
/// 如果物体不在区域内，则获取将物体以最短距离挪动到区域内后的位置
/// </summary>
public bool GetInAreaPosition(Vector3 objPos, ScrollObject obj, out Vector3 pos)
{
Vector3 min, max; Bounds2Local(objPos, obj.bounds, out min, out max);
Vector3[] boundsVertexs = CalculateBoundsVertexs(min, max);
if (LocalContains(Area, boundsVertexs))//滚动物体没有超出范围
{
pos = objPos;
return(true);
}
//处理滚动物体超出范围的情况
Vector3 moveDistance = Vector3.zero;
foreach (Vector3 v in boundsVertexs)
{
if (!Area.Contains(v)) //该点超出范围
{
Vector3 n = Area.ClosestPoint(v); //将该点限制在范围内
Vector3 offset = n - v; //移动进包围盒偏移量
if (Math.Abs(offset.x) > Math.Abs(moveDistance.x))
{
moveDistance.x = offset.x;
}
//if (Math.Abs(offset.y) > Math.Abs(moveDistance.y)) moveDistance.y = offset.y;
//if (Math.Abs(offset.z) > Math.Abs(moveDistance.z)) moveDistance.z = offset.z;
}
}
pos = objPos + moveDistance;
return(false);
}
private void DoOriginEditing()
{
ReflectionProbe reflectionProbe = (ReflectionProbe)this.target;
Vector3 position = reflectionProbe.transform.position;
Vector3 size = reflectionProbe.size;
Vector3 center = reflectionProbe.center + position;
EditorGUI.BeginChangeCheck();
Vector3 vector = Handles.PositionHandle(position, Quaternion.identity);
bool flag = EditorGUI.EndChangeCheck();
if (!flag)
{
vector = position;
flag = ((this.m_OldTransformPosition - vector).magnitude > 1E-05f);
if (flag)
{
center = reflectionProbe.center + this.m_OldTransformPosition;
}
}
if (flag)
{
Undo.RecordObject(reflectionProbe, "Modified Reflection Probe Origin");
Bounds bounds = new Bounds(center, size);
vector = bounds.ClosestPoint(vector);
Vector3 vector2 = vector;
reflectionProbe.transform.position = vector2;
this.m_OldTransformPosition = vector2;
reflectionProbe.center = bounds.center - vector;
EditorUtility.SetDirty(this.target);
}
}
void FixedUpdate()
{
foreach (GameObject asteroid in HelperFunctions.FindGameObjectsOnLayer("GravityObjects"))
{
Rigidbody asteroidRigidbody = asteroid.GetComponent <Rigidbody>();
// Do asteroid bounds checking to reflect the velocity.
if (!asteroidBounds.Contains(asteroid.transform.position))
{
// Get the required vectors for calculating reflection vector.
Vector3 closestPoint = asteroidBounds.ClosestPoint(asteroidRigidbody.position);
Vector3 reflectionNormal = Vector3.Normalize(closestPoint - asteroidRigidbody.position);
Vector3 direction = Vector3.Normalize(asteroidRigidbody.velocity);
// Set the position to the closestpoint on the bounds and the velocity to the dampened reflection.
asteroidRigidbody.position = closestPoint;
Vector3 reflection = 2 * Vector3.Dot(reflectionNormal, -direction) * reflectionNormal + direction;
asteroidRigidbody.velocity = reflection * asteroidRigidbody.velocity.magnitude;
}
// Do player bounds checking and apply constant force.
if (!cameraBounds.Contains(asteroid.transform.position))
{
Vector3 force = Time.fixedDeltaTime * asteroidRigidbody.mass * boundsForceMagnitude * Vector3.Normalize(cameraBounds.ClosestPoint(asteroidRigidbody.position) - asteroidRigidbody.position);
asteroidRigidbody.AddForce(force);
}
}
}
private void DoOriginEditing()
{
ReflectionProbe target = (ReflectionProbe)this.target;
Vector3 position = target.transform.position;
Vector3 size = target.size;
Vector3 center = target.center + position;
EditorGUI.BeginChangeCheck();
Vector3 point = Handles.PositionHandle(position, Quaternion.identity);
bool flag = EditorGUI.EndChangeCheck();
if (!flag)
{
point = position;
Vector3 vector5 = this.m_OldTransformPosition - point;
flag = vector5.magnitude > 1E-05f;
if (flag)
{
center = target.center + this.m_OldTransformPosition;
}
}
if (flag)
{
Undo.RecordObject(target, "Modified Reflection Probe Origin");
Bounds bounds = new Bounds(center, size);
point = bounds.ClosestPoint(point);
Vector3 vector6 = point;
target.transform.position = vector6;
this.m_OldTransformPosition = vector6;
target.center = bounds.center - point;
EditorUtility.SetDirty(this.target);
}
}
void KeepInBlockBounds()
{
if (blockBounds == null)
{
return;
}
Bounds b = rollable.GetComponent <BoxCollider>().bounds;
//b.size -= new Vector3(character.radius, 0, character.radius);
Vector3 pos = transform.position;
pos.y = b.center.y;
Vector3 dirOfMovement = (pos - b.center).normalized;
// are we in the block area
if (b.Contains(pos) == false)
{
// are we in a walkable area?
if (IsWalkable(pos) == false)
{
// snap into position
pos = b.ClosestPoint(pos);
Vector3 diff = pos - transform.position;
diff.y = 0;
MovePlayer(diff);
}
}
}
public List <Vector4> Update(Vector3 viewerPositon)
{
var dist = Vector3.Distance(viewerPositon, bounds.ClosestPoint(viewerPositon));
if (parentChunk != null)
{
var distParent = Vector3.Distance(viewerPositon, parentChunk.GetBounds().ClosestPoint(viewerPositon));
if (distParent > parentChunk.GetScale() * chunkSize)
{
parentChunk.MergeChunk();
return(positionsList);
}
}
if (scale * chunkSize > dist)
{
SubDivide(viewerPositon);
}
else
{
positionsList.Clear();
directionList.Clear();
positionsList.Add(positionToDraw);
directionList.Add(directionX);
}
return(positionsList);
}
void DoOriginEditing()
{
ReflectionProbe p = (ReflectionProbe)target;
Vector3 transformPosition = p.transform.position;
Vector3 size = p.size;
EditorGUI.BeginChangeCheck();
Vector3 newPostion = Handles.PositionHandle(transformPosition, GetLocalSpaceRotation(p));
bool changed = EditorGUI.EndChangeCheck();
if (changed || m_OldLocalSpace != GetLocalSpace((ReflectionProbe)target))
{
Vector3 localNewPosition = m_OldLocalSpace.inverse.MultiplyPoint3x4(newPostion);
Bounds b = new Bounds(p.center, size);
localNewPosition = b.ClosestPoint(localNewPosition);
Undo.RecordObject(p.transform, "Modified Reflection Probe Origin");
p.transform.position = m_OldLocalSpace.MultiplyPoint3x4(localNewPosition);
Undo.RecordObject(p, "Modified Reflection Probe Origin");
p.center = GetLocalSpace(p).inverse.MultiplyPoint3x4(m_OldLocalSpace.MultiplyPoint3x4(p.center));
EditorUtility.SetDirty(target);
UpdateOldLocalSpace();
}
}
public void DamageText(int value, Vector3 damagePos, Bounds bounds)
{
CombatText text = GetText();
text.position = bounds.ClosestPoint(damagePos);
text.velocity = (bounds.center - damagePos).normalized * 300;
text.drag = 0.9f;
text.transform.localPosition = Vector3.zero;
text.uiText.color = damageColor;
text.bounds = bounds;
text.worldSpace = true;
text.uiText.text = "" + value;
text.uiText.font = damageFont;
if (value < 300)
{
text.fadeSpeed = 100;
text.uiText.fontSize = (int)(30 * screenScale);
}
else
{
text.fadeSpeed = 60;
text.uiText.fontSize = (int)(40 * screenScale);
}
}
private void Update()
{
if (!worldBounds.Contains(target.position))
{
target.position = worldBounds.ClosestPoint(target.position);
}
}
// Update is called once per frame
void Update()
{
if (!active)
{
return;
}
foreach (Player p in ReInput.players.Players)
{
if (p.GetButtonDown("Cancel"))
{
manager.ChangeToScreen(GameSetupManager.Screen.TEAMSELECT);
}
}
cursor.position += (Vector3)player.GetAxis2DRaw("Move Horizontal", "Move Vertical") * cursorSpeed;
cursor.position = menuBounds.ClosestPoint(cursor.position);
if (player.GetButtonDown("Confirm"))
{
PointerEventData data = new PointerEventData(eventSystem);
data.position = cursor.position;
List <RaycastResult> results = new List <RaycastResult>();
raycaster.Raycast(data, results);
if (results.Count > 0)
{
LoadSceneButtonController sceneLoader = results[0].gameObject.GetComponent <LoadSceneButtonController>();
if (sceneLoader)
{
sceneLoader.LoadNewScene();
}
}
}
}
static void Handle_OriginEditing(HDReflectionProbeUI s, SerializedHDReflectionProbe sp, Editor o)
{
var p = (ReflectionProbe)sp.so.targetObject;
var transformPosition = p.transform.position;
var size = p.size;
EditorGUI.BeginChangeCheck();
var newPostion = Handles.PositionHandle(transformPosition, HDReflectionProbeEditorUtility.GetLocalSpaceRotation(p));
var changed = EditorGUI.EndChangeCheck();
if (changed || s.oldLocalSpace != HDReflectionProbeEditorUtility.GetLocalSpace(p))
{
var localNewPosition = s.oldLocalSpace.inverse.MultiplyPoint3x4(newPostion);
var b = new Bounds(p.center, size);
localNewPosition = b.ClosestPoint(localNewPosition);
Undo.RecordObject(p.transform, "Modified Reflection Probe Origin");
p.transform.position = s.oldLocalSpace.MultiplyPoint3x4(localNewPosition);
Undo.RecordObject(p, "Modified Reflection Probe Origin");
p.center = HDReflectionProbeEditorUtility.GetLocalSpace(p).inverse.MultiplyPoint3x4(s.oldLocalSpace.MultiplyPoint3x4(p.center));
EditorUtility.SetDirty(p);
s.UpdateOldLocalSpace(p);
}
}
private void ClampTarget()
{
float distanceToTarget = Vector3.Distance(transform.position, ArmTarget.position);
if (distanceToTarget > maxRange)
{
Vector3 dirToTarget = (ArmTarget.position - transform.position).normalized;
ArmTarget.position = new Vector3(
transform.position.x + dirToTarget.x * maxRange,
ArmTarget.position.y,
transform.position.z + dirToTarget.z * maxRange);
}
float flatDistanceToTarget =
Vector3.Distance(new Vector3(transform.position.x, 0, transform.position.z),
new Vector3(armIKSolver.Target.position.x, 0, armIKSolver.Target.position.z));
if (flatDistanceToTarget < minRange)
{
Vector3 dirToTarget = (ArmTarget.position - transform.position);
dirToTarget.y = 0;
dirToTarget.Normalize();
ArmTarget.position = new Vector3(
transform.position.x + dirToTarget.x * minRange,
ArmTarget.position.y,
transform.position.z + dirToTarget.z * minRange);
}
if (!boundingBox.Contains(ArmTarget.position))
{
ArmTarget.position = boundingBox.ClosestPoint(ArmTarget.position);
}
}
void Update()
{
if (!bounds.Contains(transform.position))
{
transform.position = bounds.ClosestPoint(transform.position);
}
}
public static Vector2 ClosestPointOnBounds(this Bounds bounds, Vector2 p)
{
//If point is outside bounds, just use this:
if (!bounds.Contains(p))
{
return(bounds.ClosestPoint(p));
}
//Point is inside bounds, so check distance to find closest point
List <Vector2> boundPos = new List <Vector2>();
boundPos.Add(new Vector2(bounds.min.x, p.y));
boundPos.Add(new Vector2(bounds.max.x, p.y));
boundPos.Add(new Vector2(p.x, bounds.min.y));
boundPos.Add(new Vector2(p.x, bounds.max.y));
Vector2 closestPos = boundPos[0];
foreach (Vector2 bpos in boundPos)
{
if (Vector2.Distance(p, bpos) < Vector2.Distance(p, closestPos))
{
closestPos = bpos;
}
}
return(closestPos);
}
public static Vector3 ProjectPoint(this Bounds bounds, Vector3 point, Vector3 origin)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if (bounds.Contains(point))
{
return(point);
}
Ray val = default(Ray);
val._002Ector(origin, origin - point);
float num = default(float);
if (!bounds.IntersectRay(val, ref num))
{
return(bounds.ClosestPoint(point));
}
return(val.GetPoint(num));
}
/// <inheritdoc />
public override void Apply(TacticalCamera tCamera)
{
if (!boundingBox.Contains(tCamera.transform.position))
{
tCamera.transform.position = boundingBox.ClosestPoint(tCamera.transform.position);
}
}
public void Update()
{
if (Input.GetMouseButtonDown(0))
{
_pressedPosition = Input.mousePosition;
}
if (Input.GetMouseButton(0))
{
var currentPosition = Input.mousePosition;
var p0 = _camera.ScreenToWorldPoint(_pressedPosition);
var p1 = _camera.ScreenToWorldPoint(currentPosition);
var difference = p1 - p0;
_camera.transform.position = _camera.transform.position + difference * _speed;
_pressedPosition = currentPosition;
}
if (_truncatePosition)
{
//var sp = _camera.WorldToScreenPoint(_camera.transform.position);
var sp = _camera.transform.position;
var p = _bounds.ClosestPoint(sp);
p.z = sp.z;
_camera.transform.position = p;
// _camera.transform.position = _camera.ScreenToWorldPoint(p);
}
}
