C# (CSharp) Class Vector3, Code Examples

C# (CSharp) Vector3 - 30 examples found. These are the top rated real world C# (CSharp) examples of class Vector3 from package extracted from open source projects. You can rate examples to help us improve the quality of examples
Example #1
0
 void Start()
 {
     ancienPos = obj.transform.position;
     posVoulu = ancienPos + vue;
     this.transform.position = posVoulu;
     y_start = transform.position.y;
 }
Example #2
0
 void Rotate(float degreesAroundRight, float degreesAroundUp)
 {
     Quaternion rotation = Quaternion.Euler(-degreesAroundRight, degreesAroundUp, 0f);
     transform.rotation = rotation;
     Vector3 percheASelfie = new Vector3(0f, 0f, -_distance); // TODO: Move new outside of update
     transform.position = rotation * percheASelfie;
 }
Example #3
0
 public Plane(Vector3 n, float d)
     : base((int)PrimitiveType.Plane)
 {
     JiggleMath.NormalizeSafe(ref n);
     this.normal = n;
     this.d = d;
 }
    void Update()
    {
        // Get input vector from kayboard or analog stick and make it length 1 at most
        Vector3 inputVector = new Vector3(0/*Input.GetAxis("Horizontal")*/, Input.GetAxis("Vertical"), 0);
        if(1 < inputVector.magnitude) {
            inputVector = inputVector.normalized;
        }
        inputVector = inputVector.normalized * Mathf.Pow(inputVector.magnitude, 2);

        // Rotate input vector into camera space so up is camera's up and right is camera's right
        inputVector = Camera.main.transform.rotation * inputVector;

        // Rotate input vector to be perpendicular to character's up vector
        Quaternion camToCharacterSpace = Quaternion.FromToRotation(Camera.main.transform.forward*-1, transform.up);
        inputVector = (camToCharacterSpace * inputVector);

        // Make input vector relative to Character's own orientation
        inputVector = Quaternion.Inverse(transform.rotation) * inputVector;

        if(walkMultiplier!=1) {
            if( (Input.GetKey("left shift") || Input.GetKey("right shift")) != defaultIsWalk ) {
                inputVector *= walkMultiplier;
            }
        }

        //motor.desiredTurn = inputVector.x;
        //inputVector.x = 0;

        // Apply direction
        motor.desiredMovementDirection = inputVector;

        return;
    }
Example #5
0
        private void SetObstacles()
        {
            string modelName = "tree stomp sculpture";
            float modelScale = 0.02f;
            Vector3 initRot = new Vector3(-MathHelper.PiOver2, 0, 0);
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(29, 0, -8) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(63, 0, -18) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(101, 0, -13) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(101, 0, -19) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(111, 0, -20) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(94, 0, -31) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(15, 0, -36) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(111, 0, -43) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(50, 0, -50) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(106, 0, -53) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(57, 0, -55) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(98, 0, -62) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(75, 0, -68) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(28, 0, -69) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(42, 0, -69) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(81, 0, -78) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(13, 0, -85) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(103, 0, -89) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(73, 0, -90) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(49, 0, -92) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(37, 0, -101) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(106, 0, -53) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(120, 0, -121) * Ground.TerrainScale, modelScale, initRot));
            Obstacles.Add(new BaseObject(RaceGame, modelName, Ground.Origin + new Vector3(24, 0, -122) * Ground.TerrainScale, modelScale, initRot));

            for (int i = 0; i < Obstacles.Count; ++i)
            {
                RaceGame.Components.Add(Obstacles[i]);
            }
        }
Example #6
0
	public void SelfDestructor(int combo, bool b){
		Combo.setCombo(combo);
		rotate = true;
		timer = 0f;
		randomRot = new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 0f), Random.Range(-1f, 1f));
		Destroy(gameObject, 20f);
	}
Example #7
0
    void Update()
    {
        if (!_First && _Velocity != 0)
        {
            float smooth = (_Velocity > 0) ? SmoothRate : -SmoothRate;
            _Velocity -= smooth * Time.deltaTime;
            if (Mathf.Abs(_Velocity) < 0.01f) _Velocity = 0f;

            Vector3 move = new Vector3(_Velocity * -1, 0, 0);
            _Transform.Translate(move, Space.World);
        }

        if (Input.GetMouseButton(0))
        {
            if (!_First)
            {
                DragEnter();
                _First = true;
            }
            else
                DragUpdate();
        }
        else if (Input.GetMouseButtonUp(0))
        {
            _First = false;
        }
    }
Example #8
0
    // Update is called once per frame
    void Update()
    {
        //		transform.LookAt(transform.position + Camera.main.transform.rotation * Vector3.back,
        //            Camera.main.transform.rotation * Vector3.up);

        //glowAmmount -= RATE * Time.deltaTime;
        glowAmount = Mathf.Lerp(glowAmount, 0, RATE * Time.deltaTime);

        if(glowAmount < 0)
            glowAmount = 0;

        //Debug.Log(glowAmmount * AMMOUNT);

        //		Color c = Color.blue;
        //		c.a = Mathf.Clamp01(glowAmmount * AMMOUNT);
        //
        //		renderer.material.color = c;

        //glowAmmount = 1.0f;

        transform.LookAt(transform.position + previousVelocity);
        GetComponent<ParticleSystem>().startSpeed = transform.parent.rigidbody.velocity.magnitude;
        GetComponent<ParticleSystem>().emissionRate = glowAmount * AMOUNT - THRESHOLD;

        //particleEmitter.Emit(Vector3.zero, previousVelosity, 1, 1, Color.white);
        //particleEmitter.Emit(50);

        previousVelocity = transform.parent.rigidbody.velocity;
    }
 public override void Fire(Vector3 direction, Quaternion rotation)
 {
     currentDistance = 0;
         base.Fire(direction,rotation);
                 BulletProjectileUp();
       amIFired = true;
 }
Example #10
0
 // Update is called once per frame
 void Update()
 {
     offset = Vector3.Lerp(offset,Vector3.zero, 20f * Time.deltaTime);
     transform.position = Vector3.Lerp(transform.position, player.transform.position, 1.0f * Time.deltaTime);
         transform.position = new Vector3(transform.position.x,transform.position.y,-20f)+offset;
         GetComponent<Camera>().orthographicSize = Screen.height / 128f;
 }
Example #11
0
    void MarchingCubesGo()
    {
        MarchingCubes.SetTarget (marchingCubesThreshold);
        MarchingCubes.SetWindingOrder(2, 1, 0);
        MarchingCubes.SetModeToTetrahedrons();
        MarchingCubes.SetScalar (voxelResolution);

        Vector3 minExtantPos = Vector3.one * voxelCountPerChunk * chunkStride * -0.5f * voxelResolution;

        for (int i = 0; i < chunkStride; i++) {
            for (int j = 0; j < chunkStride; j++) {
                for (int k = 0; k < chunkStride; k++) {
                    Vector3 start = new Vector3(i, j, k);
                    Vector3 end = start + Vector3.one;
                    start *= voxelCountPerChunk;
                    if (i > 0) start.x -= 1;
                    if (j > 0) start.y -= 1;
                    if (k > 0) start.z -= 1;
                    end *= voxelCountPerChunk;
                    end -= Vector3.one;
                    Mesh msh = MarchingCubes.CreateMesh (voxels, start, end);
                    msh.uv = new Vector2[msh.vertices.Length];
                    msh.RecalculateNormals();
                    msh.RecalculateBounds();
                    GameObject go = (GameObject)Instantiate (meshPrefab);
                    go.transform.position = minExtantPos;
                    go.GetComponent<MeshFilter> ().mesh = msh;
                    go.GetComponent<MeshCollider>().sharedMesh = msh;
                }
            }
        }
    }
		////////////////////////////////////////////////////////////////////////////////////////////////
		/*--------------------------------------------------------------------------------------------*/
		internal void UpdateWithCursor(Vector3? pCursorPosition) {
			if ( pCursorPosition == null || vIsAnimating ) {
				HighlightProgress = 0;
				vSelectionStart = null;
				IsSelectionPrevented = false;
				return;
			}

			if ( vCursorDistanceFunc == null ) {
				throw new Exception("No CursorDistanceFunction has been set.");
			}

			if ( !NavItem.IsEnabled ) {
				HighlightDistance = float.MaxValue;
				HighlightProgress = 0;
				return;
			}

			float dist = vCursorDistanceFunc((Vector3)pCursorPosition);
			float prog = Mathf.InverseLerp(vSettings.HighlightDistanceMax,
				vSettings.HighlightDistanceMin, dist);

			HighlightDistance = dist;
			HighlightProgress = prog;
		}
Example #13
0
	public bool IsHoldingGrapple = false;	// if true the player is pulled alongwith the hook shot
	public void CreateGrappleBeam() {
		if (!IsGrappling) {
			HandPosition = transform.position;	// default for now
			RaycastHit hit;
			Player MyPlayer = gameObject.GetComponent<Player> ();
			if (Physics.Raycast (transform.position, MyPlayer.ShootForwardVector, out hit, 100)) {
				HandPosition = hit.point;
				Quaternion NewRotation = new Quaternion ();
				//NewRotation.eulerAngles = (hit.point - gameObject.transform.position);
				NewRotation.eulerAngles =  MyPlayer.ShootForwardVector;
				NewRotation = Quaternion.identity;
				//Debug.LogError ("Angle of Grapple: " + NewRotation.eulerAngles.ToString());
				GameObject MyChain = (GameObject)Instantiate (GrappleBeamPrefab, HandPosition, NewRotation);
				//NewRotation = MyChain.transform.rotation;
				MyChain.transform.LookAt(hit.point);
				//Debug.LogError ("Angle of Grapple: " + MyChain.transform.rotation.eulerAngles.ToString());
				if (IsHoldingGrapple) {
					//MyChain.transform.rotation = NewRotation;
					transform.position = MyChain.transform.GetChild (7).transform.position;
					Vector3 CharacterBodyOffset = new Vector3(0,-1.5f,0);
					transform.position = transform.position+CharacterBodyOffset;
					gameObject.AddComponent<FixedJoint> ();
					gameObject.GetComponent<FixedJoint> ().connectedBody = MyChain.transform.GetChild (7).GetComponent<Rigidbody> ();
					gameObject.GetComponent<CharacterController> ().enabled = false;
					IsGrappling = true;
					gameObject.GetComponent<Rigidbody>().isKinematic = false;
				}
			}
		}
	}
    // Update is called once per frame
    void FixedUpdate()
    {
        if (should_shoot) {
            // did shoot before?
            if (delay_active){
                // enough time in between passed?
                if (stopwatch.ElapsedMilliseconds > delay) {
                    stopwatch.Reset();
                    delay_active = false;
                }
            }else{
                // shoot
                Transform tmp = Instantiate(bullet, transform.position, Quaternion.identity) as Transform;
                GameObject spawned_bullet = tmp.gameObject;
                spawned_bullet.layer = this.gameObject.layer;

                direction = (ship.transform.position - this.transform.position).normalized;
                /*
                // add spread
                direction = new Vector3(direction.x + Random.Range(-accuarcy_spread, accuarcy_spread),
                                        direction.y + Random.Range(-accuarcy_spread, accuarcy_spread),
                                        direction.z + Random.Range(-accuarcy_spread, accuarcy_spread));
        */
                spawned_bullet.transform.rotation = Quaternion.LookRotation(direction);
                spawned_bullet.GetComponent<Rigidbody>().AddForce(direction * bullet_speed);

                stopwatch.Start();
                delay_active = true;
            }
        }
    }
    // Use this for initialization
    void Start()
    {
        for (int i = 0; i < this.transform.childCount; i++) {
            GameObject obj = this.transform.GetChild(i).gameObject;
            Animator animator = obj.GetComponentInChildren<Animator>();
            this.animatorList.Add(animator);
            obj.SetActive(false);
        }

        switch (showType) {
        case ShowType.Enumeration: {
            for(int i = 0; i < animatorList.Count; i++){
                GameObject obj = animatorList[i].transform.parent.gameObject;
                obj.SetActive(true);
                float x = -20 + (i / 5) * 5;
                float y = 10 - (i % 5) * 5;
                Vector3 pos = new Vector3(x, y, i);
                obj.transform.localPosition = pos;
            }
            break;
        }
        case ShowType.Queue: {
            if(animatorList.Count >= 1){
                currentAnimator = animatorList[0];
                GameObject obj = currentAnimator.transform.parent.gameObject;
                obj.SetActive(true);
            }
            break;
        }
        }
    }
 public static Obj_AI_Hero GetTarget(this Spell spell,
     bool ignoreShields = true,
     Vector3 from = default(Vector3),
     IEnumerable<Obj_AI_Hero> ignoredChampions = null)
 {
     return TargetSelector.GetTarget(spell, ignoreShields, from, ignoredChampions);
 }
Example #17
0
        // Update is called once per frame
        private void Update()
        {
            Vector3 targetPosition = target.position;
            targetPosition.x = Mathf.Clamp(targetPosition.x, BoundsMin.x, BoundsMax.x);
            targetPosition.y = Mathf.Clamp(targetPosition.y, BoundsMin.y, BoundsMax.y);

            // only update lookahead pos if accelerating or changed direction
            float xMoveDelta = (targetPosition - m_LastTargetPosition).x;

            bool updateLookAheadTarget = Mathf.Abs(xMoveDelta) > lookAheadMoveThreshold;

            if (updateLookAheadTarget)
            {
                m_LookAheadPos = lookAheadFactor*Vector3.right*Mathf.Sign(xMoveDelta);
            }
            else
            {
                m_LookAheadPos = Vector3.MoveTowards(m_LookAheadPos, Vector3.zero, Time.deltaTime*lookAheadReturnSpeed);
            }

            Vector3 aheadTargetPos = targetPosition + m_LookAheadPos + Vector3.forward*m_OffsetZ;
            Vector3 newPos = Vector3.SmoothDamp(transform.position, aheadTargetPos, ref m_CurrentVelocity, damping);

            transform.position = newPos;

            m_LastTargetPosition = targetPosition;
        }
    public void Update()
    {
        if (Input.GetMouseButtonDown(0)
            && SpaceTraderConfig.LocalPlayer
            && SpaceTraderConfig.LocalPlayer.Ship)
        {
            var pos = new Vector3(Input.mousePosition.x, Input.mousePosition.y);
            var ray = SpaceTraderConfig.WorldMap.Camera.ScreenPointToRay(pos);

            RaycastHit hit;
            if (Physics.Raycast(ray, out hit, float.PositiveInfinity, LayerMask.GetMask("World Map")))
            {
                //the only things on this layer with colliders should be markers
                var mapArea = hit.collider.GetComponent<WorldMapMarker>().Area;

                SpaceTraderConfig.LocalPlayer.Ship.Target = mapArea.GetComponent<Targetable>();

                Debug.Log("targetted area " + mapArea);
            }
        }

        float eastWest = Input.GetAxis("yaw");
        float northSouth = Input.GetAxis("pitch");

        const float PAN_SPEED = 50;

        camOffset += PAN_SPEED * Time.deltaTime * new Vector3(eastWest, 0, northSouth);
        var lerped = Vector3.Lerp(mapCamera.transform.position, camOffset, 2 * Time.deltaTime);

        var camXform = mapCamera.transform;
        camXform.position = lerped;
    }
    private ScoreboardController _scoreboardController; // hold reference to ScoreboardController

    #endregion Fields

    #region Methods

    IEnumerator SpawnWaves()
    {
        yield return new WaitForSeconds(startWait);

        while (true)
        {
            for (int i = 0; i < hazardCount; i++)
            {
                Vector3 spawnPosition = new Vector3(Random.Range(-spawnValues.x, spawnValues.x), spawnValues.y,
                    spawnValues.z);
                Quaternion spawnRotation = Quaternion.identity;
                // spawn with no rotation, this is already defined in RandomRotator.cs
                Instantiate(hazard, spawnPosition, spawnRotation);
                yield return new WaitForSeconds(spawnWait);
            }
            yield return new WaitForSeconds(waveWait);

            if (_scoreboardController.IsGameOver())
            {
                _scoreboardController.restartLabel.text = "Press 'R' to Restart";
                _scoreboardController.SetRestart(true);
                break;
            }
        }
    }
Example #20
0
 public Vector3 Add(ref Vector3 v)
 {
     return new Vector3(
         x: x + v.x,
         y: y + v.y,
         z: z + v.z);
 }
Example #21
0
    public bool TakeDamage(int amount, Vector3 hitPoint)
    {
        // If the enemy is dead...
        if (isDead)
            // ... no need to take damage so exit the function.
            return false;

        // Play the hurt sound effect.
        //enemyAudio.Play();

        // Reduce the current health by the amount of damage sustained.
        currentHealth -= amount;
        healthPercent = Mathf.CeilToInt((currentHealth * 1.0f) / (startingHealth) * 100);
        // Set the position of the particle system to where the hit was sustained.
        //hitParticles.transform.position = hitPoint;

        // And play the particles.
        //hitParticles.Play();

        // If the current health is less than or equal to zero...
        if (currentHealth <= 0)
        {
            // ... the enemy is dead.
            Death();
            return true;
        }
        return false;
    }
Example #22
0
 private void Awake()
 {
     button = transform.FindChild("Button");
     thebase = transform.FindChild("Base");
     startScale = button.localScale;
     targetScale = thebase.localScale;
 }
Example #23
0
    // Update is called once per frame
    void Update()
    {
        this.transform.position += Velocity*Time.deltaTime;

        if (transform.position.x < -384)
        {
            Velocity = new Vector3(200.0f, Velocity.y, 0);
        }

        if (transform.position.x > 384)
        {
            Velocity = new Vector3(-200.0f, Velocity.y, 0);
        }

        if (pointer.renderer.enabled == false)
        {
            if (transform.position.y > 640)
            {
                pointer.rotation = Quaternion.Euler (0, 0, 0);
                pointer.renderer.enabled = true;
                controls.p1Wins++;
                StartCoroutine("timeout");
            }
            else if (transform.position.y < -640)
            {
                pointer.rotation = Quaternion.Euler (0, 0, 180);
                pointer.renderer.enabled = true;
                controls.p2Wins++;
                StartCoroutine("timeout");
            }
        }
    }
Example #24
0
    float CalculatePathLength(Vector3 targetPosition)
    {
        // Create a path and set it based on a target position.
        NavMeshPath path = new NavMeshPath();
        if (nav.enabled)
            nav.CalculatePath(targetPosition, path);

        // Create an array of points which is the length of the number of corners in the path + 2.
        Vector3[] allWayPoints = new Vector3[path.corners.Length + 2];

        // The first point is the enemy's position.
        allWayPoints[0] = transform.position;

        // The last point is the target position.
        allWayPoints[allWayPoints.Length - 1] = targetPosition;

        // The points inbetween are the corners of the path.
        for (int i = 0; i < path.corners.Length; i++)
        {
            allWayPoints[i + 1] = path.corners[i];
        }

        // Create a float to store the path length that is by default 0.
        float pathLength = 0;

        // Increment the path length by an amount equal to the distance between each waypoint and the next.
        for (int i = 0; i < allWayPoints.Length - 1; i++)
        {
            pathLength += Vector3.Distance(allWayPoints[i], allWayPoints[i + 1]);
        }
        return pathLength;
    }
    void FixedUpdate()
    {
        //have we moved more than our minimum extent?
        Vector3 movementThisStep = myRigidbody.position - previousPosition;
        float movementSqrMagnitude = movementThisStep.sqrMagnitude;

        if (movementSqrMagnitude > sqrMinimumExtent)
        {
            float movementMagnitude = Mathf.Sqrt(movementSqrMagnitude);
            RaycastHit hitInfo;

            //check for obstructions we might have missed
            if (Physics.Raycast(previousPosition, movementThisStep, out hitInfo, movementMagnitude, layerMask.value))
            {
                if (!hitInfo.collider)
                    return;

                if (this.GetComponent<Collider>().isTrigger)
                    this.SendMessage("OnTriggerEnter", hitInfo.collider);

                if (hitInfo.collider.isTrigger)
                    hitInfo.collider.SendMessage("OnTriggerEnter", myCollider);

                if (!hitInfo.collider.isTrigger)
                    myRigidbody.position = hitInfo.point - (movementThisStep / movementMagnitude) * partialExtent;

            }
        }

        previousPosition = myRigidbody.position;
    }
Example #26
0
        /// <summary>
        /// Checks the mouse's position set in the in-game world plane.
        /// </summary>
        /// <param name="mousePosition">Mouse's position on screen</param>
        /// <param name="camera">Camera object</param>
        /// <param name="device">Graphics device used in rendering</param>
        /// <returns></returns>
        public static Vector3 getMouseWorldPosition(Vector2 mousePosition,CameraAndLights camera,GraphicsDevice device)
        {
            Vector3 nearsource = new Vector3(mousePosition,0f);
            Vector3 farsource = new Vector3(mousePosition,CameraAndLights.nearClip);

            Vector3 nearPoint = device.Viewport.Unproject(nearsource,
                                                          camera.projectionMatrix,
                                                          camera.viewMatrix,
                                                          Matrix.Identity);

            Vector3 farPoint = device.Viewport.Unproject(farsource,
                                                         camera.projectionMatrix,
                                                         camera.viewMatrix,
                                                         Matrix.Identity);

            // Create a ray from the near clip plane to the far clip plane.
            Vector3 direction = farPoint - nearPoint;
            direction.Normalize();
            Ray pickRay = new Ray(nearPoint,direction);

            Plane floor = new Plane(new Vector3(0f,1f,0f),0f);

            float denominator = Vector3.Dot(floor.Normal,pickRay.Direction);
            float numerator = Vector3.Dot(floor.Normal,pickRay.Position) + floor.D;
            float dist = -(numerator / denominator);

            Vector3 mouseWorldPos = nearPoint + direction * dist;

            return mouseWorldPos * new Vector3(1f,0f,1f);
        }
Example #27
0
 public void LookAt(Vector3 destination)
 {
     float tempX = transform.rotation.eulerAngles.x;
     transform.LookAt(destination);
     // compensating mesh flaw, it's awful, but it's works
     transform.rotation = Quaternion.Euler(tempX, transform.rotation.eulerAngles.y, transform.rotation.eulerAngles.z);
 }
Example #28
0
    public void DrawAttkBox(SPoint[] v, string mat, int n, int endN, SPoint p, int pNum,  int t, int poly)
    {
        //specialized manual function for attackboxes
        subMesh [poly] = new Mesh ();
        int vTot = endN - n + 1;
        Vector3[] vertices = new Vector3[vTot];
        Color32[] col = new Color32[vTot];

        //std::stringstream hbName;
        string hbName = "P#" + pNum + "HB-" + t + "-" + poly;

        for (int i = n; i <= endN; i++) {
            vertices [i-n] = new Vector3 (v [i].x + p.x, v [i].y + p.y, 0);
            col [i-n] = new Color32 (0, 250, 20, 150);
        }
        int tTot = (vTot - 2) * 3;
        int[] tri = new int[tTot];
        for (int i = 0; i<(tTot/3);i++) {//triangle fan
            tri[i*3]=0;
            tri[(i*3)+1]=i+1;
            tri[(i*3)+2]=i+2;
        }
        subMesh[poly].vertices=vertices;
        subMesh[poly].triangles = tri;
        subMesh[poly].colors32 = col;
    }
Example #29
0
 public Plane(Vector3 n, Vector3 pos)
     : base((int)PrimitiveType.Plane)
 {
     JiggleMath.NormalizeSafe(ref n);
     this.normal = n;
     this.d = -Vector3.Dot(n, pos);
 }
Example #30
0
    // Update is called once per frame
    void FixedUpdate()
    {
        if(BallRef)
        {
            //DISTANCE
            DistanceToTarget = Vector3.Distance(transform.position, BallRef.transform.position);

            //GET MOVE TO LOCATION
            if(BallRef.GetComponent<Rigidbody>().velocity.normalized == Vector3.zero)
            {
                MoveToLocation = BallRef.position + new Vector3(0f,0f,-2.5f);
            }
            else
            {
                MoveToLocation = BallRef.position + ((BallRef.GetComponent<Rigidbody>().velocity.normalized) * -2.5f);
            }
            MoveToLocation += (Vector3.up * 2);

            //MOVE
            transform.position = Vector3.Lerp(transform.position, MoveToLocation, Time.deltaTime * (DistanceToTarget/3));

            //LOOK AT
            Vector3 relativePos = (BallRef.transform.position + Vector3.up) - transform.position;
            Quaternion rotation = Quaternion.LookRotation(relativePos);
            transform.rotation = rotation;

        }
    }