// these methods and coroutines change the cards position smoothly public void moveTo(Vector3 position) { TransformStruct ts = new TransformStruct(TransformManager.transform); ts.position = position; TransformManager.MoveToImmediate(ts); }
void Start() { var data = new TransformStruct[numberOfDraw]; for (var i = 0; i < numberOfDraw; i++) { data[i].translate = Vector3.one; data[i].scale = Vector3.one * particleScale; data[i].speed = Random.Range(0.1f, 5.0f); data[i].sumTime = i; } transformBuff = CreateComputeBuffer(data); var args = new uint[5] { 0, 0, 0, 0, 0 }; args[0] = mesh.GetIndexCount(0); args[1] = (uint)numberOfDraw; argsBuff = new ComputeBuffer(1, args.Length * sizeof(uint), ComputeBufferType.IndirectArguments); argsBuff.SetData(args); kernel.SetBuffer(kernel.FindKernel("Calculate"), "_TransformBuff", transformBuff); mat = new Material(shader); mat.SetBuffer("_TransformBuff", transformBuff); for (int i = 0; i < initialIterate; i++) { KernelUpdate(1.0f / 60.0f); } }
// add to queue public void QueueMoveTo(TransformStruct t) { if (!locked && !removedFromScene) { transformQueue.Enqueue(t); } }
private void Update() { // first check if there is anything to do if (currentTransform == null && transformQueue.Count == 0 || removedFromScene || locked) { return; } // if close to transform or currentTransform is null then move to next transform if (currentTransform == null || Vector3.Distance(transform.localPosition, currentTransform.position) < closeEnough) { if (transformQueue.Count > 0) { currentTransform = transformQueue.Dequeue(); } else { currentTransform = null; return; } } // move towards current transform if (currentTransform.useLocalPosition) { transform.localPosition = Vector3.Lerp(transform.localPosition, currentTransform.position, speed * Time.deltaTime); } else { transform.position = Vector3.Lerp(transform.position, currentTransform.position, speed * Time.deltaTime); } transform.rotation = Quaternion.Lerp(transform.rotation, Quaternion.Euler(currentTransform.rotation), speed * Time.deltaTime); transform.localScale = Vector3.Lerp(transform.localScale, currentTransform.localScale, speed * Time.deltaTime); }
public void SetTargetPosition(TransformStruct targetPosition) { var cameraMovementJobState = this.CameraMovementJobState[0]; cameraMovementJobState.SetTargetPosition(targetPosition); this.CameraMovementJobState[0] = cameraMovementJobState; }
public AIMoveToActionV2(CoreInteractiveObject InteractiveObject, TransformStruct WorldPoint, AIMovementSpeedDefinition AIMovementSpeed, Func <List <ASequencedAction> > nextActionsDeffered) : base(nextActionsDeffered) { this.destinationReached = false; this.InteractiveObject = InteractiveObject; this.WorldPoint = WorldPoint; this.AIMovementSpeed = AIMovementSpeed; }
// clear and add public void MoveToImmediate(TransformStruct t) { if (!locked && !removedFromScene) { ClearQueue(); QueueMoveTo(t); } }
private static TransformStruct CopyTransformLocal(Transform transform) { TransformStruct stored = new TransformStruct(); stored.position = transform.localPosition; stored.rotation = transform.localRotation; stored.localScale = transform.localScale; return(stored); }
public void SpawnFiredProjectile(TransformStruct StartTransform) { var FiredProjectile = this.WeaponDefinition.FiredProjectileDefinition.BuildFiredProjectile(this.WeaponRef.WeaponHolder); var ProjectileSpawnLocalPosition = StartTransform.WorldPosition; var FiredProjectileTransform = FiredProjectile.InteractiveGameObject.GetTransform(); // Eq (2) FiredProjectile.InteractiveGameObject.InteractiveGameObjectParent.transform.position = StartTransform.WorldPosition; FiredProjectile.InteractiveGameObject.InteractiveGameObjectParent.transform.eulerAngles = StartTransform.WorldRotationEuler; this.SpawnFiringProjectileEvent.OnFiringProjectileSpawned(FiredProjectile, this.WeaponRef); }
protected void SetCoordinates(Tile tile) { TransformStruct ts = new TransformStruct(SourceCard.TransformManager.transform); ts.position = tile.transform.position; //ts.position = tile.GetComponent<RectTransform>().rect.center; ts.position.x += 45; // these adjustments are needed because tile pivot is in the corner ts.position.y -= 40; // if tile size is changed these need to change too ts.useLocalPosition = false; SourceCard.TransformManager.SetTransform(ts); //SourceCard.TransformManager.MoveToInformativeAnimation(ts); }
public void SetTransform(TransformStruct tStruct) { ClearQueue(); if (tStruct.useLocalPosition) { transform.localPosition = tStruct.position; } else { transform.position = tStruct.position; } transform.localScale = tStruct.localScale; transform.localRotation = Quaternion.Euler(tStruct.rotation); }
private void SetPositions(IReadOnlyList <Card> cards, float distanceBetweenCards) { for (int i = 0; i < cards.Count; i++) { TransformStruct tStruct = new TransformStruct(source.transform); multiplier = (((float)cards.Count) / -2) + .5f + i; offset = multiplier * distanceBetweenCards; tStruct.position = Vector3.right * offset; tStruct.rotation = new Vector3(0, 0, multiplier * -maxRotation); tStruct.useLocalPosition = true; cards[i].TransformManager.MoveToImmediate(tStruct); cards[i].transform.SetSiblingIndex(i); cards[i].transform.localPosition = Vector3.zero; } }
public void TransformStructTestSimplePasses() { Transform t = new GameObject("lul").transform; Transform t2 = new GameObject("lul2").transform; t.localPosition = -Vector3.one; t.localRotation = Quaternion.Euler(new Vector3(0, 45, 0)); t2.parent = t; t2.localPosition = Vector3.one; t2.localRotation = Quaternion.Euler(new Vector3(45, 0, 0)); // Test construction TransformStruct st = new TransformStruct(t); TransformStruct st2 = new TransformStruct(t2); Assert.AreEqual(st.localPosition, t.localPosition); Assert.AreEqual(st2.localPosition, t2.localPosition); Assert.AreEqual(st.localRotation, t.localRotation); Assert.AreEqual(st2.localRotation, t2.localRotation); Assert.AreEqual(st2.parent, t2.parent); // Test modification st2.localEulerAngles = new Vector3(90, 0, 0); t2.localEulerAngles = new Vector3(90, 0, 0); t2.localPosition = Vector3.one * 2; st2.localPosition = Vector3.one * 2; Assert.AreEqual(st2.localPosition, t2.localPosition); Assert.IsTrue(Mathf.Approximately(st2.localRotation.x, t2.localRotation.x)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.y, t2.localRotation.y)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.z, t2.localRotation.z)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.w, t2.localRotation.w)); // Test application t2.localEulerAngles = new Vector3(0, 0, 0); t2.localPosition = Vector3.zero; st2.Apply(t2); Assert.AreEqual(st2.localPosition, t2.localPosition); Assert.IsTrue(Mathf.Approximately(st2.localRotation.x, t2.localRotation.x)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.y, t2.localRotation.y)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.z, t2.localRotation.z)); Assert.IsTrue(Mathf.Approximately(st2.localRotation.w, t2.localRotation.w)); }
//Choose the Maneuver the ship will take public ManeuverType ChooseManeuver(Transform player) { if (Input.GetButton("LeftMan")) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.L_DODGE; } else if (Input.GetButton("RightMan")) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.R_DODGE; } else if (Input.GetButton("DownMan")) { //Save coordinates start = player; player.Rotate(Vector3.left * 180); end = player; player.Rotate(Vector3.left * 180); //Return Maneuver Type return ManeuverType.U_TURN1; } else if (Input.GetButton("UpMan")) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.LOOP; } else return ManeuverType.NONE; }
private static void PasteTransformAction(bool worldSpace = false) { if (Selection.activeTransform == null) { return; } Undo.RegisterCompleteObjectUndo(Selection.activeGameObject, $"pasted transform values"); TransformStruct storedTransform = new TransformStruct(); // Attempt to parse JSON try { storedTransform = JsonUtility.FromJson <TransformStruct>(EditorGUIUtility.systemCopyBuffer); if (worldSpace) { PasteTransformWorld(Selection.activeTransform, storedTransform); } else { PasteTransformLocal(Selection.activeTransform, storedTransform); } } catch { } }
public void MoveToInformativeAnimation(TransformStruct t) { InformativeAnimationsQueue.Instance.AddAnimation(new TransformCommand(this, t)); }
public void SpawnFiredProjectile(TransformStruct StartTransform) { this.FiringProjectileSystem.SpawnFiredProjectile(StartTransform); }
// clear queue public void ClearQueue() { currentTransform = null; transformQueue.Clear(); }
public void SetTargetPosition(TransformStruct targetPosition) { this.CameraMovementJob.SetTargetPosition(targetPosition); }
public void SetTargetPosition(TransformStruct targetPosition) { this.CameraFollowState.CameraFollowTargetPosition = targetPosition.WorldPosition; this.CameraObject.CameraPivotPointTransformWithoutOffset.rot = quaternion.Euler(targetPosition.WorldRotationEuler); }
public TransformCommand(TransformManager transformManager, TransformStruct targetTransform) { this.transformManager = transformManager; this.targetTransform = targetTransform; }
public bool IsEqualTo(TransformStruct other) { return((this.WorldPosition == other.WorldPosition) && (this.WorldRotationEuler == other.WorldRotationEuler) && (this.LossyScale == other.LossyScale)); }
public void CalculateFrustumWorldPositionyFace(out FrustumPointsPositions FrustumPointsPositions, TransformStruct FrustumTransform) { Vector3 C1 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F1.Width, this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C2 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F1.Width, this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C3 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F1.Width, -this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C4 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F1.Width, -this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C5 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F2.Width, this.F2.Height, 0) + this.F2.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C6 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F2.Width, this.F2.Height, 0) + this.F2.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C7 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F2.Width, -this.F2.Height, 0) + this.F2.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C8 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F2.Width, -this.F2.Height, 0) + this.F2.FaceOffsetFromCenter).Mul(0.5f)); FrustumPointsPositions = new FrustumPointsPositions(C1, C2, C3, C4, C5, C6, C7, C8); }
//Update the rotation for the initial movement of the U-Turn public bool UpdateUTurn1(Transform player) { //Check to see if we have completed the movement if (CompareVec (player.eulerAngles, end.rotation)) { //If we have completed the movement, set the rotation and prepare //for the second movement of the U-Turn player.eulerAngles = end.rotation; //Set up coordinates for the second part of the U-Turn start = player; player.Rotate(Vector3.forward * 180); end = player; player.Rotate(Vector3.forward * 180); return false; } //Rotate the ship upwards Vector3 rotateUp = Vector3.left * 2.0f; player.Rotate(rotateUp); return true; }
public AIWarpActionV2(CoreInteractiveObject InteractiveObject, TransformStruct WorldPoint, Func <List <ASequencedAction> > nextActionsDeferred) : base(nextActionsDeferred) { this.InteractiveObject = InteractiveObject; this.WorldPoint = WorldPoint; }
/// <summary> /// Extracts camera state information from the specified camera. /// </summary> /// <param name="camera">The camera to extract data from.</param> /// <returns>The camera state data structure.</returns> public CameraState(Camera camera) { this.transform = new TransformStruct(camera.transform); }
private static void PasteTransformLocal(Transform transform, TransformStruct stored) { transform.localPosition = stored.position; transform.localRotation = stored.rotation; transform.localScale = stored.localScale; }
//Manually choose a maneuver public ManeuverType ManualManeuver(Transform player, ManeuverType maneuver) { if (maneuver == ManeuverType.L_DODGE) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.L_DODGE; } else if (maneuver == ManeuverType.R_DODGE) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.R_DODGE; } else if (maneuver == ManeuverType.U_TURN1) { //Save coordinates start = player; player.Rotate(Vector3.left * 180); end = player; player.Rotate(Vector3.left * 180); //Return Maneuver Type return ManeuverType.U_TURN1; } else if (maneuver == ManeuverType.LOOP) { //Save coordinates start = player; end = player; loopCount = 0; //Return Maneuver Type return ManeuverType.LOOP; } else return ManeuverType.NONE; }
private Vector3 LocalToWorld(TransformStruct FrustumTransform, Vector3 localPoint) { return(Matrix4x4.TRS(Center + FrustumTransform.WorldPosition, Quaternion.Euler(FrustumTransform.WorldRotationEuler) * Quaternion.Euler(this.DeltaRotation), FrustumTransform.LossyScale).MultiplyPoint(localPoint)); }
/// <summary> /// Calculate Frustums based on point projectiion <paramref name="WorldStartAngleProjection"/>. /// Frustums calculation are done only if the <paramref name="WorldStartAngleProjection"/> is facing the <see cref="F1v3"/> face. <paramref name="IsFacing"/> flags /// indicates if calculation has been done or not. /// </summary> public void CalculateFrustumPointsWorldPosByProjection(out FrustumPointsPositions FrustumPointsPositions, out bool IsFacing, TransformStruct FrustumTransform, Vector3 WorldStartAngleProjection) { // this.F1.CalculateLocalFacePoints(out Vector3 lC1, out Vector3 lC2, out Vector3 lC3, out Vector3 lC4); Vector3 C1 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC1); Vector3 C2 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC2); Vector3 C3 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC3); Vector3 C4 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC4); // Debug.Log(C1.ToString("F4")); Vector3 frontFaceNormal = Vector3.Cross(C2 - C1, C4 - C1).normalized; IsFacing = Vector3.Dot(frontFaceNormal, C1 - WorldStartAngleProjection) >= 0; //We abort calculation if not facing if (IsFacing) { Vector3 C5 = C1 + ((C1 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C6 = C2 + ((C2 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C7 = C3 + ((C3 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C8 = C4 + ((C4 - WorldStartAngleProjection) * this.FaceDistance); FrustumPointsPositions = new FrustumPointsPositions(C1, C2, C3, C4, C5, C6, C7, C8); } else { FrustumPointsPositions = default; } }
public void CalculateFrustumWorldPositionyFace(out FrustumPointsPositions FrustumPointsPositions, TransformStruct FrustumTransform) { Vector3 C1 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC1); Vector3 C2 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC2); Vector3 C3 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC3); Vector3 C4 = this.LocalToWorld(FrustumTransform, this.F1v3.LocalC4); Vector3 C5 = this.LocalToWorld(FrustumTransform, this.F2v3.LocalC1); Vector3 C6 = this.LocalToWorld(FrustumTransform, this.F2v3.LocalC2); Vector3 C7 = this.LocalToWorld(FrustumTransform, this.F2v3.LocalC3); Vector3 C8 = this.LocalToWorld(FrustumTransform, this.F2v3.LocalC4); FrustumPointsPositions = new FrustumPointsPositions(C1, C2, C3, C4, C5, C6, C7, C8); }
static void addTransform(Transform inObject, List <TransformStruct> transforms, Queue <Transform> transformQueue, ref Dictionary <Type, Component> defaultComponentDictionary, ref GameObject defaultComponentContainer, ref int index) { //Construct this transform as a TransformStruct TransformStruct thisTransform = new TransformStruct(); thisTransform.name = inObject.name; thisTransform.instanceID = inObject.GetInstanceID(); thisTransform.localPosition = inObject.position; thisTransform.localRotation = inObject.rotation; thisTransform.localScale = inObject.localScale; //Count up the valid components int validComponentIndex = 0; Component[] components = inObject.GetComponents <Component>(); for (int i = 0; i < components.Length; i++) { string typeName = components[i].GetType().ToString(); if (typeName != "SerializedGameObject" && typeName != "UnityEngine.Transform") { validComponentIndex++; } } //Add all of the valid components thisTransform.components = new ComponentStruct[validComponentIndex]; validComponentIndex = 0; for (int i = 0; i < components.Length; i++) { ComponentStruct component = new ComponentStruct(); component.typeName = components[i].GetType().ToString(); if (component.typeName != "SerializedGameObject" && component.typeName != "UnityEngine.Transform") { component.instanceID = components[i].GetInstanceID(); if (!component.typeName.StartsWith("UnityEngine.")) { component.sanitizedJson = JsonUtility.ToJson(components[i]); } else { Component defaultComponent; if (!defaultComponentDictionary.TryGetValue(components[i].GetType(), out defaultComponent)) { defaultComponent = defaultComponentContainer.AddComponent(components[i].GetType()); defaultComponentDictionary.Add(components[i].GetType(), defaultComponent); } serializeEngineComponent(ref component, ref components[i], defaultComponent); } thisTransform.components[validComponentIndex] = component; validComponentIndex++; } } //And all the children, too! thisTransform.children = new int[inObject.childCount]; for (int i = 0; i < thisTransform.children.Length; i++) { thisTransform.children[i] = ++index; transformQueue.Enqueue(inObject.GetChild(i)); } transforms.Add(thisTransform); }
public void CalculateFrustumPointsWorldPosByProjection(out FrustumPointsPositions FrustumPointsPositions, out bool IsFacing, TransformStruct FrustumTransform, Vector3 WorldStartAngleProjection) { Vector3 C1 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F1.Width, this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C2 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F1.Width, this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C3 = this.LocalToWorld(FrustumTransform, (new Vector3(this.F1.Width, -this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 C4 = this.LocalToWorld(FrustumTransform, (new Vector3(-this.F1.Width, -this.F1.Height, 0) + this.F1.FaceOffsetFromCenter).Mul(0.5f)); Vector3 frontFaceNormal = Vector3.Cross(C2 - C1, C4 - C1).normalized; IsFacing = Vector3.Dot(frontFaceNormal, C1 - WorldStartAngleProjection) >= 0; //We abort calculation if not facing if (IsFacing) { Vector3 C5 = C1 + ((C1 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C6 = C2 + ((C2 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C7 = C3 + ((C3 - WorldStartAngleProjection) * this.FaceDistance); Vector3 C8 = C4 + ((C4 - WorldStartAngleProjection) * this.FaceDistance); FrustumPointsPositions = new FrustumPointsPositions(C1, C2, C3, C4, C5, C6, C7, C8); } else { FrustumPointsPositions = default; } }