public override void Effect()
{
Debug.Log ("EFFECT V !!!");
Ray ray = new Ray();
RaycastHit rHit;
ray.origin = hand.transform.position;
ray.direction = hand.transform.forward;
Physics.Raycast (ray, out rHit);
GameObject lightning = (GameObject)MonoBehaviour.Instantiate(lightningObject);
//lightning.transform.position = (hand.transform.position + rHit.transform.position)/2;
lightning.transform.position = (hand.transform.position + Vector3.forward * 10)/2;
lightning.transform.position += Vector3.down * 5;
//Vector3 pathBetween = rHit.transform.position - hand.transform.position;
Vector3 pathBetween = Vector3.forward * 100;
lightning.transform.eulerAngles = new Vector3(90,180 + Mathf.Rad2Deg * Mathf.Atan( (float)pathBetween.x / pathBetween.z ),180 );
lightning.transform.localScale = pathBetween.magnitude/80 * Vector3.one;
MonoBehaviour.Destroy ( lightning , 10f);
}
protected virtual void Update()
{
// Retrieve the frustum planes from the camera.
frustumPlanes = GeometryUtility.CalculateFrustumPlanes(Camera.main);
// Determine if the Tagalong needs to move based on whether its
// BoxCollider is in or out of the camera's view frustum.
Vector3 tagalongTargetPosition;
if (CalculateTagalongTargetPosition(transform.position, out tagalongTargetPosition))
{
// Derived classes will use the same Interpolator and may have
// adjusted its PositionUpdateSpeed for some other purpose.
// Restore the value we care about and tell the Interpolator
// to move the Tagalong to its new target position.
interpolator.PositionPerSecond = PositionUpdateSpeed;
interpolator.SetTargetPosition(tagalongTargetPosition);
}
else if (!interpolator.Running && EnforceDistance)
{
// If the Tagalong is inside the camera's view frustum, and it is
// supposed to stay a fixed distance from the camera, force the
// tagalong to that location (without using the Interpolator).
Ray ray = new Ray(Camera.main.transform.position, transform.position - Camera.main.transform.position);
transform.position = ray.GetPoint(TagalongDistance);
}
}
void Start()
{
// bboxFollower = GetComponent<BoundingBoxFollower>();
boneFollower = GetComponent<BoneFollower>();
zeRay = new Ray();
}
private IEnumerator CheckAlignment()
{
// Continue looping until the game is no longer running.
while (m_IsGameRunning)
{
// If there is a current ring, set it to be unaligned by default.
if (m_CurrentRing)
m_CurrentRing.ShipAligned = false;
// Create a ray forward from the flyer's current position.
Ray ray = new Ray (transform.position, Vector3.forward);
RaycastHit hit;
// Spherecast along the ray.
if (Physics.SphereCast (ray, m_Radius, out hit))
{
// Try to find a ring on the hit object.
Ring ring = hit.transform.GetComponent<Ring> ();
// If it is a ring...
if (ring)
{
// ... set it as the current ring and the flyer is aligned with it.
m_CurrentRing = ring;
m_CurrentRing.ShipAligned = true;
}
}
// Wait until next frame.
yield return null;
}
}
public override void OnCharacterCollided(ControllerColliderHit hit, Transform other)
{
base.OnCharacterCollided(hit, other);
if (Colliding)
return;
//check if hit point beneath player
var dir = (hit.point - other.position).normalized;
if (dir.y < -0.9)
CollisionType = DaggerfallAction.TriggerTypes.WalkOn;
else
{
if (thisAction.TriggerFlag == DaggerfallConnect.DFBlock.RdbTriggerFlags.Collision01)
{
Vector3 origin = new Vector3(hit.controller.transform.position.x, hit.controller.transform.position.y - hit.controller.height / 2, hit.controller.transform.position.z);
Ray ray = new Ray(origin, Vector3.down);
RaycastHit hitInfo;
//if hit not below controller, see if player standing on this action object w/ raycast & if action flag is Collision01 (walk on)
//set trigger type & activate if so - to avoid player being able to push against wall to avoid
if (hit.collider.Raycast(ray, out hitInfo, hit.controller.skinWidth))
CollisionType = DaggerfallAction.TriggerTypes.WalkOn;
else
CollisionType = DaggerfallAction.TriggerTypes.WalkInto;
}
else
CollisionType = DaggerfallAction.TriggerTypes.WalkInto;
}
Colliding = true;
}
void CastRayFromBoundObject()
{
hits.Clear();
//CAST RAY
Vector3 v = boundObject.position;
Quaternion q = boundObject.rotation;
ray = new Ray(v, q * Vector3.forward);
hits.AddRange(Physics.RaycastAll(ray, interactDistance));
eventData.previousRaycast = eventData.currentRaycast;
if (hits.Count == 0) {
eventData.currentRaycast = null;
return;
}
//FIND THE CLOSEST OBJECT
RaycastHit minHit = hits[0];
for (int i = 0; i < hits.Count; i++) {
if (hits[i].distance < minHit.distance) {
minHit = hits[i];
}
}
//MAKE SURE CLOSEST OBJECT IS INTERACTABLE
if (interactTag != null && interactTag.Length > 1 && !minHit.transform.tag.Equals(interactTag)) {
eventData.currentRaycast = null;
return;
} else {
eventData.currentRaycast = minHit.transform.gameObject;
}
}
private void DropToNearestFloor(bool withBlink)
{
if (enableTeleport && eyeCamera.transform.position.y > this.transform.position.y)
{
//send a ray down to find the closest object to stand on
Ray ray = new Ray(eyeCamera.transform.position, -transform.up);
RaycastHit rayCollidedWith;
bool rayHit = Physics.Raycast(ray, out rayCollidedWith);
float floorY = eyeCamera.transform.position.y - rayCollidedWith.distance;
if (rayHit && ValidLocation(rayCollidedWith.transform) && !FloorIsGrabbedObject(rayCollidedWith) && (MeshYChanged(rayCollidedWith, floorY) || CurrentFloorChanged(rayCollidedWith)))
{
currentFloor = rayCollidedWith.transform.gameObject;
currentRayDownY = floorY;
if (withBlink && !rayCollidedWith.transform.GetComponent<MeshCollider>())
{
Blink(blinkTransitionSpeed);
}
Vector3 newPosition = new Vector3(this.transform.position.x, floorY, this.transform.position.z);
var teleportArgs = new DestinationMarkerEventArgs
{
destinationPosition = newPosition,
distance = rayCollidedWith.distance,
enableTeleport = true,
target = currentFloor.transform
};
OnTeleporting(gameObject, teleportArgs);
SetNewPosition(newPosition, currentFloor.transform);
OnTeleported(gameObject, teleportArgs);
}
}
}
void Update()
{
_ray = new Ray(transform.position, transform.forward);
if (Physics.Raycast(_ray, out _hit, interactionRange))
{
Interactable i = _hit.transform.GetComponent<Interactable>();
if (i)
{
if (_interactableObject != null && !i.Equals(_interactableObject))
{
_interactableObject.interacting = false;
this.interacting = false;
}
_interactableObject = _hit.transform.GetComponent<Interactable>();
this.interacting = true;
_interactableObject.interacting = true;
_interactableObject.interactPosition = _hit.point;
}
}
else if (_interactableObject)
{
_interactableObject.interacting = false;
this.interacting = false;
_interactableObject = null;
}
}
void Update() {
Vector3 forward = RaycastSource.TransformDirection(Vector3.forward);
bool didHit = Physics.Raycast(RaycastSource.position, forward, out hit, MaxDistance, Collidable);
if (ObjectToPosition != null) {
if (didHit) {
ObjectToPosition.transform.position = hit.point;
lastLegalPlane.SetNormalAndPosition(Vector3.up,
new Vector3(0, ObjectToPosition.transform.position.y, 0));
} else {
Ray castRay = new Ray(RaycastSource.transform.position, RaycastSource.transform.forward);
float rayDistance;
if (lastLegalPlane.Raycast(castRay, out rayDistance)) {
ObjectToPosition.transform.position = castRay.GetPoint(rayDistance);
}
}
}
if (UseLineRenderer) {
if (didHit) {
if (Line.gameObject.activeSelf == false) {
Line.gameObject.SetActive(true);
}
Line.SetPosition(0, RaycastSource.transform.position);
Line.SetPosition(1, ObjectToPosition.transform.position);
} else if (Line.gameObject.activeSelf == true)
Line.gameObject.SetActive(false);
}
}
private float GetHitDistance(Ray ray)
{
var hitDistance = float.MaxValue;
if (canvas.renderMode != RenderMode.ScreenSpaceOverlay && blockingObjects != BlockingObjects.None)
{
var maxDistance = Vector3.Distance(ray.origin, canvas.transform.position);
if (blockingObjects == BlockingObjects.ThreeD || blockingObjects == BlockingObjects.All)
{
RaycastHit hit;
Physics.Raycast(ray, out hit, maxDistance);
if (hit.collider && !hit.collider.GetComponent<VRTK_PlayerObject>())
{
hitDistance = hit.distance;
}
}
if (blockingObjects == BlockingObjects.TwoD || blockingObjects == BlockingObjects.All)
{
RaycastHit2D hit = Physics2D.Raycast(ray.origin, ray.direction, maxDistance);
if (hit.collider != null && !hit.collider.GetComponent<VRTK_PlayerObject>())
{
hitDistance = hit.fraction * maxDistance;
}
}
}
return hitDistance;
}
void Update ()
{
if (Showtime) {
if (Time.time >= timeTemp + Delay) {
Ray ray = new Ray (this.transform.position + new Vector3 (Random.Range (-RandomSize, RandomSize), 0, Random.Range (-RandomSize, RandomSize)), -Vector3.up);
RaycastHit hit;
if (Physics.Raycast (ray, out hit, 100))
positionLook = hit.point;
Quaternion look = Quaternion.LookRotation ((positionLook - this.transform.position).normalized);
look.eulerAngles = new Vector3 (0, look.eulerAngles.y, 0);
this.transform.rotation = look;
if (RandomSkill) {
Index = Random.Range (0, Skills.Length);
} else {
Index += 1;
}
Deploy ();
timeTemp = Time.time;
}
} else {
Aim ();
if (Input.GetMouseButtonDown(0)) {
Deploy ();
}
}
KeyUpdate();
}
void OnMouseOver() // event souris dessus
{
ray = Camera.main.ScreenPointToRay(Input.mousePosition);
Physics.Raycast(ray, out hit, 100);
if (Input.GetKeyDown(KeyCode.Mouse0))
{
if (!hit.Equals(null))
{
if (hit.collider == myCollider) // Collision clic
{
// myMenu.update_Color(myColor);
// Change la couleur des valeurs -> est maintenant directement géré depuis le updateValuesPlayer du playerController
GetComponent<Transform>().parent.parent.gameObject.GetComponent<BasicPlayerController>().updateValuesPlayer(myColor);
/*
if (PhotonNetwork.inRoom) {
GetComponent<Transform> ().parent.parent.gameObject.GetComponent<PlayerController> ().updateValuesPlayer (myColor);
} else {
GetComponent<Transform>().parent.parent.gameObject.GetComponent<Player_controller>().updateValuesPlayer(myColor);
}*/
transform.localScale -= new Vector3(0.02f, 0.02f, 0.02f);
}
}
}
if (Input.GetKeyUp(KeyCode.Mouse0))
{
transform.localScale += new Vector3(0.02f, 0.02f, 0.02f);
}
}
public override void OnStart()
{
RaycastHit hit;
int raycastCount = 0;
var direction = transform.forward;
float step = 0;
// Keep firing a ray until too many rays have been fired
while (raycastCount < maxRaycasts.Value) {
var ray = new Ray(transform.position, direction);
if (Physics.Raycast(ray, out hit, maxCoverDistance.Value, availableLayerCovers.value)) {
// A suitable agent has been found. Find the opposite side of that agent by shooting a ray in the opposite direction from a point far away
if (hit.collider.Raycast(new Ray(hit.point - hit.normal * maxCoverDistance.Value, hit.normal), out hit, Mathf.Infinity)) {
coverPoint = hit.point;
break;
}
}
// Keep sweeiping along the y axis
step += rayStep.Value;
direction = Quaternion.Euler(0, 0, transform.eulerAngles.z + step) * Vector3.up;
raycastCount++;
}
SetDestination(Target());
base.OnStart();
}
public static bool RaycastSmoke(Ray ray)
{
if(!CMDropper.smokePool)
{
return false;
}
for(int i = 0; i < CMDropper.smokePool.size; i++)
{
Transform smokeTf = CMDropper.smokePool.GetPooledObject(i).transform;
if(smokeTf.gameObject.activeInHierarchy)
{
Plane smokePlane = new Plane((ray.origin-smokeTf.position).normalized, smokeTf.position);
float enter;
if(smokePlane.Raycast(ray, out enter))
{
float dist = (ray.GetPoint(enter)-smokeTf.position).magnitude;
if(dist < 16)
{
return true;
}
}
}
}
return false;
}
private void Update()
{
InteractionText.text = "";
RaycastHit hit;
var cam = UnityEngine.Camera.main.transform;
var forward = cam.forward;
var position = cam.position;
var ray = new Ray(position, forward);
if (Physics.Raycast(ray, out hit))
{
var interaction = hit.collider.GetComponent<IInteractable>();
if (interaction != null && Vector3.Distance(transform.position, hit.collider.transform.position) < InteractionDistance)
{
if (Input.GetKeyDown(KeyCode.E))
{
interaction.Interact();
}
else
{
InteractionText.text = "Press E to interact";
}
}
}
}
// Update is called once per frame
public override void OnUpdate()
{
var vrcam = SteamVR_Render.Top();
GameObject go = Fsm.GetOwnerDefaultTarget(gazeObject);
Ray r = new Ray(vrcam.transform.position, vrcam.transform.forward);
Plane p = new Plane(vrcam.transform.forward, go.transform.position);
float enter = 0.0f;
if (p.Raycast(r, out enter))
{
Vector3 intersect = vrcam.transform.position + vrcam.transform.forward * enter;
float dist = Vector3.Distance(intersect, go.transform.position);
//Debug.Log("Gaze dist = " + dist);
if (dist < gazeInCutoff.Value && !isInGaze.Value)
{
isInGaze.Value = true;
GazeEventArgsPlaymaker e;
e.distance = dist;
OnGazeOn(e);
}
else if (dist >= gazeOutCutoff.Value && isInGaze.Value)
{
isInGaze.Value = false;
GazeEventArgsPlaymaker e;
e.distance = dist;
OnGazeOff(e);
}
}
}
public static Vector2 ClosestPointToRay(Ray ray, Vector2 point)
{
//http://pastie.org/1066490
var t = Vector2.Dot(point - (Vector2) ray.origin, ray.direction);
return ray.GetPoint(t);
}
/// <summary>
/// Updates the StableHeadPosition and StableHeadRotation based on GazeSample values.
/// Call this method with Raycasthit parameters to get stable values.
/// </summary>
/// <param name="position">Position value from a RaycastHit point.</param>
/// <param name="rotation">Rotation value from a RaycastHit rotation.</param>
public void UpdateHeadStability(Vector3 position, Quaternion rotation)
{
Vector3 gazePosition = position;
Vector3 gazeDirection = rotation * Vector3.forward;
positionRollingStats.AddSample(gazePosition);
directionRollingStats.AddSample(gazeDirection);
float lerpPower = unstabalizedLerpFactor;
if (positionRollingStats.ActualSampleCount > minimumSamplesRequiredToStabalize && // we have enough samples and...
(positionRollingStats.CurrentStandardDeviation > positionStandardDeviationReset || // the standard deviation of positions is high or...
directionRollingStats.CurrentStandardDeviation > directionStandardDeviationReset)) // the standard deviation of directions is high
{
// We've detected that the user's gaze is no longer fixed, so stop stabalizing so that gaze is responsive.
//Debug.LogFormat("Reset {0} {1} {2} {3}", positionRollingStats.standardDeviation, positionRollingStats.standardDeviationsAway, directionRollignStats.standardDeviation, directionRollignStats.standardDeviationsAway);
positionRollingStats.Reset();
directionRollingStats.Reset();
}
else if (positionRollingStats.ActualSampleCount > minimumSamplesRequiredToStabalize)
{
// We've detected that the user's gaze is fairly fixed, so start stabalizing. The more fixed the gaze the less the cursor will move.
lerpPower = stabalizedLerpBoost * (positionRollingStats.CurrentStandardDeviation + directionRollingStats.CurrentStandardDeviation);
}
StableHeadPosition = Vector3.Lerp(StableHeadPosition, gazePosition, lerpPower);
StableHeadRotation = Quaternion.LookRotation(Vector3.Lerp(StableHeadRotation * Vector3.forward, gazeDirection, lerpPower));
StableHeadRay = new Ray(StableHeadPosition, StableHeadRotation * Vector3.forward);
}
private void UpdatePointer() {
bool handled = true;
pointerRay = new Ray(transform.position, transform.forward);
if (InteractedObject != null) {
ExecuteEvents.ExecuteHierarchy<IRemoteInputEventHandler>(InteractedObject, null,
(x, y) => x.OnRemoteOrientation(out handled, transform));
LaserPointer.PointerTarget = TargetedObject.transform.position;
if (!handled) {
InteractedObject = null;
}
} else if (Physics.Raycast(pointerRay, out pointerHit, PointerDistance)) {
if (ExecuteEvents.ExecuteHierarchy<IRemoteInputEventHandler>(pointerHit.collider.gameObject, null,
(x, y) => x.OnRemotePointEnter(out handled))) {
if (TargetedObject != null && !TargetedObject.Equals(pointerHit.collider.gameObject)) {
ExecuteEvents.Execute<IRemoteInputEventHandler>(TargetedObject, null,
(x, y) => x.OnRemotePointExit(out handled));
}
TargetedObject = pointerHit.collider.gameObject;
} else if (TargetedObject != null) {
ExecuteEvents.ExecuteHierarchy<IRemoteInputEventHandler>(TargetedObject, null,
(x, y) => x.OnRemotePointExit(out handled));
TargetedObject = null;
}
LaserPointer.PointerTarget = pointerHit.point;
} else {
LaserPointer.PointerTarget = transform.position + transform.forward * PointerDistance;
if (TargetedObject != null) {
ExecuteEvents.ExecuteHierarchy<IRemoteInputEventHandler>(TargetedObject, null,
(x, y) => x.OnRemotePointExit(out handled));
TargetedObject = null;
}
}
}
public IEnumerator FollowMouse(GameObject _item)
{
Debug.Log("follow mouse started");
while (Input.GetMouseButton(0) == true)
{
float _mouseXR = (Mathf.Round(Input.mousePosition.x * 2)) / 2;
float _mouseYR = (Mathf.Round(Input.mousePosition.y * 2)) / 2;
Vector3 _mouseVR = new Vector3(_mouseXR, _mouseYR , 0.0f);
_item.transform.position = _mouseVR * Time.deltaTime;
}
Debug.Log ("Leaving loop");
Debug.Log ("checking underneath");
RaycastHit _rayHit;
Ray _ray = new Ray( _item.transform.position, Vector3.down);
Debug.Log("did i hit?");
if (Physics.Raycast(_ray, out _rayHit))
{
if (_rayHit.collider.gameObject.tag == "floor")
{
_item.transform.position = _rayHit.collider.gameObject.transform.position;
Debug.Log("yes");
}
}
else
{
Debug.Log ("no");
DestroyObject(_item);
}
yield return null;
}
//Calculate the bounce and turn the ball into that direction.
private void Update()
{
Ray ray = new Ray(transform.position, transform.forward);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Time.deltaTime * LS_moveSpeed + 0.1f, LS_LayerMask))
{
//Show the normal of the plane
Debug.DrawRay(transform.position, transform.forward);
//Reflect the electricity
Vector3 reflectDir = Vector3.Reflect(ray.direction, hit.normal);
//Calculate the turn of the electricity
float rot = 90 - Mathf.Atan2(reflectDir.z, reflectDir.x) * Mathf.Rad2Deg;
transform.eulerAngles = new Vector3(0, rot, 0);
//Add some moveSpeed
LS_moveSpeed += 0.5f;
}
//Move the player and set the movespeed.
transform.Translate(Vector3.forward * Time.deltaTime * LS_moveSpeed);
LS_moveSpeed = Mathf.Clamp(LS_moveSpeed, 3, LS_maxSpeed);
}
void FixedUpdate()
{
float fmotion = -InputManager.Instance.GetAxis("DEDH_FMotion" + _PlayerID);
float smotion = InputManager.Instance.GetAxis("DEDH_RMotion" + _PlayerID);
_RBody.drag = _Drag;
_RBody.angularDrag = _ADrag;
_RTorque = _RTorque - (_RBody.velocity.magnitude / 300);
_RTorque += 1;
_RTorque = Mathf.Clamp(_RTorque, 1, 5);
_RBody.AddForce(fmotion * (_MForce - 40 - _RBody.velocity.magnitude) * transform.forward);
_RBody.AddTorque(smotion * _RTorque * Vector3.up);
RaycastHit hit;
Ray dray = new Ray(transform.position, -Vector3.up);
if (Physics.Raycast(dray, out hit))
{
if (hit.transform.tag == "Tag 4")
{
float hoverError = _HHeight - hit.distance;
if (hoverError > 0)
{
float upwardSpeed = _RBody.velocity.y;
float lift = hoverError * _HForce - upwardSpeed * _HDamp;
_RBody.AddForce(lift * new Vector3(0, 90, 0));
}
}
}
}
public override MovementOutput GetMovement()
{
RaycastHit rayVector = new RaycastHit();
Collider hitbox = AvoidObstacle.GetComponent<Collider>();
Ray centralRay = new Ray(this.Character.position, this.Character.velocity.normalized);
bool collision = hitbox.Raycast(centralRay, out rayVector, lookAhead);
if (collision)
{
Target.position = rayVector.point + rayVector.normal * avoidDistance;
return base.GetMovement();
}
Ray whiskerRay1 = new Ray(this.Character.position, Util.MathHelper.Rotate2D(Character.velocity.normalized, ((float)System.Math.PI) / 4.0f).normalized);
collision = hitbox.Raycast(whiskerRay1, out rayVector, whiskersLookAhead);
if (collision)
{
Target.position = rayVector.point + rayVector.normal * avoidDistance;
return base.GetMovement();
}
Ray whiskerRay2 = new Ray(this.Character.position, Util.MathHelper.Rotate2D(Character.velocity.normalized, -((float)System.Math.PI) / 4.0f).normalized);
collision = hitbox.Raycast(whiskerRay2, out rayVector, whiskersLookAhead);
if (collision)
{
Target.position = rayVector.point + rayVector.normal * avoidDistance;
return base.GetMovement();
}
return new MovementOutput();
}
static int Raycast(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 4);
UnityEngine.Collider obj = (UnityEngine.Collider)ToLua.CheckObject <UnityEngine.Collider>(L, 1);
UnityEngine.Ray arg0 = ToLua.ToRay(L, 2);
UnityEngine.RaycastHit arg1;
float arg2 = (float)LuaDLL.luaL_checknumber(L, 4);
bool o = obj.Raycast(arg0, out arg1, arg2);
LuaDLL.lua_pushboolean(L, o);
if (o)
{
ToLua.Push(L, arg1);
}
else
{
LuaDLL.lua_pushnil(L);
}
return(2);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
protected override bool CheckCanRotate()
{
float rayDistance = 1.0f;
Ray ray0 = new Ray();
ray0.origin = Cube0.transform.position;
switch (mPositionIndex)
{
case 0:
ray0.direction = Vector3.down;
break;
case 1:
ray0.direction = Vector3.left;
break;
case 2:
ray0.direction = Vector3.up;
break;
case 3:
ray0.direction = Vector3.right;
break;
default:
Debug.LogError("Wrong mPositionIndex");
break;
}
bool trigegr0 = CheckRaycastHit(ray0, rayDistance);
if (trigegr0 == true)
{
return false;
}
return true;
}
private const float k_PowerUpWaitTime = 2.033f; // The amount of time it takes for the turret to power up (based on the animation).
private void AimAtPlayer()
{
// Find the players position but at the rotators height.
Vector3 playerAtTurretHeight = m_PlayerTransform.position;
playerAtTurretHeight.y = m_TurretRotator.position.y;
// Find a rotation of the turret rotating to facing the player.
Quaternion newRotation = Quaternion.LookRotation(playerAtTurretHeight - m_TurretRotator.position);
// If the normalised time hasn't reached 1 yet, increment it.
if (m_AimTimer < 1f)
m_AimTimer += Time.deltaTime / m_AimTime;
else
m_AimTimer = 1f;
// Use the normalised time to rotate the turret smoothly so that it's facing the player.
m_TurretRotator.rotation = Quaternion.Slerp(m_TurretRotator.rotation, newRotation, m_AimTimer);
// Create a ray from the turret in the direction of the turret to the player.
Ray ray = new Ray(m_TurretRotator.position, playerAtTurretHeight - m_TurretRotator.position);
RaycastHit hit;
// The player is in sight if the raycast hits something and the transform of what's been hit is the player's transform.
m_PlayerInSight = Physics.Raycast(ray, out hit, m_Range) && hit.transform == m_PlayerTransform;
// However the player only counts as being in sight if it's not dead.
m_PlayerInSight &= !m_Player.Dead;
}
public static bool IntersectRayMesh(Ray ray, Mesh mesh, Matrix4x4 matrix, out RaycastHit hit)
{
var parameters = new object[]{ray,mesh,matrix,null};
bool result = (bool)meth_IntersectRayMesh.Invoke(null,parameters);
hit = (RaycastHit)parameters[3];
return result;
}
public override void Start()
{
currentTime = 0.0f;
Enemy enemy = components.action_target.GetComponent<Enemy>();
Collider2D[] hazards = Physics2D.OverlapCircleAll(enemy.transform.position, fieldOfReaction, 4096);
for (int i = 0; i < hazards.Length; i++)
{
Vector3 hazardPosition = hazards[i].transform.position;
Vector3 delta = hazardPosition - enemy.transform.position;
Vector3 optionA = Vector3.Cross(Vector3.forward, delta); optionA = optionA.normalized;
Vector3 optionB = Vector3.Reflect(optionA, delta); optionB = optionB.normalized;
Vector3 optionC = delta * -1; optionC = optionC.normalized;
Vector2[] options = new Vector2[] { optionA, optionB, optionC };
for (int c = 0; c < options.Length; c++)
{
Ray ray = new Ray(enemy.transform.position, options[c].normalized);
RaycastHit2D hit = Physics2D.GetRayIntersection(ray, speed, 256);
if (hit)
{
if (hit.distance < speed * 0.8f) continue;
enemy.Impulse(options[c].normalized, speed);
}
else
{
enemy.Impulse(options[c].normalized, speed);
}
}
}
}
public KinematicData willViolate()
{
RaycastHit rayVector = new RaycastHit();
foreach (var bot in this.bots) {
Collider hitbox = bot.GetComponent<Collider>();
Vector3 tempVect = this.character.KinematicData.velocity.normalized;
if (this.character.KinematicData.velocity.magnitude != 0.0f && tempVect.magnitude != 0.0f)
{
Ray centralRay = new Ray(this.character.KinematicData.position, this.character.KinematicData.velocity.normalized);
if (hitbox.Raycast(centralRay, out rayVector, 15.0f))
{
this.pedestrian = new DynamicCharacter(bot)
{
Drag = 15.0f,
MaxSpeed = 20.0f
};
return this.pedestrian.KinematicData;
}
}
}
return null;
}
IEnumerator FireLaser()
{
_line.enabled = true;
_light.enabled = true;
while (Input.GetButton("Fire1"))
{
_renderer.material.mainTextureOffset = new Vector2(Time.time, Time.time);
Ray ray = new Ray(transform.position, transform.forward);
RaycastHit hit;
_line.SetPosition(0, ray.origin);
if (Physics.Raycast(ray, out hit, 100))
{
_line.SetPosition(1, hit.point);
EBunny_Status status = hit.collider.GetComponent<EBunny_Status>();
if (status)
{
status.ApplyDamage(LaserDamage);
}
}
else
_line.SetPosition(1, ray.GetPoint(100));
yield return null;
}
_line.enabled = false;
_light.enabled = false;
}
// Spherecast from the root to find ground height
protected virtual RaycastHit GetSpherecastHit()
{
Ray ray = new Ray (r.position + Vector3.up * airborneThreshold, Vector3.down);
RaycastHit h = new RaycastHit();
Physics.SphereCast(ray, spherecastRadius, out h, airborneThreshold * 2f, groundLayers);
return h;
}
static public int ctor_s(IntPtr l)
{
try {
UnityEngine.Ray o;
o = new UnityEngine.Ray();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static int ScreenPointToRay(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.Camera arg0 = (UnityEngine.Camera)ToLua.CheckObject(L, 1, typeof(UnityEngine.Camera));
UnityEngine.Vector2 arg1 = ToLua.ToVector2(L, 2);
UnityEngine.Ray o = UnityEngine.RectTransformUtility.ScreenPointToRay(arg0, arg1);
ToLua.Push(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static public int constructor(IntPtr l)
{
try {
UnityEngine.Ray o;
UnityEngine.Vector3 a1;
checkType(l, 2, out a1);
UnityEngine.Vector3 a2;
checkType(l, 3, out a2);
o = new UnityEngine.Ray(a1, a2);
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static bool InterSectWithAABB(UnityEngine.Ray ray, Aabb aabb)
{
double tx1 = (aabb.Min.x - ray.origin.x) * (1 / ray.direction.x);
double tx2 = (aabb.Max.x - ray.origin.x) * (1 / ray.direction.x);
double tmin = math.min(tx1, tx2);
double tmax = math.max(tx1, tx2);
double ty1 = (aabb.Min.y - ray.origin.y) * (1 / ray.direction.y);
double ty2 = (aabb.Max.y - ray.origin.y) * (1 / ray.direction.y);
tmin = math.max(tmin, math.min(ty1, ty2));
tmax = math.min(tmax, math.max(ty1, ty2));
double tz1 = (aabb.Min.z - ray.origin.z) * (1 / ray.direction.z);
double tz2 = (aabb.Max.z - ray.origin.z) * (1 / ray.direction.z);
tmin = math.max(tmin, math.min(tz1, tz2));
tmax = math.min(tmax, math.max(tz1, tz2));
UnityEngine.Debug.LogFormat("tmin : {0} tmax : {1}", tmin, tmax);
return(tmax >= tmin);
}
public bool SphereCast(UnityEngine.Ray ray, float radius, out UnityEngine.RaycastHit hitInfo)
{
return(Physics.SphereCast(ray, radius, out hitInfo));
}
public bool SphereCast(UnityEngine.Ray ray, float radius, out UnityEngine.RaycastHit hitInfo, float distance, int layerMask)
{
return(Physics.SphereCast(ray, radius, out hitInfo, distance, layerMask));
}
public UnityEngine.RaycastHit[] SphereCastAll(UnityEngine.Ray ray, float radius)
{
return(Physics.SphereCastAll(ray, radius));
}
public UnityEngine.RaycastHit[] SphereCastAll(UnityEngine.Ray ray, float radius, float distance, int layerMask)
{
return(Physics.SphereCastAll(ray, radius, distance, layerMask));
}
/// <summary>Calcule la distance signée entre une droite et un plan. Le signe dépend du côté duquel se trouve la droite par rapport au plan. Vaut 0 si ils ne sont pas parallèles.</summary>
public static float DistSigned(Line l, Plane p)
{
return(DistSigned(p, l));
}
/// <summary>Calcule la plus petite distance entre la droite et le point</summary>
public static float Dist(Line l, Point p)
{
return(Point.Cross((p - l.origin), l.direction).magnitude / l.direction.magnitude);
}
static int SphereCastAll(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(float)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1);
ToLua.Push(L, o);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(float), typeof(float)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1, arg2);
ToLua.Push(L, o);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(float), typeof(UnityEngine.Vector3)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
UnityEngine.Vector3 arg2 = ToLua.ToVector3(L, 3);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1, arg2);
ToLua.Push(L, o);
return(1);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(float), typeof(UnityEngine.Vector3), typeof(float)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
UnityEngine.Vector3 arg2 = ToLua.ToVector3(L, 3);
float arg3 = (float)LuaDLL.lua_tonumber(L, 4);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1, arg2, arg3);
ToLua.Push(L, o);
return(1);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(float), typeof(float), typeof(int)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
int arg3 = (int)LuaDLL.lua_tonumber(L, 4);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1, arg2, arg3);
ToLua.Push(L, o);
return(1);
}
else if (count == 5 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(float), typeof(UnityEngine.Vector3), typeof(float), typeof(int)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
UnityEngine.Vector3 arg2 = ToLua.ToVector3(L, 3);
float arg3 = (float)LuaDLL.lua_tonumber(L, 4);
int arg4 = (int)LuaDLL.lua_tonumber(L, 5);
UnityEngine.RaycastHit[] o = UnityEngine.Physics.SphereCastAll(arg0, arg1, arg2, arg3, arg4);
ToLua.Push(L, o);
return(1);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Physics.SphereCastAll"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public UnityEngine.RaycastHit[] RaycastAll(UnityEngine.Ray ray, float distance)
{
return(Physics.RaycastAll(ray, distance));
}
public UnityEngine.RaycastHit[] RaycastAll(UnityEngine.Ray ray)
{
return(Physics.RaycastAll(ray));
}
public bool SphereCast(UnityEngine.Ray ray, float radius)
{
return(Physics.SphereCast(ray, radius));
}
public static void ReportOnPointerUpEvent(ACTION_BUTTON buttonId, string sceneId, string uuid, string entityId, string meshName, Ray ray, Vector3 point, Vector3 normal, float distance)
{
if (string.IsNullOrEmpty(uuid))
{
return;
}
onPointerUpEvent.uuid = uuid;
SetPointerEventPayload(onPointerEventPayload, buttonId, entityId, meshName, ray, point, normal, distance, isHitInfoValid: true);
onPointerUpEvent.payload = onPointerEventPayload;
SendSceneEvent(sceneId, "uuidEvent", onPointerUpEvent);
}
/// <summary>Calcule la distance entre une droite et une sphère. Peut être négatif : entre 0 si la droite est tangeante à la surface de la sphère, et -rayon si la droite traverse le centre de la sphère.</summary>
public static float Dist(Sphere s, Line l)
{
return(Dist(s.position, l) - s.radius);
}
/// <summary>Calcule la distance entre une droite et une sphère. Si c'est négatif, indique la profondeur de la droite dans la sphère.</summary>
public static float Dist(Line l, SphereCollider s)
{
return(Dist(s, l));
}
/// <summary>Calcule la distance entre une droite et une sphère. Si c'est négatif, indique la profondeur de la droite dans la sphère.</summary>
public static float Dist(SphereCollider s, Line l)
{
return(Dist(ToSphere(s), l));
}
/// <summary>Calcule la plus petite distance entre la droite et le point</summary>
public static float Dist(Point p, Line l)
{
return(Dist(l, p));
}
public UnityEngine.RaycastHit[] RaycastAll(UnityEngine.Ray ray, float distance, int layerMask)
{
return(Physics.RaycastAll(ray, distance, layerMask));
}
private static void SetPointerEventPayload(OnPointerEventPayload pointerEventPayload, ACTION_BUTTON buttonId, string entityId, string meshName, Ray ray, Vector3 point, Vector3 normal, float distance, bool isHitInfoValid)
{
pointerEventPayload.origin = ray.origin;
pointerEventPayload.direction = ray.direction;
pointerEventPayload.buttonId = buttonId;
if (isHitInfoValid)
{
pointerEventPayload.hit = CreateHitObject(entityId, meshName, point, normal, distance);
}
else
{
pointerEventPayload.hit = null;
}
}
/// <summary>
/// Write the specified value using the writer.
/// </summary>
/// <param name="value">Value.</param>
/// <param name="writer">Writer.</param>
public override void Write(object value, ISaveGameWriter writer)
{
UnityEngine.Ray ray = (UnityEngine.Ray)value;
writer.WriteProperty("origin", ray.origin);
writer.WriteProperty("direction", ray.direction);
}
public List <SVONode> Trace(UnityEngine.Ray ray)
{
return(tracer.Trace(ray, svo));
}
static int Raycast(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 1 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
bool o = UnityEngine.Physics.Raycast(arg0);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(float)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
bool o = UnityEngine.Physics.Raycast(arg0, arg1);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
UnityEngine.RaycastHit arg1;
bool o = UnityEngine.Physics.Raycast(arg0, out arg1);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg1);
return(2);
}
else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
bool o = UnityEngine.Physics.Raycast(arg0, arg1);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(float), typeof(int)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
float arg1 = (float)LuaDLL.lua_tonumber(L, 2);
int arg2 = (int)LuaDLL.lua_tonumber(L, 3);
bool o = UnityEngine.Physics.Raycast(arg0, arg1, arg2);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
bool o = UnityEngine.Physics.Raycast(arg0, arg1, arg2);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>), typeof(float)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
UnityEngine.RaycastHit arg1;
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
bool o = UnityEngine.Physics.Raycast(arg0, out arg1, arg2);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg1);
return(2);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
UnityEngine.RaycastHit arg2;
bool o = UnityEngine.Physics.Raycast(arg0, arg1, out arg2);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg2);
return(2);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(float), typeof(int)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
int arg3 = (int)LuaDLL.lua_tonumber(L, 4);
bool o = UnityEngine.Physics.Raycast(arg0, arg1, arg2, arg3);
LuaDLL.lua_pushboolean(L, o);
return(1);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>), typeof(float)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
UnityEngine.RaycastHit arg2;
float arg3 = (float)LuaDLL.lua_tonumber(L, 4);
bool o = UnityEngine.Physics.Raycast(arg0, arg1, out arg2, arg3);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg2);
return(2);
}
else if (count == 4 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Ray), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>), typeof(float), typeof(int)))
{
UnityEngine.Ray arg0 = ToLua.ToRay(L, 1);
UnityEngine.RaycastHit arg1;
float arg2 = (float)LuaDLL.lua_tonumber(L, 3);
int arg3 = (int)LuaDLL.lua_tonumber(L, 4);
bool o = UnityEngine.Physics.Raycast(arg0, out arg1, arg2, arg3);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg1);
return(2);
}
else if (count == 5 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Vector3), typeof(UnityEngine.Vector3), typeof(LuaInterface.LuaOut <UnityEngine.RaycastHit>), typeof(float), typeof(int)))
{
UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 1);
UnityEngine.Vector3 arg1 = ToLua.ToVector3(L, 2);
UnityEngine.RaycastHit arg2;
float arg3 = (float)LuaDLL.lua_tonumber(L, 4);
int arg4 = (int)LuaDLL.lua_tonumber(L, 5);
bool o = UnityEngine.Physics.Raycast(arg0, arg1, out arg2, arg3, arg4);
LuaDLL.lua_pushboolean(L, o);
ToLua.Push(L, arg2);
return(2);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Physics.Raycast"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public bool Raycast(UnityEngine.Ray ray)
{
var bounds = new UnityEngine.Bounds();
bounds.SetMinMax(new UnityEngine.Vector3(0, 0, 0), new UnityEngine.Vector3(_sizeX * 16, _sizeY * 16, _sizeZ * 16));
// if we're outside world bounds, first intersect the world's bounding box
if (!bounds.Contains(ray.origin))
{
float dist;
if (!bounds.IntersectRay(ray, out dist))
{
return(false);
}
ray.origin += ray.direction * dist;
}
// inside or at world edge, time to voxel trace
// From "A Fast Voxel Traversal Algorithm for Ray Tracing"
// by John Amanatides and Andrew Woo, 1987
// <http://www.cse.yorku.ca/~amana/research/grid.pdf>
// <http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.3443>
// initialize to initial voxel coordinate
// TODO verify that this works reliable even if we started outside the world bounds
int x = Mathf.FloorToInt(ray.origin.x);
int y = Mathf.FloorToInt(ray.origin.y);
int z = Mathf.FloorToInt(ray.origin.z);
// TODO determine initial distances to voxel edges
float tMaxX = intbound(ray.origin.x, ray.direction.x);
float tMaxY = intbound(ray.origin.y, ray.direction.y);
float tMaxZ = intbound(ray.origin.z, ray.direction.z);
// determine stepping direction
int stepX = (int)Mathf.Sign(ray.direction.x);
int stepY = (int)Mathf.Sign(ray.direction.y);
int stepZ = (int)Mathf.Sign(ray.direction.z);
// determine distance (in ray units) between voxel edges
float tDeltaX = stepX / ray.direction.x;
float tDeltaY = stepY / ray.direction.y;
float tDeltaZ = stepZ / ray.direction.z;
int wx = _sizeX * 16;
int wy = _sizeY * 16;
int wz = _sizeZ * 16;
while (
(stepX > 0 ? x < wx : x >= 0) &&
(stepY > 0 ? y < wy : y >= 0) &&
(stepZ > 0 ? z < wz : z >= 0))
{
// lalala
// TODO WE NOW HAVE A VOXEL AT X,Y,Z
// walk...
if (tMaxX < tMaxY)
{
if (tMaxX < tMaxZ)
{
x += stepX;
tMaxX += tDeltaX;
}
else
{
z += stepZ;
tMaxZ += tDeltaZ;
}
}
else
{
if (tMaxY < tMaxZ)
{
y += stepY;
tMaxY += tDeltaY;
}
else
{
z += stepZ;
tMaxZ += tDeltaZ;
}
}
}
return(false);
}
public bool Raycast(UnityEngine.Ray ray, out UnityEngine.RaycastHit hitInfo, float distance, int layerMask)
{
return(Physics.Raycast(ray, out hitInfo, distance, layerMask));
}
private UnityEngine.Vector2 ProjectPointer(float x, float y)
{
if (_texture == null)
{
return(new UnityEngine.Vector2(x, UnityEngine.Screen.height - y));
}
else
{
// Project using texture coordinates
// First try with Unity GUI RawImage objects
UnityEngine.EventSystems.EventSystem eventSystem = UnityEngine.EventSystems.EventSystem.current;
if (eventSystem != null && eventSystem.IsPointerOverGameObject())
{
UnityEngine.Vector2 pos = new UnityEngine.Vector2(x, y);
if (_pointerData == null)
{
_pointerData = new UnityEngine.EventSystems.PointerEventData(eventSystem)
{
pointerId = 0,
position = pos
};
}
else
{
_pointerData.Reset();
}
_pointerData.delta = pos - _pointerData.position;
_pointerData.position = pos;
UnityEngine.RectTransform rect = GetComponent <UnityEngine.RectTransform>();
if (rect != null &&
UnityEngine.RectTransformUtility.ScreenPointToLocalPointInRectangle(
rect, _pointerData.position, _pointerData.pressEventCamera, out pos))
{
UnityEngine.Vector2 pivot = new UnityEngine.Vector2(
rect.pivot.x * rect.rect.width,
rect.pivot.y * rect.rect.height);
float texCoordX = (pos.x + pivot.x) / rect.rect.width;
float texCoordY = (pos.y + pivot.y) / rect.rect.height;
float localX = _texture.width * texCoordX;
float localY = _texture.height * (1.0f - texCoordY);
return(new UnityEngine.Vector2(localX, localY));
}
}
// NOTE: A MeshCollider must be attached to the target to obtain valid
// texture coordintates, otherwise Hit Testing won't work
UnityEngine.Ray ray = UnityEngine.Camera.main.ScreenPointToRay(new UnityEngine.Vector3(x, y, 0));
UnityEngine.RaycastHit hit;
if (UnityEngine.Physics.Raycast(ray, out hit))
{
if (hit.collider.gameObject == gameObject)
{
float localX = _texture.width * hit.textureCoord.x;
float localY = _texture.height * (1.0f - hit.textureCoord.y);
return(new UnityEngine.Vector2(localX, localY));
}
}
return(new UnityEngine.Vector2(-1, -1));
}
}
/// <summary>Calcule la distance absolue entre une droite et un plan. Vaut 0 si ils ne sont pas parallèles.</summary>
public static float Dist(Line l, Plane p)
{
return(Dist(p, l));
}
public bool Raycast(UnityEngine.Ray ray, out UnityEngine.RaycastHit hitInfo)
{
return(Physics.Raycast(ray, out hitInfo));
}
