// 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;
}
}
