// Update is called once per frame void Update () { oldStart = start; start = transform.position; finish = start + new Vector3(0, 15); if (isFire) { CD -= Time.deltaTime; if (CD <= 0) { GetComponent<LineRenderer>().enabled = true; GetComponent<LineRenderer>().sortingLayerName = "Bullets"; //GetComponent<LineRenderer>().SetPosition(0, start); //GetComponent<LineRenderer>().SetPosition(1, finish); GetComponent<LineRenderer>().SetPosition(0, Vector3.zero); GetComponent<LineRenderer>().SetPosition(1, new Vector3(0, 15)); if (!start.Equals(oldStart)) { GameObject newGlow = Instantiate(afterglow); newGlow.GetComponent<LineRenderer>().SetPosition(0, start); newGlow.GetComponent<LineRenderer>().SetPosition(1, finish); } targets = Physics2D.RaycastAll(start, Vector2.up,100,LayerMask.GetMask("Enemy")); if (targets!=null) foreach (RaycastHit2D item in targets) { if (item.collider.tag == "Enemy") { item.collider.SendMessage("ApplyDamage", 1f + power * 0.2f); } } } } else { GetComponent<LineRenderer>().enabled = false; CD = MaxCD; } }
public void EqualityTest( float x1, float y1, float z1, float x2, float y2, float z2, bool expected ) { Vector3 vector1 = new Vector3( x1, y1, z1 ); Vector3 vector2 = new Vector3( x2, y2, z2 ); Assert.AreEqual( vector1 == vector2, expected ); Assert.AreEqual( vector1 != vector2, !expected ); Assert.AreEqual( vector1.Equals( vector2 ), expected ); Assert.AreEqual( vector1.Equals( (object) vector2 ), expected ); }
public WVector3(Vector3 v) { if(v.Equals(null)) { throw new ArgumentNullException(); } Value = v; }
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId) { Vector3 playerSpawnPos = new Vector3(0.0F, 0.0F, 0.0F); Vector3 spawnA = new Vector3(0.0F, 0.0F, 0.0F); Vector3 spawnB = new Vector3(0.0F, 0.0F, 0.0F); GameObject[] spawns = GameObject.FindGameObjectsWithTag("spawn"); GameObject[] players = GameObject.FindGameObjectsWithTag("Player"); string target = "Spawn_A"; Quaternion rotation = Quaternion.identity; if (hostConnection != -1 && conn.connectionId != hostConnection) { target = "Spawn_B"; rotation = Quaternion.Euler(rotation.eulerAngles + new Vector3(0.0F, 180.0F, 0.0F)); } else { hostConnection = conn.connectionId; } foreach (GameObject spawn in spawns ) { if (spawn.name == "Spawn_A") spawnA = spawn.transform.position; else spawnB = spawn.transform.position; } if (target == "Spawn_A") playerSpawnPos = spawnA; if (playerSpawnPos.Equals(new Vector3(0.0F, 0.0F, 0.0F)) || target == "Spawn_B") playerSpawnPos = spawnB; GameObject player = (GameObject)GameObject.Instantiate(playerPrefab, playerSpawnPos, rotation); NetworkServer.AddPlayerForConnection(conn, player, playerControllerId); }
/// <summary> /// Creates a rotation matrix that will aim from one point to another. The resulting /// matrix can be used to make objects face a certain direction. /// </summary> /// <param name="from">The source point.</param> /// <param name="to">The destination point.</param> /// <returns>The aimed matrix.</returns> public static Matrix CreateAimedTransform(Vector3 from, Vector3 to) { // get a normalized vector from 'from' to 'to' Vector3 aimVector = to - from; aimVector.Normalize(); // get a vector to the left (no roll) Vector3 leftVector = new Vector3(-aimVector.Y, aimVector.X, 0); if (!leftVector.Equals(Vector3.Zero)) leftVector.Normalize(); else leftVector = Vector3.Backward; // get the up vector Vector3 upVector = Vector3.Cross(aimVector, leftVector); upVector.Normalize(); // create the matrix Matrix transform = Matrix.Identity; transform.Up = aimVector; transform.Backward = upVector; transform.Left = leftVector; // set the translation to the from position transform.Translation = from; // return the new matrix return transform; }
public void DifferentAreNotEqual() { var v1 = new Vector3(10, 10, 10); var v2 = new Vector3(1, 1, 1); Assert.IsFalse(v1.Equals(v2), "Vector with different values should not be equal"); }
public void powerupGone(Vector3 pos){ for (int i = 0; i < itemSpawnPoints.Length; i++) { if(pos.Equals(itemSpawnPoints[i])){ item[i] = false; break; } } }
public UInt16 FindVert(Vector3 v) { UInt16 index = (UInt16)Geometry.Vertecies.FindIndex(delegate(Vector3 p) { return v.Equals(p); }); if (index >= 0) return index; Geometry.Vertecies.Add(v); return (UInt16)(Geometry.Vertecies.Count - 1); }
public void ScalarDivision() { Vector3 ScalarMultiplicationArgument = new Vector3(5.0f, 4.0f, 3.0f); Assert.IsTrue(ScalarMultiplicationArgument / 2 == new Vector3(2.5f, 2.0f, 1.5f)); Assert.IsTrue(2 / ScalarMultiplicationArgument == new Vector3(2.5f, 2.0f, 1.5f)); Vector3 Point3 = new Vector3(12, 18, 24); Point3 /= 6; Assert.IsTrue(Point3.Equals(new Vector3(2, 3, 4), .01f)); }
void FixedUpdate() { targetPosition = GetComponent<BubbleExplorer>().targetPosition; if (!targetPosition.Equals(lastTargetPosition)) { lastTargetPosition = targetPosition; PathRequestManager.RequestPath(transform.position, targetPosition, OnPathFound); // ListPathRequestManager.RequestPath(transform.position, targetPosition, grid.unwalkable, new List<Node>(),OnPathFound); path = null; } else { if (path != null && Vector3.Distance(transform.position, targetPosition) > 0.05f) { if (Vector3.Distance(transform.position, currentWayPoint + height) < 0.05f) { targetIndex++; currentWayPoint = path[targetIndex]; } if (!recheckPath()) { PathRequestManager.RequestPath(transform.position, targetPosition, OnPathFound); //ListPathRequestManager.RequestPath(transform.position, targetPosition, grid.unwalkable,grid.dynamicUnwalkable, OnPathFound); path = null; } else { float angle = Vector3.Angle(transform.forward, (currentWayPoint) + height - transform.position); bool posDir = (Vector3.Angle(transform.right, (currentWayPoint) + height - transform.position) > 90); int rot = Mathf.RoundToInt(angle / rotationUnit); if (rot > maxRotationSpeed) { rot = maxRotationSpeed; } Quaternion deltaRotation; if (posDir) { deltaRotation = Quaternion.Euler(0.0f, -(rot * rotationUnit), 0.0f); } else { deltaRotation = Quaternion.Euler(0.0f, (rot * rotationUnit), 0.0f); } rb.MoveRotation(rb.rotation * deltaRotation); if (Mathf.Abs(angle) < rotationDirectionDifference) { transform.position = Vector3.MoveTowards(transform.position, currentWayPoint + height, movementSpeed * Time.deltaTime); } } } } }
public JsConsole(Game1 game, Vector3 pos, Vector3 dir) : base() { this.game = game; this.pos = pos; minigame = game.minigame; instance = new MgInstance(game, minigame); ship = game.ship; this.dir = dir; successAtActivate = -1; interactRange = new CircleCollider(this.pos + dir * 16, 3); interestRange = new CircleCollider(this.pos + dir * 16, 20); model = new JsConsoleModel(this, game); game.modelManager.addObject(model); nodePos = new Vector2((int)((this.pos.X / 30) + 0.5f), (int)((this.pos.Z / 30) + 0.5f)); destroying = false; cardCount = 0; consolePos = pos + dir * 15; consolePos.Y = 4.5f; cols = new List<OOBB>(); cols.Add(new OOBB(consolePos + dir*1, dir, 5, 1, dir)); cols.Add(new OOBB(consolePos + dir*-1, dir, 5, 1, -dir)); cols.Add(new OOBB(consolePos + Vector3.Cross(dir, Vector3.Up) * -2f, dir, 2, 1, Vector3.Cross(-dir, Vector3.Up))); cols.Add(new OOBB(consolePos + Vector3.Cross(-dir, Vector3.Up) * -2f, dir, 2, 1, Vector3.Cross(dir, Vector3.Up))); cols.Add(new OOBB(pos + dir * 13, dir, 30, 1, dir)); if(dir.Equals(Vector3.Left) || dir.Equals(Vector3.Right)) { forcefield = new ForcefieldDrill(game, pos + dir * 13, 1); } else { forcefield = new ForcefieldDrill(game, pos + dir * 13, 0); } game.modelManager.addAdditive(forcefield); }
static bool TestOne(double Tx, double Ty, double Tz, double Rx, double Ry, double Rz, double Sx, double Sy, double Sz) { Vector3 UnitVectorY = new Vector3(0.0f, 1.0f, 0.0f); Vector3 v1 = new Vector3(); v1 = UnitVectorY; Matrix4X4 NormalMatrix = Matrix4X4.Identity; Matrix4X4 InverseMatrixFromNormalMatrix = Matrix4X4.Identity; Matrix4X4 InverseMatrixCalculated = Matrix4X4.Identity; NormalMatrix.PrepareMatrix(Tx, Ty, Tz, Rx, Ry, Rz, Sx, Sy, Sz); NormalMatrix.TransformVector(ref v1); InverseMatrixFromNormalMatrix.SetToInverse(NormalMatrix); InverseMatrixFromNormalMatrix.TransformVector(ref v1); // make sure they are the same within an error range Assert.IsTrue(v1.Equals(UnitVectorY, .01f)); NormalMatrix.TransformVector(ref v1); InverseMatrixCalculated.PrepareInvMatrix(-Tx, -Ty, -Tz, -Rx, -Ry, -Rz, 1.0f/Sx, 1.0f/Sy, 1.0f/Sz); InverseMatrixCalculated.TransformVector(ref v1); // make sure they are the same within an error range Assert.IsTrue(v1.Equals(UnitVectorY, .001f)); // And just a bit more checking [7/26/2001] LBB // and now just check that TransformVector is always working NormalMatrix.PrepareMatrix(Tx, Ty, Tz, Rx, Ry, Rz, Sx, Sy, Sz); NormalMatrix.TransformVector3X3(ref v1); InverseMatrixCalculated.PrepareInvMatrix(-Tx, -Ty, -Tz, -Rx, -Ry, -Rz, 1.0f/Sx, 1.0f/Sy, 1.0f/Sz); InverseMatrixCalculated.TransformVector3X3(ref v1); Assert.IsTrue(v1.Equals(UnitVectorY, .001f)); NormalMatrix.PrepareMatrix(Tx, Ty, Tz, Rx, Ry, Rz, Sx, Sy, Sz); NormalMatrix.TransformVector3X3(ref v1); InverseMatrixCalculated.SetToInverse(NormalMatrix); InverseMatrixCalculated.TransformVector3X3(ref v1); Assert.IsTrue(v1.Equals(UnitVectorY, .001f)); return true; }
public void ScalarMultiplication() { Vector3 ScalarMultiplicationArgument = new Vector3(5.0f, 4.0f, 3.0f); Assert.IsTrue(ScalarMultiplicationArgument * -.5 == -new Vector3(2.5f, 2.0f, 1.5f)); Assert.IsTrue(-.5 * ScalarMultiplicationArgument == -new Vector3(2.5f, 2.0f, 1.5f)); Assert.IsTrue(5 * ScalarMultiplicationArgument == new Vector3(25.0f, 20.0f, 15.0f)); Vector3 Point3 = new Vector3(2, 3, 4); Point3 *= 6; Assert.IsTrue(Point3.Equals(new Vector3(12, 18, 24), .01f)); }
void setColor(Vector3 seb) { if (seb.Equals(Vector3.zero)) { if (getViewCount(VIS_DIST) != 0) { gameObject.GetComponent<Renderer>().material.color = Color.white; } else { gameObject.GetComponent<Renderer>().material.color = Color.blue; } } else { gameObject.GetComponent<Renderer>().material.color = Color.red; } }
public override void CmdActivate(Arguments args) { if (!isOnCooldown()) // check if we can cast it { Vector3 point = new Vector3(); if (!point.Equals(new Vector3())) { startCooldown(); Cmdspawnit(point); } } }
public static Vector3[] OffsetPoints (this Vector3[] points, Vector3 offset) { if (offset.Equals (Vector3.zero)) return points; // Make a flat clone of the original array var ofsPoints = Enumerable.Repeat (Vector3.zero, points.Length).ToArray (); Array.Copy (points, ofsPoints, points.Length); for (int i = 0; i < ofsPoints.Length; i++) { ofsPoints[i] = ofsPoints[i] + offset; } return ofsPoints; }
void OnEnable() { scriptTarget = (Direction) target; rotationEuler = toVector3(scriptTarget.rotation); rotationEuler.x = (float) decimal.Round((decimal) rotationEuler.x, 2, MidpointRounding.AwayFromZero); rotationEuler.y = (float) decimal.Round((decimal) rotationEuler.y, 2, MidpointRounding.AwayFromZero); rotationEuler.z = (float) decimal.Round((decimal) rotationEuler.z, 2, MidpointRounding.AwayFromZero); useDefault = rotationEuler.Equals(DirectionUtil.getDefaultEulerAngles(scriptTarget.direction)) || rotationEuler.magnitude == 0; }
private void scaleFromPosition(Vector3 scale, Vector3 fromPos) { if(!fromPos.Equals(prevPos)) { Vector3 prevParentPos = transform.position; transform.position = fromPos; Vector3 diff = transform.position - prevParentPos; Vector3 pos = new Vector3(diff.x/transform.localScale.x*-1, diff.y/transform.localScale.y*-1, transform.position.z); transform.localPosition = new Vector3(transform.localPosition.x + pos.x, transform.localPosition.y+pos.y, pos.z); } transform.localScale = scale; prevPos = fromPos; }
// void GeneraRotacion( Vector3 vectorAux ) { if (vectorAux.Equals(Vector3.zero)) return; float dot = Vector3.Dot(this.transform.up,vectorAux); if (dot < 0.05 && dot > -0.05) { Vector3 cross = Vector3.Cross(this.transform.up, vectorAux); float angulo = Vector3.Angle(this.transform.up, vectorAux); print(string.Format("{0} {1} {2}", dot, cross, angulo)); this.transform.eulerAngles += new Vector3(0f, 0f, angulo * (cross.z < 0 ? -1 : 1)); } }
public virtual void Draw(Vector3 vec) { if (!isPlaying) { root.transform.localPosition = vec; timer += Time.deltaTime; if (!vec.Equals (Vector3.zero)) strokeUtils.addToTrail (Trail, trailHead, vec); trailToLine (0,trailHead); if (timer > trailLength) strokeUtils.shiftArray (Trail, trailHead);// trail.RemoveAt (0); else { trailHead++; playbackHead++; } } }
public static Vector3 getDistanceBetweenPoint(Vector3 point1, Vector3 point2, Vector3 direction) { if (point1.Equals(point2)) { return Vector3.Zero; } else { Vector3 distance = point2 - point1; Vector3 normalizedDistance = distance; normalizedDistance.Normalize(); float dotProduct = Vector3.Dot(normalizedDistance, direction); return dotProduct * direction * distance.Length(); } }
// Update is called once per frame void FixedUpdate() { rigidbody.isKinematic = false; Vector3 targetVelocity = new Vector3 (Input.GetAxis ("Horizontal"), 0, Input.GetAxis ("Vertical")); if (targetVelocity.Equals(new Vector3(0,0,0))) { footstepSound.SetActive(false); } else { footstepSound.SetActive(true); } if (targetVelocity.magnitude > targetVelocity.normalized.magnitude) { targetVelocity = targetVelocity.normalized; // Prevents a faster movement when two keys are pressed } float modifiedspeed = speed; if (Input.GetButton ("Run")) // Running, the key must be held down { modifiedspeed *= 1.5f; } targetVelocity = transform.TransformDirection (targetVelocity); targetVelocity *= modifiedspeed*Time.deltaTime; rigidbody.MovePosition(rigidbody.position+targetVelocity); // Alternative movement //rigidbody.AddForce (targetVelocity, ForceMode.VelocityChange); if (Input.GetButton("Jump") && grounded) { rigidbody.AddForce (new Vector3(0,jumpSpeed,0),ForceMode.VelocityChange); } if (!grounded) { rigidbody.AddForce (new Vector3(0,-moregravity,0), ForceMode.VelocityChange); } grounded = false; }
private void moveStick(String position) { String[] coordonees = position.Split(':'); tmp = new Vector3(int.Parse(coordonees[2]),int.Parse(coordonees[1]),int.Parse(coordonees[0])); if(!tmp.Equals(newPosition)){ oldPosition = newPosition; newPosition = tmp; Vector3 mvt = newPosition - oldPosition; X.Enqueue (mvt.x); Y.Enqueue (mvt.y); Z.Enqueue(mvt.z); if (X.Count > 5) { X.Dequeue (); Y.Dequeue (); Z.Dequeue (); } gameObject.transform.Translate (-mvt.x*0.0000f, -mvt.y*0.005f, -mvt.z*0.005f); } }
public override void Draw(Vector3 vec) { if (!isPlaying) { timer += Time.deltaTime; if(!vec.Equals(Vector3.zero)) strokeUtils.addToTrail (Trail, trailHead, vec); trailToLine (0,trailHead); makeSubTrail (); foreach (GameObject t in subTrails) { Stroke s = t.GetComponent<Stroke> (); strokeUtils.addToTrail (s.Trail, ++s.trailHead, Trail [trailHead]); } trailHead++; } }
public override void Draw(Vector3 vec) { if (!isPlaying) { root.transform.localPosition = vec; timer += Time.deltaTime; if(!vec.Equals(Vector3.zero)) strokeUtils.addToTrail (Trail, trailHead, vec); // trail.Add (vec); trailToLine (0,trailHead); // Debug.Log (timer+","+trailLength + "," + subTrails.Count); makeSubTrail (); foreach (GameObject t in subTrails) { Stroke s = t.GetComponent<Stroke> (); strokeUtils.addToTrail (s.Trail, ++s.trailHead, Trail [trailHead]); // t.GetComponent<Stroke> ().trail.Add (trail[trail.Count-1]); } trailHead++; // Debug.Log (trailHead); // if (timer > trailLength) { // timer = 0; //// Debug.Log (timer+" , "+trailLength + " , " + subTrails.Count); // subTrails.Add (Instantiate (bGlobals.strokes[0])); // subTrails[subTrails.Count-1].GetComponent<Stroke>().trail = trail; // subTrails [subTrails.Count - 1].GetComponent<Stroke> ().playButton (); // // } // foreach (GameObject t in subTrails) { //// subTrails [subTrails.Count - 1].GetComponent<Stroke> (). // subTrails [subTrails.Count - 1].GetComponent<Stroke> ().trail.Add (vec); // subTrails [subTrails.Count - 1].GetComponent<Stroke> ().playBack (); // } } // foreach (GameObject s in subTrails) { // s.GetComponent<Stroke> ().Draw (); // } }
// Update is called once per frame void Update() { if (!stopped) { if (!inTransit) { inTransit = true; v = pvm.checkSandPosition (transform.position.x, transform.position.y, transform.position.z); if (v.Equals(transform.position)) { stopped = true; if(pvm.addBlock(transform.position.x - 0.5f,transform.position.y + 0.5f,3)){ Debug.Log ("added"); Destroy(gameObject); } //couldn't add, better move up v = transform.position + Vector3.up; stopped = false; } } else { transform.position = Vector3.Lerp (transform.position, v, speed * Time.deltaTime); //lerp to position if(Vector3.Distance(transform.position,v) <= 0.2f){ inTransit = false; } } } }
public bool Equals(Transform other) { return(position.Equals(other.position) && rotation.Equals(other.rotation) && scale.Equals(other.scale)); }
public bool Equals(Circle3 other) { return(center.Equals(other.center) && normal.Equals(other.normal) && radius.Equals(other.radius)); }
private void HoverCamera() { if (!tiltAngle.Equals(currentTiltAngle) || !panAngle.Equals(currentPanAngle) || !target.Equals(pos)) { if (wrapPanAngle) { if (panAngle < 0) { currentPanAngle += panAngle % 360 + 360 - panAngle; panAngle = panAngle % 360 + 360; } else { currentPanAngle += panAngle % 360 - panAngle; panAngle = panAngle % 360; } while (panAngle - currentPanAngle < -180) { currentPanAngle -= 360; } while (panAngle - currentPanAngle > 180) { currentPanAngle += 360; } } if (interpolate) { currentTiltAngle += (tiltAngle - currentTiltAngle) / (steps + 1); currentPanAngle += (panAngle - currentPanAngle) / (steps + 1); } else { currentPanAngle = panAngle; currentTiltAngle = tiltAngle; } //snap coords if angle differences are close if ((Mathf.Abs(tiltAngle - currentTiltAngle) < 0.01) && (Mathf.Abs(panAngle - currentPanAngle) < 0.01)) { currentTiltAngle = tiltAngle; currentPanAngle = panAngle; } if (MainCamera is null) { return; } pos.x = target.x + distance * Mathf.Sin(currentPanAngle * Mathf.Deg2Rad) * Mathf.Cos(currentTiltAngle * Mathf.Deg2Rad); pos.z = target.z + distance * Mathf.Cos(currentPanAngle * Mathf.Deg2Rad) * Mathf.Cos(currentTiltAngle * Mathf.Deg2Rad); pos.y = target.y + distance * Mathf.Sin(currentTiltAngle * Mathf.Deg2Rad) * yFactor; MainCamera.transform.position = pos; MainCamera.transform.LookAt(target); } }
// Update is called once per frame void Update () { if (Input.GetKeyDown (KeyCode.Q)) testKey = true; if (Input.GetKey (KeyCode.Escape)) { file.Close (); Application.Quit(); } vCur = transform.rotation * Vector3.forward; //file.WriteLine("cur dis:\t" + Vector3.Distance (vLast, vCur)); vLast = vCur; if(tc.isReadyToMove){ // move according to invisible tracked objects if(!lastRefPosition.Equals(new Vector3(0,0,0))){ drawRays(); // test rotation // move as reference move if (testKey) { // do it every 10 frames ++count; if (count != debugCount) { return; } count = 0; testKey = true; vCur = transform.rotation * Vector3.forward; print ("update:\tvCur:\t" + vCur.ToString ("F4") ); print ("update:\tangle:\t" + Vector3.Angle (vLast, vCur)); // write to the file //file.WriteLine("cur angle:\t" + Vector3.Angle (vLast, vCur)); //file.WriteLine("cur dis:\t" + Vector3.Distance (vLast, vCur)); vLast = vCur; switch (step) { case 0: if (isCloseEnough ()) step = 0; else { if (turnRound ()) { ++step; // for test //step = 0; } } break; case 1: if (goStraight ()) { ++step; } else step = 0; break; case 2: if (isCloseEnough ()) { // do not need to turn to the right face step = 0; } break; case 3: turnBack (); if(isCloseEnough()) // do not need to turn to the right face step = 0; break; case 4: if (turnFace ()) { step = 0; } break; default: break; } } } //testKey = false; lastRefPosition = referenceObj.transform.position; lastRefRotation = referenceObj.transform.rotation; lastPosition = transform.position; lastRotation = transform.rotation; //print ("pos:\t" + transform.position); //testKey = false; } }
/// <summary>Indicates whether the current object is equal to another object of the same type.</summary> /// <param name="other">An object to compare with this object.</param> /// <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns> public bool Equals(VertexPositionNormalTexture other) { return(Position.Equals(other.Position) && Normal.Equals(other.Normal) && TextureCoordinate.Equals(other.TextureCoordinate)); }
/// <inheritdoc /> public unsafe override int BuildVertexBuffer(ParticleVertexBuilder vtxBuilder, Vector3 invViewX, Vector3 invViewY, ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ParticleSorter sorter) { // Update the curve samplers if required base.BuildVertexBuffer(vtxBuilder, invViewX, invViewY, ref spaceTranslation, ref spaceRotation, spaceScale, sorter); SamplerRotation?.UpdateChanges(); // Get all the required particle fields var positionField = sorter.GetField(ParticleFields.Position); if (!positionField.IsValid()) { return(0); } var lifeField = sorter.GetField(ParticleFields.Life); var sizeField = sorter.GetField(ParticleFields.Size); var angleField = sorter.GetField(ParticleFields.Angle); var hasAngle = angleField.IsValid() || (SamplerRotation != null); // Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors var trsIdentity = (spaceScale == 1f); trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0))); trsIdentity = trsIdentity && (spaceRotation.Equals(new Quaternion(0, 0, 0, 1))); var renderedParticles = 0; var posAttribute = vtxBuilder.GetAccessor(VertexAttributes.Position); var texAttribute = vtxBuilder.GetAccessor(vtxBuilder.DefaultTexCoords); foreach (var particle in sorter) { var centralPos = GetParticlePosition(particle, positionField, lifeField); var particleSize = GetParticleSize(particle, sizeField, lifeField); if (!trsIdentity) { spaceRotation.Rotate(ref centralPos); centralPos = centralPos * spaceScale + spaceTranslation; particleSize *= spaceScale; } // Use half size to make a Size = 1 result in a Billboard of 1m x 1m var unitX = invViewX * (particleSize * 0.5f); var unitY = invViewY * (particleSize * 0.5f); // Particle rotation. Positive value means clockwise rotation. if (hasAngle) { var rotationAngle = GetParticleRotation(particle, angleField, lifeField); var cosA = (float)Math.Cos(rotationAngle); var sinA = (float)Math.Sin(rotationAngle); var tempX = unitX * cosA - unitY * sinA; unitY = unitY * cosA + unitX * sinA; unitX = tempX; } var particlePos = centralPos - unitX + unitY; var uvCoord = new Vector2(0, 0); // 0f 0f vtxBuilder.SetAttribute(posAttribute, (IntPtr)(&particlePos)); vtxBuilder.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); vtxBuilder.NextVertex(); // 1f 0f particlePos += unitX * 2; uvCoord.X = 1; vtxBuilder.SetAttribute(posAttribute, (IntPtr)(&particlePos)); vtxBuilder.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); vtxBuilder.NextVertex(); // 1f 1f particlePos -= unitY * 2; uvCoord.Y = 1; vtxBuilder.SetAttribute(posAttribute, (IntPtr)(&particlePos)); vtxBuilder.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); vtxBuilder.NextVertex(); // 0f 1f particlePos -= unitX * 2; uvCoord.X = 0; vtxBuilder.SetAttribute(posAttribute, (IntPtr)(&particlePos)); vtxBuilder.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); vtxBuilder.NextVertex(); renderedParticles++; } var vtxPerShape = 4 * QuadsPerParticle; return(renderedParticles * vtxPerShape); }
void Update() { // membatalkan proses penggambaran saat proses panning/zooming if (Input.touchCount >= 2) { // membersihkan tampilan temporary ClearColor(ref this.temporaryTexture); this.temporaryTexture.Apply(); // reset garis poligon yang sedang dibuat this.lineCount = 0; // reset bentuk yang sedang digambar this.currentDrawnShape = null; return; } RaycastHit hit; if (!Physics.Raycast(cam.ScreenPointToRay(Input.mousePosition), out hit)) { return; } Renderer rend = hit.transform.GetComponent <Renderer>(); MeshCollider meshCollider = hit.collider as MeshCollider; if (rend == null || rend.sharedMaterial == null || rend.sharedMaterial.mainTexture == null || meshCollider == null) { return; } // jangan proses jika posisi mouse masih sama dengan posisi terakhir if (Vector3.Equals(hit.textureCoord, lastPixelPosition)) { return; } Vector2 pixelUV = hit.textureCoord; Texture2D tex = rend.material.mainTexture as Texture2D; pixelUV.x *= tex.width; pixelUV.y *= tex.height; // Menerima input mouse pertama ditekan if (Input.GetMouseButtonDown(0)) { startDownPos = pixelUV; switch (this.CurrentDrawingMode) { case DrawingMode.Line: currentDrawnShape = new ShapeModel(); currentDrawnShape.Mode = DrawingMode.Line; break; case DrawingMode.Triangle: // posisi awal menekan mouse if (lineCount == 0) { currentDrawnShape = new ShapeModel(); currentDrawnShape.Mode = DrawingMode.Triangle; startTrianglePos = startDownPos; // tambahkan data titik awal currentDrawnShape.Vertices.Add(pixelUV); } break; case DrawingMode.Rectangle: currentDrawnShape = new ShapeModel(); currentDrawnShape.Mode = DrawingMode.Rectangle; // data titik awal gambar segi empat currentDrawnShape.Vertices.Add(new Vector2(startDownPos.x, startDownPos.y)); currentDrawnShape.Vertices.Add(new Vector2(pixelUV.x, startDownPos.y)); currentDrawnShape.Vertices.Add(new Vector2(pixelUV.x, pixelUV.y)); currentDrawnShape.Vertices.Add(new Vector2(startDownPos.x, pixelUV.y)); break; } } // Menerima input mouse sedang ditekan if (Input.GetMouseButton(0)) { switch (this.CurrentDrawingMode) { case DrawingMode.Line: tempTargetRender.gameObject.SetActive(true); if (hit.transform == tempTargetRender.transform) { ClearColor(ref temporaryTexture); DrawBresenhamLine(ref temporaryTexture, (int)startDownPos.x, (int)startDownPos.y, (int)pixelUV.x, (int)pixelUV.y); } break; case DrawingMode.Triangle: tempTargetRender.gameObject.SetActive(true); if (lineCount == 0 && (startDownPos.x != pixelUV.x && startDownPos.y != pixelUV.y)) { lastMouseUpPos = startDownPos; lineCount = 1; // tambahkan data titik baru currentDrawnShape.Vertices.Add(pixelUV); } if (currentDrawnShape.Vertices.Count > 0) { currentDrawnShape.Vertices[currentDrawnShape.Vertices.Count - 1] = pixelUV; } break; case DrawingMode.Rectangle: tempTargetRender.gameObject.SetActive(true); break; } } // Menerima input ketika mouse diangkat if (Input.GetMouseButtonUp(0) && currentDrawnShape != null) { switch (this.CurrentDrawingMode) { // menggambar garis case DrawingMode.Line: // menambahkan titik awal currentDrawnShape.Vertices.Add(startDownPos); // menambahkan titik akhir currentDrawnShape.Vertices.Add(pixelUV); // menyimpan data gambar ShapeModels.Add(currentDrawnShape); // reset data yang sedang digambar currentDrawnShape = null; break; // menggambar segitiga case DrawingMode.Triangle: // menghitung jumlah garis yang sudah digambar // indeks titik 0, 1, dan 2 if (lineCount < 2) { if (lineCount == 0 && (startDownPos.x != pixelUV.x && startDownPos.y != pixelUV.y)) { lineCount = 1; } else { lineCount++; // tambahkan data titik baru currentDrawnShape.Vertices.Add(pixelUV); } } else { // tambahkan data gambar ShapeModels.Add(currentDrawnShape); // reset indeks garis lineCount = 0; // reset data yang sedang digambar currentDrawnShape = null; } break; // menggambar segi empat case DrawingMode.Rectangle: currentDrawnShape.Vertices[0] = new Vector2(startDownPos.x, startDownPos.y); currentDrawnShape.Vertices[1] = new Vector2(pixelUV.x, startDownPos.y); currentDrawnShape.Vertices[2] = new Vector2(pixelUV.x, pixelUV.y); currentDrawnShape.Vertices[3] = new Vector2(startDownPos.x, pixelUV.y); // tambahkan data gambar persegi ShapeModels.Add(currentDrawnShape); // reset data yang sedang digambar currentDrawnShape = null; break; } lastMouseUpPos = pixelUV; ClearColor(ref temporaryTexture); RenderShapes(ref targetTexture); } // Preview update if (currentDrawnShape != null && currentDrawnShape.Vertices.Count > 0) { Vector2 vertex1, vertex2; switch (this.CurrentDrawingMode) { case DrawingMode.Triangle: // titik yang sedang digerakkan currentDrawnShape.Vertices[currentDrawnShape.Vertices.Count - 1] = pixelUV; break; case DrawingMode.Rectangle: currentDrawnShape.Vertices[0] = new Vector2(startDownPos.x, startDownPos.y); currentDrawnShape.Vertices[1] = new Vector2(pixelUV.x, startDownPos.y); currentDrawnShape.Vertices[2] = new Vector2(pixelUV.x, pixelUV.y); currentDrawnShape.Vertices[3] = new Vector2(startDownPos.x, pixelUV.y); break; } // proses menggambar garis-garis preview ClearColor(ref temporaryTexture); for (int itVertex = 0; itVertex < currentDrawnShape.Vertices.Count - 1; itVertex++) { if (itVertex < currentDrawnShape.Vertices.Count - 1) { vertex1 = currentDrawnShape.Vertices[itVertex]; vertex2 = currentDrawnShape.Vertices[itVertex + 1]; int x1 = (int)vertex1.x; int y1 = (int)vertex1.y; int x2 = (int)vertex2.x; int y2 = (int)vertex2.y; // garis penghubung DrawBresenhamLine(ref temporaryTexture, x1, y1, x2, y2); } } switch (this.CurrentDrawingMode) { case DrawingMode.Rectangle: // garis penghubung terakhir untuk gambar segi empat vertex1 = currentDrawnShape.Vertices[currentDrawnShape.Vertices.Count - 1]; vertex2 = currentDrawnShape.Vertices[0]; int x1 = (int)vertex1.x; int y1 = (int)vertex1.y; int x2 = (int)vertex2.x; int y2 = (int)vertex2.y; DrawBresenhamLine(ref temporaryTexture, x1, y1, x2, y2); break; } } lastPixelPosition = hit.textureCoord; tex.Apply(); }
public bool IsNull() => pos.Equals(Vector3.zero) && rot.Equals(Quaternion.identity);
/// <summary> /// Spawns a new Instance in the Gameworld and registers itself to the Static Database /// </summary> /// <param name="editing"></param> /// <param name="bPreview"></param> internal void SpawnObject(Boolean editing = false, Boolean bPreview = false) { // mangle Squads statics if (model.isSquad) { InstanceUtil.MangleSquadStatic(this); } // Objects spawned at runtime should be active, ones spawned at loading not InstanceUtil.SetActiveRecursively(this, editing); Transform[] gameObjectList = gameObject.GetComponentsInChildren <Transform>(); List <GameObject> rendererList = (from t in gameObjectList where t.gameObject.GetComponent <Renderer>() != null select t.gameObject).ToList(); InstanceUtil.SetLayerRecursively(this, 15); if (bPreview && editing) { this.ToggleAllColliders(false); } this.preview = bPreview; if (editing) { KerbalKonstructs.instance.selectObject(this, true, true, bPreview); } InstanceUtil.CreateGroupCenterIfMissing(this); groupCenter = StaticDatabase.allCenters[groupCenterName]; if (RelativePosition.Equals(Vector3.zero)) { Log.Normal("LegacySpawnInstance called for " + configPath); LegacySpawnInstance(); gameObject.transform.parent = groupCenter.gameObject.transform; pqsCity.enabled = false; pqsCity.sphere = null; pqsCity = null; RelativePosition = gameObject.transform.localPosition; Orientation = gameObject.transform.localEulerAngles; } else { gameObject.transform.position = groupCenter.gameObject.transform.position; gameObject.transform.parent = groupCenter.gameObject.transform; gameObject.transform.localPosition = RelativePosition; gameObject.transform.localEulerAngles = Orientation; } //Scaling origScale = gameObject.transform.localScale; // save the original scale for later use gameObject.transform.localScale *= ModelScale; RefLatitude = (float)CelestialBody.GetLatitudeAndLongitude(gameObject.transform.position).x; RefLongitude = (float)(CelestialBody.GetLatitudeAndLongitude(gameObject.transform.position).y); RadialPosition = radialPosition; foreach (StaticModule module in model.modules) { Type moduleType = AssemblyLoader.loadedAssemblies.SelectMany(asm => asm.assembly.GetTypes()).FirstOrDefault(t => t.Namespace == module.moduleNamespace && t.Name == module.moduleClassname); StaticModule mod = gameObject.AddComponent(moduleType) as StaticModule; if (mod != null) { mod.staticInstance = this; foreach (string fieldName in module.moduleFields.Keys) { FieldInfo field = mod.GetType().GetField(fieldName); if (field != null) { field.SetValue(mod, Convert.ChangeType(module.moduleFields[fieldName], field.FieldType)); } else { Log.UserWarning("Field " + fieldName + " does not exist in " + module.moduleClassname); } } } else { Log.UserError("Module " + module.moduleClassname + " could not be loaded in " + gameObject.name); } } foreach (GameObject gorenderer in rendererList) { gorenderer.GetComponent <Renderer>().enabled = true; } StaticDatabase.AddStatic(this); // Add them to the bodys objectlist, so they show up as anomalies // After we got a new Name from StaticDatabase.AddStatic() if (isScanable) { Log.Normal("Added " + gameObject.name + " to scanable Objects"); var pqsObjectList = CelestialBody.pqsSurfaceObjects.ToList(); if (!pqsObjectList.Contains((PQSSurfaceObject)groupCenter.pqsCity)) { pqsObjectList.Add(groupCenter.pqsCity as PQSSurfaceObject); } CelestialBody.pqsSurfaceObjects = pqsObjectList.ToArray(); } }
/// <summary>Returns a value indicating whether this <see cref="BoundingSphere"/> equals another <see cref="BoundingSphere"/>.</summary> /// <param name="other">A <see cref="BoundingSphere"/>.</param> /// <returns>Returns true if the bounding spheres are equal, otherwise returns false.</returns> public bool Equals(BoundingSphere other) { return((Radius == other.Radius) && Center.Equals(ref other.Center)); }
void Update() { if (petrol > startingPetrol && !boss) { petrol = startingPetrol; } if (petrol < 0) { petrol = 0; } if (petrol > 0) { fuelGuage.transform.GetChild(0).GetComponent <Image>().color = Color.white; } if (petrol == 0) { fuelGuage.transform.GetChild(0).GetComponent <Image>().color = new Color(0.4f, 0.4f, 0.4f); } //CHEAT if (Input.GetKeyDown(KeyCode.F5)) { AddFuel(); } if (isMoving && time > 0) { time -= Time.deltaTime; } if (isMoving && time < 0) { petrol--; fuelGuage.value = petrol; time = 0.5f; } if (Input.GetButtonDown("Submit") && allowed2 && (!vanFull || GetPlayer().Equals(GameManager.playerTwo))) { startDriving = !startDriving; endStartDrivingBool = false; indicatorText2.gameObject.GetComponent <TextMeshPro>().enabled = false; SetPlayer(GameManager.playerTwo); } if (Input.GetKeyDown(KeyCode.F) && allowed1 && (!vanFull || GetPlayer().Equals(GameManager.playerOne))) { startDriving = !startDriving; endStartDrivingBool = false; indicatorText1.gameObject.GetComponent <TextMeshPro>().enabled = false; SetPlayer(GameManager.playerOne); } { if (startDriving && !endStartDrivingBool) { driving = true; DriveStart(GetPlayer()); endStartDrivingBool = true; } if (!startDriving && !endStartDrivingBool) { driving = false; DriveEnd(GetPlayer()); endStartDrivingBool = true; } } if (driving && petrol > 0) { Vector3 movement = GameManager.GetMovementVectorForControlScheme(playerInVan.GetComponent <PlayerController>().controlScheme, 1.0f / Time.deltaTime); if (movement.Equals(Vector3.zero)) { isMoving = false; } else { isMoving = true; } van.transform.Rotate(Vector3.up * movement.x * steering); //was h van.transform.position += transform.up * movement.z * acceleration * Time.deltaTime; //was v } }
public bool IsFacingDirection(Vector3 direction) { return(direction.Equals(m_currentDirection)); }
protected virtual void FixedUpdate() { HandleFalling(); // If Move In Place is currently engaged. if (active && !currentlyFalling) { // Initialize the list average. float listAverage = 0; foreach (Transform trackedObj in trackedObjects) { // Get the amount of Y movement that's occured since the last update. float deltaYPostion = Mathf.Abs(previousYPositions[trackedObj] - trackedObj.transform.localPosition.y); // Convenience code. List <float> trackedObjList = movementList[trackedObj]; // Cap off the speed. if (deltaYPostion > sensitivity) { trackedObjList.Add(sensitivity); } else { trackedObjList.Add(deltaYPostion); } // Keep our tracking list at m_averagePeriod number of elements. if (trackedObjList.Count > averagePeriod) { trackedObjList.RemoveAt(0); } // Average out the current tracker's list. float sum = 0; foreach (float diffrences in trackedObjList) { sum += diffrences; } float avg = sum / averagePeriod; // Add the average to the the list average. listAverage += avg; } float speed = ((speedScale * 350) * (listAverage / trackedObjects.Count)); if (speed > maxSpeed && maxSpeed >= 0) { speed = maxSpeed; } direction = Vector3.zero; // If we're doing a decoupling method... if (directionMethod == DirectionalMethod.SmartDecoupling || directionMethod == DirectionalMethod.DumbDecoupling) { // If we haven't set an inital gaze yet, set it now. // If we're doing dumb decoupling, this is what we'll be sticking with. if (initalGaze.Equals(Vector3.zero)) { initalGaze = new Vector3(headset.forward.x, 0, headset.forward.z); } // If we're doing smart decoupling, check to see if we want to reset our distance. if (directionMethod == DirectionalMethod.SmartDecoupling) { bool closeEnough = true; float curXDir = headset.rotation.eulerAngles.y; if (curXDir <= smartDecoupleThreshold) { curXDir += 360; } closeEnough = closeEnough && (Mathf.Abs(curXDir - controllerLeftHand.transform.rotation.eulerAngles.y) <= smartDecoupleThreshold); closeEnough = closeEnough && (Mathf.Abs(curXDir - controllerRightHand.transform.rotation.eulerAngles.y) <= smartDecoupleThreshold); // If the controllers and the headset are pointing the same direction (within the threshold) reset the direction the player's moving. if (closeEnough) { initalGaze = new Vector3(headset.forward.x, 0, headset.forward.z); } } direction = initalGaze; } // if we're doing controller rotation movement else if (directionMethod.Equals(DirectionalMethod.ControllerRotation)) { direction = DetermineAverageControllerRotation() * Vector3.forward; } // Otherwise if we're just doing Gaze movement, always set the direction to where we're looking. else if (directionMethod.Equals(DirectionalMethod.Gaze)) { direction = (new Vector3(headset.forward.x, 0, headset.forward.z)); } // Update our current speed. currentSpeed = speed; } else if (currentSpeed > 0f) { currentSpeed -= (currentlyFalling ? fallingDeceleration : deceleration); } else { currentSpeed = 0f; direction = Vector3.zero; } foreach (Transform trackedObj in trackedObjects) { // Get delta postions and rotations previousYPositions[trackedObj] = trackedObj.transform.localPosition.y; } Vector3 movement = (direction * currentSpeed) * Time.fixedDeltaTime; if (playArea) { playArea.position = new Vector3(movement.x + playArea.position.x, playArea.position.y, movement.z + playArea.position.z); } }
//------------------------------------------------- // Computes the angle to rotate the game object based on the change in the transform //------------------------------------------------- private void ComputeAngle(Hand hand) { Vector3 toHandProjected = ComputeToTransformProjected(hand.hoverSphereTransform); if (!toHandProjected.Equals(lastHandProjected)) { float absAngleDelta = Vector3.Angle(lastHandProjected, toHandProjected); if (absAngleDelta > 0.0f) { if (frozen) { float frozenSqDist = (hand.hoverSphereTransform.position - frozenHandWorldPos).sqrMagnitude; if (frozenSqDist > frozenSqDistanceMinMaxThreshold.x) { outAngle = frozenAngle + Random.Range(-1.0f, 1.0f); float magnitude = Util.RemapNumberClamped(frozenSqDist, frozenSqDistanceMinMaxThreshold.x, frozenSqDistanceMinMaxThreshold.y, 0.0f, 1.0f); if (magnitude > 0) { StartCoroutine(HapticPulses(hand.controller, magnitude, 10)); } else { StartCoroutine(HapticPulses(hand.controller, 0.5f, 10)); } if (frozenSqDist >= frozenSqDistanceMinMaxThreshold.y) { onFrozenDistanceThreshold.Invoke(); } } } else { Vector3 cross = Vector3.Cross(lastHandProjected, toHandProjected).normalized; float dot = Vector3.Dot(worldPlaneNormal, cross); float signedAngleDelta = absAngleDelta; if (dot < 0.0f) { signedAngleDelta = -signedAngleDelta; } if (limited) { float angleTmp = Mathf.Clamp(outAngle + signedAngleDelta, minAngle, maxAngle); if (outAngle == minAngle) { if (angleTmp > minAngle && absAngleDelta < minMaxAngularThreshold) { outAngle = angleTmp; lastHandProjected = toHandProjected; } } else if (outAngle == maxAngle) { if (angleTmp < maxAngle && absAngleDelta < minMaxAngularThreshold) { outAngle = angleTmp; lastHandProjected = toHandProjected; } } else if (angleTmp == minAngle) { outAngle = angleTmp; lastHandProjected = toHandProjected; onMinAngle.Invoke(); if (freezeOnMin) { Freeze(hand); } } else if (angleTmp == maxAngle) { outAngle = angleTmp; lastHandProjected = toHandProjected; onMaxAngle.Invoke(); if (freezeOnMax) { Freeze(hand); } } else { outAngle = angleTmp; lastHandProjected = toHandProjected; } } else { outAngle += signedAngleDelta; lastHandProjected = toHandProjected; } } } } }
public bool IsValid() { return(!playerPosition.Equals(Vector3.zero)); }
public CfgEncoder Add_IfNotOne(string tag, Vector3 v3) => v3.Equals(Vector3.one) ? this : Add(tag, v3.Encode());
//static int m_touch_num = 0; static public void Update() { bool lastUp = false; if (HasTouchDown(0)) { lastUp = true; m_deltaPos = Vector3.zero; m_downing0 = true; m_moving = false; m_slideDist = 0.0f; m_downPos = GeTouchPos(); if (Time.time - m_lastDownTime < 0.5f) { m_double = true; } else { m_double = false; } m_lastDownTime = Time.time; } if (HasTouchUp(0)) { m_downing0 = false; m_moving = false; m_deltaPos = Vector3.zero; } if (Application.isEditor) { if (HasTouchDown(1)) { //Log.Error("btn 2 down"); m_downing1 = true; } if (HasTouchUp(1)) { m_downing1 = false; } } if (m_downing0) { Vector3 pos = GeTouchPos(); if (lastUp == false && pos.Equals(m_mousePos) == false) { m_deltaPos = pos - m_mousePos; m_moving = true; } else { m_deltaPos = Vector3.zero; m_moving = false; } m_mousePos = pos; } }
private static List <T> InstantiateAgents(Transform agentParent, ICollection <Transform> agentsGoals, GameObject agentPrefab, int numberOfAgents, GameObject environmentModel, int tries = DEFAULT_TRIES, float distance = DEFAULT_DISTANCE) { if (agentsGoals.Count <= 0) { var goal = new GameObject { transform = { position = new Vector3(15f, 0f, 0f) } }; agentsGoals.Add(goal.transform); //For debug purposes, just add a valid goal } List <T> agents = new List <T>(numberOfAgents); Bounds bounds = environmentModel.CalculateRendererBounds(); for (int i = 0; i < numberOfAgents; i++) { GameObject agentGameObject = Object.Instantiate(agentPrefab, agentParent); NavMeshAgent?navAgent = agentGameObject.GetComponent <NavMeshAgent>(); if (!agentGameObject.TryGetComponent(out T agent)) { agent = agentGameObject.AddComponent <T>(); } if (agentGameObject.GetComponentDependants <NavMeshAgent>().Count == 0) { navAgent.DestroyApplicationSafe(); } bool failed = true; for (int j = 0; j < tries; j++) { Vector3 position = GetRandomPointOnNavMesh(bounds, environmentModel.transform, distance); if (position.Equals(Vector3.positiveInfinity)) { continue; } if (navAgent != null) { navAgent.Warp(position); //TODO consider doing this check in agent } else { agentGameObject.transform.position = position; } if (!SetGoal(agent, position, agentsGoals)) { continue; } failed = false; break; } if (failed) { agentGameObject.DestroyApplicationSafe(); Debug.LogWarning($"Failed to instantiate agent in a valid location after {tries} tries."); } else { agents.Add(agent); } } return(agents); }
/// <inheritdoc /> public unsafe override int BuildVertexBuffer(ref ParticleBufferState bufferState, Vector3 invViewX, Vector3 invViewY, ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ref ParticleList sorter) { // Update the curve samplers if required base.BuildVertexBuffer(ref bufferState, invViewX, invViewY, ref spaceTranslation, ref spaceRotation, spaceScale, ref sorter); // Get all the required particle fields var positionField = sorter.GetField(ParticleFields.Position); if (!positionField.IsValid()) { return(0); } var lifeField = sorter.GetField(ParticleFields.Life); var sizeField = sorter.GetField(ParticleFields.Size); var directionField = sorter.GetField(ParticleFields.Direction); // Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors var trsIdentity = (spaceScale == 1f); trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0))); trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity)); var renderedParticles = 0; var posAttribute = bufferState.GetAccessor(VertexAttributes.Position); var texAttribute = bufferState.GetAccessor(bufferState.DefaultTexCoords); Vector3 invViewZ; Vector3.Cross(ref invViewX, ref invViewY, out invViewZ); invViewZ.Normalize(); foreach (var particle in sorter) { var centralPos = GetParticlePosition(particle, positionField, lifeField); var centralOffset = (directionField.IsValid()) ? particle.Get(directionField) : new Vector3(0, 1, 0); var particleSize = GetParticleSize(particle, sizeField, lifeField); if (!trsIdentity) { spaceRotation.Rotate(ref centralPos); centralPos = centralPos * spaceScale + spaceTranslation; spaceRotation.Rotate(ref centralOffset); centralOffset = centralOffset * spaceScale; particleSize *= spaceScale; } var unitX = invViewX; var unitY = invViewY; { var centralAxis = centralOffset; float dotZ; Vector3.Dot(ref centralAxis, ref invViewZ, out dotZ); centralAxis -= invViewZ * dotZ; centralAxis.Normalize(); float dotX; Vector3.Dot(ref centralAxis, ref unitX, out dotX); float dotY; Vector3.Dot(ref centralAxis, ref unitY, out dotY); unitX = unitX * dotY - unitY * dotX; unitX.Normalize(); unitY = centralOffset; } // Use half size to make a Size = 1 result in a Billboard of 1m x 1m unitX *= (particleSize * 0.5f); if (ScaleLength) { unitY *= (LengthFactor * particleSize * 0.5f); } else { unitY *= (LengthFactor * 0.5f); } var particlePos = centralPos - unitX + unitY; var uvCoord = new Vector2(0, 0); // 0f 0f bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos)); bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); bufferState.NextVertex(); // 1f 0f particlePos += unitX * 2; uvCoord.X = 1; bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos)); bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); bufferState.NextVertex(); // 1f 1f particlePos -= unitY * 2; uvCoord.Y = 1; bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos)); bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); bufferState.NextVertex(); // 0f 1f particlePos -= unitX * 2; uvCoord.X = 0; bufferState.SetAttribute(posAttribute, (IntPtr)(&particlePos)); bufferState.SetAttribute(texAttribute, (IntPtr)(&uvCoord)); bufferState.NextVertex(); renderedParticles++; } var vtxPerShape = 4 * QuadsPerParticle; return(renderedParticles * vtxPerShape); }
private void ComputeAngle(Hand hand) { Vector3 vector = this.ComputeToTransformProjected(hand.hoverSphereTransform); if (!vector.Equals(this.lastHandProjected)) { float num = Vector3.Angle(this.lastHandProjected, vector); if (num > 0f) { if (this.frozen) { float sqrMagnitude = (hand.hoverSphereTransform.position - this.frozenHandWorldPos).sqrMagnitude; if (sqrMagnitude > this.frozenSqDistanceMinMaxThreshold.x) { this.outAngle = this.frozenAngle + UnityEngine.Random.Range(-1f, 1f); float num2 = Util.RemapNumberClamped(sqrMagnitude, this.frozenSqDistanceMinMaxThreshold.x, this.frozenSqDistanceMinMaxThreshold.y, 0f, 1f); if (num2 > 0f) { base.StartCoroutine(this.HapticPulses(hand.controller, num2, 10)); } else { base.StartCoroutine(this.HapticPulses(hand.controller, 0.5f, 10)); } if (sqrMagnitude >= this.frozenSqDistanceMinMaxThreshold.y) { this.onFrozenDistanceThreshold.Invoke(); } } } else { Vector3 normalized = Vector3.Cross(this.lastHandProjected, vector).normalized; float num3 = Vector3.Dot(this.worldPlaneNormal, normalized); float num4 = num; if (num3 < 0f) { num4 = -num4; } if (this.limited) { float num5 = Mathf.Clamp(this.outAngle + num4, this.minAngle, this.maxAngle); if (this.outAngle == this.minAngle) { if (num5 > this.minAngle && num < this.minMaxAngularThreshold) { this.outAngle = num5; this.lastHandProjected = vector; } } else if (this.outAngle == this.maxAngle) { if (num5 < this.maxAngle && num < this.minMaxAngularThreshold) { this.outAngle = num5; this.lastHandProjected = vector; } } else if (num5 == this.minAngle) { this.outAngle = num5; this.lastHandProjected = vector; this.onMinAngle.Invoke(); if (this.freezeOnMin) { this.Freeze(hand); } } else if (num5 == this.maxAngle) { this.outAngle = num5; this.lastHandProjected = vector; this.onMaxAngle.Invoke(); if (this.freezeOnMax) { this.Freeze(hand); } } else { this.outAngle = num5; this.lastHandProjected = vector; } } else { this.outAngle += num4; this.lastHandProjected = vector; } } } } }
public override IEnumerator DamagedAnimation(int oldHealth, Slider healthBar = null, StatusUI statusUI = null, Vector3 direction = new Vector3(), bool isCritical = false) { isMoving = true; float frame = 16, frame2 = 0, frame3 = 10; Vector3 originalPosition = t.position; Color originalColor = GetComponent <SpriteRenderer>().color; DamagedScreen damagedScreen = GameManager.gm.Canvas.GetComponent <UIInfo>().DamagedPanel; DamageNumber.DamageType dt = DamageNumber.DamageType.Normal; if (isCritical) { dt = DamageNumber.DamageType.Critical; } if (!direction.Equals(new Vector3())) { GameObject g = Instantiate(damageNumber, c.canvas.GetComponent <Transform>()); g.GetComponent <DamageNumber>().Initialize(oldHealth - c.currentHealth, dt); } for (int i = 0; i < frame + frame2; i++) { if (i < frame / 2) { GetComponent <SpriteRenderer>().color = Color.Lerp(originalColor, new Color(0.7f, 0f, 0f, 0.6f), i / frame * 2); if (!direction.Equals(new Vector3())) { t.position = Vector3.Lerp(originalPosition, originalPosition + 0.2f * direction, i / frame * 2); } } else { GetComponent <SpriteRenderer>().color = Color.Lerp(originalColor, new Color(0.7f, 0f, 0f, 0.6f), (frame + frame2 - i) / (frame / 2 + frame2)); if (!direction.Equals(new Vector3())) { t.position = Vector3.Lerp(originalPosition, originalPosition + 0.2f * direction, (frame + frame2 - i) / (frame / 2 + frame2)); } } if (c.currentHealth <= c.MaxHealth / 6) { damagedScreen.StartEffect(true); } else if (c.currentHealth <= c.MaxHealth / 3) { damagedScreen.StartEffect(false); } if (i < frame) { float f = Mathf.Lerp(c.currentHealth, oldHealth, Mathf.Pow(1 - (i / frame), 2f)); if (healthBar != null) { healthBar.value = f; } if (statusUI != null) { statusUI.UpdateAll(c, (int)f); } } yield return(null); } if (healthBar != null) { healthBar.value = c.currentHealth; } if (statusUI != null) { statusUI.UpdateAll(c, c.currentHealth); } GetComponent <SpriteRenderer>().color = originalColor; if (!direction.Equals(new Vector3())) { t.position = originalPosition; } for (int i = 0; i < frame3; i++) { yield return(null); } isMoving = false; }
public static int testEquals(Vector3 v0) { float f1 = (float)random.NextDouble(); float f2 = (float)random.NextDouble(); float f3 = (float)random.NextDouble(); Vector3 v1 = new Vector3(f1, f2, f3) - v0; bool result = v1.Equals(getTestValue(f1, f2, f3) - v0); if ((result == false) || !v1.Equals(getTestValue(f1, f2, f3) - v0)) { Console.WriteLine("Equals returns wrong value " + v1); return -1; } return 100; }
public void DrawBoundaries() { Dictionary <Edge, int> edges = new Dictionary <Edge, int>(); Dictionary <Vector3, int> allVertices = new Dictionary <Vector3, int>(); foreach (var gameObject in gamesObjects) { if (gameObject.Value == null) { continue; } Vector3[] verts = gameObject.Value.GetComponent <MeshFilter>().mesh.vertices; int[] inds = gameObject.Value.GetComponent <MeshFilter>().mesh.triangles; for (int i = 0; i < inds.Length; i += 3) { Vector3[] triangleVert = new Vector3[3]; //這個triangle的三個點 for (int j = 0; j < 3; j++) //看此點是否已經在已出現點的陣列裡面 { triangleVert[j] = verts[inds[i + j]]; if (!allVertices.ContainsKey(triangleVert[j])) { allVertices.Add(triangleVert[j], allVertices.Count); } } if (edges.ContainsKey(new Edge(triangleVert[0], triangleVert[1], triangleVert[2]))) //查看這個邊是否已經出現過,出現過就count + 1, 未出現就初始化這條邊 { edges[new Edge(triangleVert[0], triangleVert[1], triangleVert[2])] += 1; } else { edges.Add(new Edge(triangleVert[0], triangleVert[1], triangleVert[2]), 1); } if (edges.ContainsKey(new Edge(triangleVert[0], triangleVert[2], triangleVert[1]))) { edges[new Edge(triangleVert[0], triangleVert[2], triangleVert[1])] += 1; } else { edges.Add(new Edge(triangleVert[0], triangleVert[2], triangleVert[1]), 1); } if (edges.ContainsKey(new Edge(triangleVert[1], triangleVert[2], triangleVert[0]))) { edges[new Edge(triangleVert[1], triangleVert[2], triangleVert[0])] += 1; } else { edges.Add(new Edge(triangleVert[1], triangleVert[2], triangleVert[0]), 1); } } } List <Edge> singleEdges = new List <Edge>(); foreach (var edge in edges) //等所有的邊都檢查過一次後,把count只有出現一次的邊取出來,並取出這條邊的兩個點在點陣列中的位置,然後丟進indices(用來之後要在mesh裡面把它畫出來) { if (edge.Value == 1) { singleEdges.Add(edge.Key); //indices.Add(allVertices[edge.Key.v1]); //indices.Add(allVertices[edge.Key.v2]); } } edges.Clear(); List <List <Vector3> > Vertices = new List <List <Vector3> >(); List <Vector3> vertices = new List <Vector3>(); List <List <Vector3> > ThirdVertices = new List <List <Vector3> >(); List <Vector3> thirdvertices = new List <Vector3>(); vertices.Add(singleEdges[0].v1); vertices.Add(singleEdges[0].v2); thirdvertices.Add(singleEdges[0].v3); singleEdges.RemoveAt(0); int k = 0; while (singleEdges.Count != 0) { if (Vector3.Equals(singleEdges[k].v1, vertices.Last())) { vertices.Add(singleEdges[k].v2); thirdvertices.Add(singleEdges[k].v3); singleEdges.RemoveAt(k); k = 0; } else if (Vector3.Equals(singleEdges[k].v2, vertices.Last())) { vertices.Add(singleEdges[k].v1); thirdvertices.Add(singleEdges[k].v3); singleEdges.RemoveAt(k); k = 0; } else if (k == singleEdges.Count - 1) { Vertices.Add(vertices.ToList()); vertices.Clear(); ThirdVertices.Add(thirdvertices.ToList()); thirdvertices.Clear(); vertices.Add(singleEdges[0].v1); vertices.Add(singleEdges[0].v2); thirdvertices.Add(singleEdges[0].v3); singleEdges.RemoveAt(0); k = 0; } else { k += 1; } } Vertices.Add(vertices.ToList()); vertices.Clear(); ThirdVertices.Add(thirdvertices.ToList()); thirdvertices.Clear(); List <int> indices = new List <int>(); for (int i = 0; i < Vertices.Count; i++) { if (!PointInsidePolygon(ThirdVertices[i], Vertices[i])) { Mesh temp = new Mesh(); temp.vertices = Vertices[i].ToArray(); Vector3 center = temp.bounds.center; allVertices.Add(center, allVertices.Count); for (int j = 0; j < Vertices[i].Count - 1; j++) { indices.Add(allVertices[Vertices[i][j]]); indices.Add(allVertices[center]); indices.Add(allVertices[Vertices[i][j + 1]]); indices.Add(allVertices[Vertices[i][j + 1]]); indices.Add(allVertices[center]); indices.Add(allVertices[Vertices[i][j]]); } /* float area = 0f; * List<int> tempIndices = new List<int>(); * for (int j = 0; j < Vertices[i].Count - 1; j++) * { * tempIndices.Add(allVertices[Vertices[i][j]]); * tempIndices.Add(allVertices[center]); * tempIndices.Add(allVertices[Vertices[i][j + 1]]); * tempIndices.Add(allVertices[Vertices[i][j + 1]]); * tempIndices.Add(allVertices[center]); * tempIndices.Add(allVertices[Vertices[i][j]]); * area += Vector3.Cross(Vertices[i][j]-center, Vertices[i][j+1]-center).magnitude * 0.5f; * } * if(area >= 0.09) * { * indices.AddRange(tempIndices); * } * else * { * allVertices.Remove(center); * }*/ } } Vector3[] vertss = new Vector3[allVertices.Keys.Count]; allVertices.Keys.CopyTo(vertss, 0); List <Color> colors = new List <Color>(); for (int i = 0; i < allVertices.Count; i++) { colors.Add(Color.red); } // 畫mesh insideBoundary = Instantiate(mesh); insideBoundary.SetActive(true); insideBoundary.GetComponent <MeshFilter>().mesh.vertices = vertss; insideBoundary.GetComponent <MeshFilter>().mesh.SetIndices(indices.ToArray(), MeshTopology.Triangles, 0, false); insideBoundary.GetComponent <MeshFilter>().mesh.colors = colors.ToArray(); }
public bool IsCreatedIn(float radius) { if (relationship == 0) { return(false); } Vector3 safePosition = Util.GetSafePositionIn(radius); if (safePosition.Equals(Vector3.Zero)) { Logger.Error("Terrorist: Couldn't find safe position. Abort.", name); return(false); } for (int cnt = 0; cnt < 5; cnt++) { Road road = Util.GetNextPositionOnStreetWithHeading(safePosition.Around(50.0f)); if (road != null) { Logger.Write(false, "Terrorist: Found proper road.", name); spawnedVehicle = Util.Create(name, road.Position, road.Heading, true); if (!Util.ThereIs(spawnedVehicle)) { Logger.Write(false, "Terrorist: Couldn't create vehicle.", name); Restore(true); continue; } Logger.Write(false, "Terrorist: Created vehicle and driver.", name); Script.Wait(50); Util.Tune(spawnedVehicle, false, false, false); if (name == "khanjali" && spawnedVehicle.GetMod(VehicleMod.Roof) != -1) { spawnedVehicle.SetMod(VehicleMod.Roof, -1, false); } for (int i = -1; i < spawnedVehicle.PassengerSeats; i++) { if (spawnedVehicle.IsSeatFree((VehicleSeat)i)) { members.Add(spawnedVehicle.CreatePedOnSeat((VehicleSeat)i, "g_m_m_chicold_01")); Script.Wait(50); } } Logger.Write(false, "Terrorist: Tuned vehicle and created members.", name); if (members.Find(p => !Util.ThereIs(p)) != null) { Logger.Write(false, "Terrorist: There is a member who doesn't exist.", name); Restore(true); continue; } foreach (Ped p in members) { Util.SetCombatAttributesOf(p); p.RelationshipGroup = relationship; p.IsPriorityTargetForEnemies = true; p.CanBeShotInVehicle = false; p.Weapons.Give(WeaponHash.MicroSMG, 100, true, true); p.Weapons.Current.InfiniteAmmo = true; p.FiringPattern = FiringPattern.BurstFireDriveby; p.AlwaysKeepTask = true; p.BlockPermanentEvents = true; p.Task.FightAgainstHatedTargets(400.0f); Logger.Write(false, "Terrorist: Characteristics are set.", name); } if (SpawnedPedExistsIn(members)) { Logger.Write(false, "Terrorist: Created terrorists successfully.", name); blipName += VehicleInfo.GetNameOf(spawnedVehicle.Model.Hash); return(true); } else { Logger.Write(false, "Terrorist: Driver doesn't exist.", name); Restore(true); } } } Logger.Error("Terrorist: Couldn't find proper road. Abort.", name); return(false); }
public bool Equals(Edge other) { if ((Vector3.Equals(this.v1, other.v1) && Vector3.Equals(this.v2, other.v2)) || (Vector3.Equals(this.v1, other.v2) && Vector3.Equals(this.v2, other.v1))) { return(true); } else { return(false); } }
/// <summary> /// Combines all submeshes into the mesh on this object. /// </summary> public void Combine() { //get all mesh filters, but don't continue if there are no submeshes MeshFilter[] meshFilters = GetComponentsInChildren <MeshFilter>(); //get the mesh filter on this object MeshFilter myFilter = meshFilters[0]; List <CombineInstance> combine = new List <CombineInstance>(); //add meshes to the combine instances for (int i = 0; i < meshFilters.Length; i++) { if (meshFilters[i].sharedMesh == null) { continue; } CombineInstance c = new CombineInstance(); c.mesh = meshFilters[i].sharedMesh; c.transform = meshFilters[i].transform.localToWorldMatrix; combine.Add(c); } //rename mesh to a more appropriate name or keep it string meshName = "NavMesh"; if (myFilter.sharedMesh != null) { meshName = myFilter.sharedMesh.name; } //create new shared mesh from combined meshes myFilter.sharedMesh = new Mesh(); myFilter.sharedMesh.name = meshName; myFilter.sharedMesh.CombineMeshes(combine.ToArray()); current.Clear(); //list of vertices and triangles List <Vector3> vertices = new List <Vector3>(myFilter.sharedMesh.vertices); List <int> triangles = new List <int>(myFilter.sharedMesh.triangles); //convert vertex positions into relative positions for (int i = 0; i < vertices.Count; i++) { vertices[i] = transform.InverseTransformPoint(vertices[i]); } /* * string str = ""; * for (int i = 0; i < triangles.Count; i++) * str += triangles[i] + " "; * * Debug.Log("BEFORE tris: " + str); */ //find duplicated vertex positions List <int> dupIndices = new List <int>(); List <Vector3> duplicates = vertices.GroupBy(x => x) .Where(x => x.Count() > 1) .Select(x => x.Key) .ToList(); //Debug.Log("duplicates: " + duplicates.Count); //loop over duplicates to find vertex indices, //also overwrite indices with the first occurence in the triangle array for (int i = 0; i < duplicates.Count; i++) { //get all occurences of duplicated indices List <int> indices = vertices.Select((value, index) => new { value, index }) .Where(a => Vector3.Equals(a.value, duplicates[i])) .Select(a => a.index).ToList(); //get first occurence int unique = indices[0]; indices.RemoveAt(0); //loop over duplicated indices for (int j = 0; j < indices.Count; j++) { //get this duplicate int dupIndex = indices[j]; //get all matches in the triangle array List <int> matches = Enumerable.Range(0, triangles.Count) .Where(v => triangles[v] == dupIndex) .ToList(); //overwrite duplicated matches with the unique index for (int k = 0; k < matches.Count; k++) { //Debug.Log("overwriting index: " + matches[j] + " with: " + first); triangles[matches[k]] = unique; } //remember for later, when we are merging vertices dupIndices.Add(dupIndex); } } //sort duplicated indices in a descending order dupIndices = dupIndices.OrderByDescending(x => x).ToList(); //loop over indices for (int i = 0; i < dupIndices.Count; i++) { //remove the vertex int dupIndex = dupIndices[i]; vertices.RemoveAt(dupIndex); //decrease indices starting after this vertex, //since we removed it and the array is smaller now for (int j = dupIndex; j < triangles.Count; j++) { if (triangles[j] >= dupIndex) { triangles[j] = triangles[j] - 1; } } } /* * str = ""; * for (int i = 0; i < triangles.Count; i++) * str += triangles[i] + " "; * * Debug.Log("AFTER tris: " + str); */ //Debug.Log("COUNTS: " + vertices.Count + " " + triangles.Count); //assign merged vertices and triangles to the new mesh myFilter.sharedMesh.triangles = triangles.ToArray(); myFilter.sharedMesh.vertices = vertices.ToArray(); //recalculate and optimize myFilter.sharedMesh.RecalculateNormals(); myFilter.sharedMesh.RecalculateBounds(); myFilter.sharedMesh.Optimize(); }
int[] FindFacesUsing(Vector3 p, Vector3 n) { List<int> faces = new List<int>(); Vector3 v = Vector3.zero; for ( int i = 0; i < otris.Length; i += 3 ) { v = overts[otris[i]]; if ( v.x == p.x && v.y == p.y && v.z == p.z ) { if ( n.Equals(norms[otris[i]]) ) faces.Add(i / 3); } else { v = overts[otris[i + 1]]; if ( v.x == p.x && v.y == p.y && v.z == p.z ) { if ( n.Equals(norms[otris[i + 1]]) ) faces.Add(i / 3); } else { v = overts[otris[i + 2]]; if ( v.x == p.x && v.y == p.y && v.z == p.z ) { if ( n.Equals(norms[otris[i + 2]]) ) faces.Add(i / 3); } } } } return faces.ToArray(); //return faces; }
// Update is called once per frame void Update() { animator.SetBool("isWalking", false); h = Input.GetAxis("Horizontal"); v = Input.GetAxis("Vertical"); dir = xdir + ydir; if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow)) { transform.Translate(new Vector3(-0.6f * movingSpd * Time.deltaTime, 0, 0)); //0.6f는 해당 방향으로 프레임당 얼마씩 움직일지 정하는숫자. //Debug.Log(movingSpd * Time.deltaTime); isWalking = true; animator.SetFloat("Direction_X", h); animator.SetFloat("Direction_Y", v); animator.SetBool("isWalking", isWalking); getPlayerDirection(); } if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow)) { transform.Translate(new Vector3(0.6f * movingSpd * Time.deltaTime, 0, 0)); isWalking = true; animator.SetFloat("Direction_X", h); animator.SetFloat("Direction_Y", v); animator.SetBool("isWalking", isWalking); getPlayerDirection(); } if (Input.GetKey(KeyCode.W) || Input.GetKey(KeyCode.UpArrow)) { transform.Translate(new Vector3(0, 0.6f * movingSpd * Time.deltaTime, 0)); isWalking = true; animator.SetFloat("Direction_X", h); animator.SetFloat("Direction_Y", v); animator.SetBool("isWalking", isWalking); getPlayerDirection(); } if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow)) { transform.Translate(new Vector3(0, -0.6f * movingSpd * Time.deltaTime, 0)); isWalking = true; animator.SetFloat("Direction_X", h); animator.SetFloat("Direction_Y", v); animator.SetBool("isWalking", isWalking); getPlayerDirection(); } if (Input.GetKeyDown(KeyCode.C)) { guntype += 1; if (guntype == 3) { guntype = 0; } } if (Input.GetKeyDown(KeyCode.Q)) { SoundManager.instance.bgSource.Pause(); SoundManager.instance.ChangeBgAudio(voyagerSound1); //FIXME - 배열화 } if (Input.GetKeyDown(KeyCode.E)) { SoundManager.instance.bgSource.Pause(); SoundManager.instance.ChangeBgAudio(voyagerSound2); // FIXME - 배열화 //SoundManager.instance.bgSource.Stop(); } if (Input.GetKeyDown(KeyCode.LeftShift)) // dash // transform.SetPositionAndRotation(new Vector3(),Quaternion.identity); { Instantiate(dashEffect, transform.position, Quaternion.identity); isDashing = true; // Vector3 move = 0.6f * dir * 10f; // Debug.Log("move: " + move); // transform.Translate(move); //FIXME if (dashTime <= 0) { dir = new Vector3(0, 0, 0); // why?? dashTime = startDashTime; animator.SetBool("isDashing", false); transform.Translate(new Vector3(0, 0, 0)); } else { if (!Vector3.Equals(dir, new Vector3(0, 0, 0))) //없어도 되지않나? { } } //animator.SetBool("isDashing", isDashing); } if (dashTime <= 0) { animator.SetBool("isDashing", false); isDashing = false; } if (isDashing) { animator.SetBool("isDashing", true); dir.Normalize(); //없애보고 테스트 필요. dashTime -= Time.deltaTime; if (animator.GetCurrentAnimatorStateInfo(0).IsName("TempRolling")) { transform.Translate(dir * dashSpeed * Time.deltaTime); } animator.SetFloat("Direction_X", h); animator.SetFloat("Direction_Y", v); } }
public int CompareFlowVectors(Vector3 A, Vector3 B, Vector3 flow) { if(A.Equals(B)) { return 0; } else { float dotA = Vector3.Dot(A, flow); float dotB = Vector3.Dot(B, flow); if(dotA > dotB) { return 1; } else { return -1; } } }
/// <summary> /// Moves, scales, and/or rotates the current entity given a 3x3 transformation matrix and a translation vector. /// </summary> /// <param name="transformation">Transformation matrix.</param> /// <param name="translation">Translation vector.</param> /// <remarks>Matrix3 adopts the convention of using column vectors to represent a transformation matrix.</remarks> public override void TransformBy(Matrix3 transformation, Vector3 translation) { // NOTE: this is a generic implementation of the ellipse transformation, // for non rotated ellipses and/or uniform scaling the code can be simplified // rectangle that circumscribe the ellipse double semiMajorAxis = this.MajorAxis * 0.5; double semiMinorAxis = this.MinorAxis * 0.5; Vector2 p1 = new Vector2(-semiMajorAxis, semiMinorAxis); Vector2 p2 = new Vector2(semiMajorAxis, semiMinorAxis); Vector2 p3 = new Vector2(-semiMajorAxis, -semiMinorAxis); Vector2 p4 = new Vector2(semiMajorAxis, -semiMinorAxis); List <Vector2> ocsPoints = MathHelper.Transform(new[] { p1, p2, p3, p4 }, this.Rotation * MathHelper.DegToRad, CoordinateSystem.Object, CoordinateSystem.World); Vector3 p1Prime = new Vector3(ocsPoints[0].X, ocsPoints[0].Y, 0.0); Vector3 p2Prime = new Vector3(ocsPoints[1].X, ocsPoints[1].Y, 0.0); Vector3 p3Prime = new Vector3(ocsPoints[2].X, ocsPoints[2].Y, 0.0); Vector3 p4Prime = new Vector3(ocsPoints[3].X, ocsPoints[3].Y, 0.0); List <Vector3> wcsPoints = MathHelper.Transform(new[] { p1Prime, p2Prime, p3Prime, p4Prime }, this.Normal, CoordinateSystem.Object, CoordinateSystem.World); for (int i = 0; i < wcsPoints.Count; i++) { wcsPoints[i] += this.Center; wcsPoints[i] = transformation * wcsPoints[i]; wcsPoints[i] += translation; } Vector3 newNormal = transformation * this.Normal; if (Vector3.Equals(Vector3.Zero, newNormal)) { newNormal = this.Normal; } List <Vector3> rectPoints = MathHelper.Transform(wcsPoints, newNormal, CoordinateSystem.World, CoordinateSystem.Object); // corners of the transformed rectangle that circumscribe the new ellipse Vector2 pointA = new Vector2(rectPoints[0].X, rectPoints[0].Y); Vector2 pointB = new Vector2(rectPoints[1].X, rectPoints[1].Y); Vector2 pointC = new Vector2(rectPoints[2].X, rectPoints[2].Y); Vector2 pointD = new Vector2(rectPoints[3].X, rectPoints[3].Y); // the new ellipse is tangent at the mid points Vector2 pointM = Vector2.MidPoint(pointA, pointB); Vector2 pointN = Vector2.MidPoint(pointC, pointD); Vector2 pointH = Vector2.MidPoint(pointA, pointC); Vector2 pointK = Vector2.MidPoint(pointB, pointD); // we need to find a fifth point Vector2 origin = Vector2.MidPoint(pointH, pointK); Vector2 pointX = Vector2.MidPoint(pointH, origin); // a point along the OH segment // intersection line AC and line parallel to BC through pointX Vector2 pointY = MathHelper.FindIntersection(pointA, pointC - pointA, pointX, pointC - pointB); if (Vector2.IsNaN(pointY)) { Debug.Assert(false, "The transformation cannot be applied."); return; } // find the fifth point in the ellipse Vector2 pointZ = MathHelper.FindIntersection(pointM, pointX - pointM, pointN, pointY - pointN); if (Vector2.IsNaN(pointZ)) { Debug.Assert(false, "The transformation cannot be applied."); return; } Vector3 oldNormal = this.Normal; double oldRotation = this.Rotation; Vector2 newCenter; double newSemiMajorAxis; double newSemiMinorAxis; double newRotation; if (ConicThroughFivePoints.EllipseProperties(pointM, pointN, pointH, pointK, pointZ, out newCenter, out newSemiMajorAxis, out newSemiMinorAxis, out newRotation)) { double axis1 = 2 * newSemiMajorAxis; axis1 = MathHelper.IsZero(axis1) ? MathHelper.Epsilon : axis1; double axis2 = 2 * newSemiMinorAxis; axis2 = MathHelper.IsZero(axis2) ? MathHelper.Epsilon : axis2; this.Center = transformation * this.Center + translation; this.MajorAxis = axis1; this.MinorAxis = axis2; this.Rotation = newRotation * MathHelper.RadToDeg; this.Normal = newNormal; } else { Debug.Assert(false, "The transformation cannot be applied."); return; } if (this.IsFullEllipse) { return; } //if not full ellipse calculate start and end angles Vector2 start = this.PolarCoordinateRelativeToCenter(this.StartAngle); Vector2 end = this.PolarCoordinateRelativeToCenter(this.EndAngle); if (!MathHelper.IsZero(oldRotation)) { double beta = oldRotation * MathHelper.DegToRad; double sinBeta = Math.Sin(beta); double cosBeta = Math.Cos(beta); start = new Vector2(start.X * cosBeta - start.Y * sinBeta, start.X * sinBeta + start.Y * cosBeta); end = new Vector2(end.X * cosBeta - end.Y * sinBeta, end.X * sinBeta + end.Y * cosBeta); } Vector3 pStart = new Vector3(start.X, start.Y, 0.0); Vector3 pEnd = new Vector3(end.X, end.Y, 0.0); List <Vector3> wcsAnglePoints = MathHelper.Transform(new[] { pStart, pEnd }, oldNormal, CoordinateSystem.Object, CoordinateSystem.World); for (int i = 0; i < wcsAnglePoints.Count; i++) { wcsPoints[i] += this.Center; wcsAnglePoints[i] = transformation * wcsAnglePoints[i]; wcsPoints[i] += translation; } List <Vector3> ocsAnglePoints = MathHelper.Transform(wcsAnglePoints, newNormal, CoordinateSystem.World, CoordinateSystem.Object); Vector2 newStart = new Vector2(ocsAnglePoints[0].X, ocsAnglePoints[0].Y); Vector2 newEnd = new Vector2(ocsAnglePoints[1].X, ocsAnglePoints[1].Y); if (Math.Sign(transformation.M11 * transformation.M22 * transformation.M33) < 0) { this.EndAngle = Vector2.Angle(newStart) * MathHelper.RadToDeg; this.StartAngle = Vector2.Angle(newEnd) * MathHelper.RadToDeg; } else { this.StartAngle = Vector2.Angle(newStart) * MathHelper.RadToDeg; this.EndAngle = Vector2.Angle(newEnd) * MathHelper.RadToDeg; } }
public bool Equals(VertexPosition other) { return(Position.Equals(other.Position)); }
/// <inheritdoc /> public override unsafe int BuildVertexBuffer(ref ParticleBufferState bufferState, Vector3 invViewX, Vector3 invViewY, ref Vector3 spaceTranslation, ref Quaternion spaceRotation, float spaceScale, ref ParticleList sorter, ref Matrix viewProj) { // Get all the required particle fields var positionField = sorter.GetField(ParticleFields.Position); if (!positionField.IsValid()) { return(0); } var sizeField = sorter.GetField(ParticleFields.Size); var directionField = sorter.GetField(ParticleFields.Direction); // Check if the draw space is identity - in this case we don't need to transform the position, scale and rotation vectors var trsIdentity = (spaceScale == 1f); trsIdentity = trsIdentity && (spaceTranslation.Equals(new Vector3(0, 0, 0))); trsIdentity = trsIdentity && (spaceRotation.Equals(Quaternion.Identity)); var ribbonizer = new Ribbonizer(this, currentTotalParticles, currentQuadsPerParticle); var renderedParticles = 0; bufferState.StartOver(); uint oldOrderValue = 0; var orderField = sorter.GetField(ParticleFields.Order); foreach (var particle in sorter) { if (orderField.IsValid()) { var orderValue = (*((uint *)particle[orderField])); if ((orderValue >> SpawnOrderConst.GroupBitOffset) != (oldOrderValue >> SpawnOrderConst.GroupBitOffset)) { ribbonizer.Ribbonize(ref bufferState, QuadsPerParticle); ribbonizer.RibbonSplit(); } oldOrderValue = orderValue; } var centralPos = particle.Get(positionField); var particleSize = sizeField.IsValid() ? particle.Get(sizeField) : 1f; var particleDirection = directionField.IsValid() ? particle.Get(directionField) * particleSize : new Vector3(0f, particleSize, 0f); if (!trsIdentity) { spaceRotation.Rotate(ref centralPos); centralPos = centralPos * spaceScale + spaceTranslation; // Direction spaceRotation.Rotate(ref particleDirection); particleDirection *= spaceScale; } ribbonizer.AddParticle(ref centralPos, ref particleDirection); renderedParticles++; } ribbonizer.Ribbonize(ref bufferState, QuadsPerParticle); ribbonizer.Free(); var vtxPerShape = 4 * QuadsPerParticle; return(renderedParticles * vtxPerShape); }
/// <summary> /// Sets the current target of the ray. /// </summary> /// public void OverrideRayTarget(Vector3 pos) { if (pos.Equals(Vector3.zero)) { overrideTarget = false; } else { overrideTarget = true; rayTarget.point = pos; } }
protected virtual void InitAstar(Path path) { this.path = path; _start = gridScript.start; _goal = gridScript.goal; _gridWidth = gridScript.gridWidth; _gridHeight = gridScript.gridHeight; _pos = gridScript.GetGrid(); _frontier = new PriorityQueue <Vector3>(); _frontier.Enqueue(_start, 0); _cameFrom.Add(_start, _start); _costSoFar.Add(_start, 0); var exploredNodes = 0; while (_frontier.Count != 0) { exploredNodes++; _current = _frontier.Dequeue(); _visited.Add(_current); // _pos[(int)_current.x, (int)_current.y].transform.localScale = Vector3.Scale(_pos[(int)_current.x, (int)_current.y].transform.localScale, new Vector3(.8f, .8f, .8f)); if (_current.Equals(_goal)) { Debug.Log("GOOOAL!"); break; } for (var y = -1; y < 2; y += 2) { AddNodesToFrontier((int)_current.x, (int)_current.y + y); } for (var x = -1; x < 2; x += 2) { AddNodesToFrontier((int)_current.x + x, (int)_current.y); } } _current = _goal; var line = GetComponent <LineRenderer>(); var i = 0; float score = 0; while (!_current.Equals(_start)) { line.positionCount++; var go = _pos[(int)_current.x, (int)_current.y]; path.Insert(0, go, new Vector3((int)_current.x, (int)_current.y)); _current = _cameFrom[_current]; var vec = Util.clone(go.transform.position); vec.z = -1; line.SetPosition(i, vec); score += gridScript.GetMovementCost(go); i++; } path.Insert(0, _pos[(int)_current.x, (int)_current.y]); path.nodeInspected = exploredNodes; Debug.Log(path.pathName + " Terrain Score: " + score); Debug.Log(path.pathName + " Nodes Checked: " + exploredNodes); Debug.Log(path.pathName + " Total Score: " + (score + exploredNodes)); }