void Start()
{
if (showMainTest)
{
InitMainTest();
}
a = new Vec3(A);
b = new Vec3(B);
//value = Vector3.Project(A, B).normalized;
//value2 = Vec3.Project(a, b).normalized;
Vector3Debugger.AddVector(Vector3.zero, a, Color.blue, "Test Blue");
Vector3Debugger.EnableEditorView("Test Blue");
Vector3Debugger.AddVector(Vector3.zero, b, Color.green, "Test Green");
Vector3Debugger.EnableEditorView("Test Green");
//Vector3Debugger.AddVector(Vector3.zero, value2, Color.red, "Test Red");
//Vector3Debugger.EnableEditorView("Test Red");
Debug.Log("1: " + value);
Debug.Log("2: " + value2);
}
void Start()
{
Vector3Debugger.AddVector(ejer1, Color.red, "primero");
ejer1 = new Vector3(5, 0, 0);
Vector3Debugger.AddVectorsSecuence(ejer2, false, Color.blue, "segundo");
ejer2.Add(new Vector3(5, 0, 0));
ejer2.Add(new Vector3(5, 5, 0));
ejer2.Add(new Vector3(10, 5, 0));
Vector3Debugger.AddVectorsSecuence(ejer3, false, Color.yellow, "tercero");
ejer3.Add(new Vector3(5, 0, 0));
ejer3.Add(new Vector3(5, 5, 0));
ejer3.Add(new Vector3(10, 5, 0));
ejer3.Add(new Vector3(10, 10, 0));
// ----------------------------
// Testeos propios:
//Vec3 position = new Vec3(obj2.position);
//var rotation = MyQuatern.LookRotation(position, Vec3.Up);
//
//obj1.rotation = new Quaternion(rotation.x, rotation.y, rotation.z, rotation.w);
//var myQuat = MyQuatern.Euler(12, 5, -1);
//var unityQuat = Quaternion.Euler(12, 5, -1);
//
//Debug.Log("My: " + myQuat.eulerAngles);
//Debug.Log("Unity: " + unityQuat.eulerAngles.ToString("F7"));
}
private void Start()
{
SetExcercise(0);
Vector3Debugger.AddVectorsSecuence(secuencePointList, true, Color.red, "Secuence");
Vector3Debugger.EnableEditorView();
}
void FixedUpdate()
{
switch (ejercicio)
{
case Funciones.Uno:
Vector3Debugger.EnableEditorView("primero");
Vector3Debugger.DisableEditorView("segundo");
Vector3Debugger.DisableEditorView("tercero");
// ---------------
MyQuatern miQuat1 = MyQuatern.Euler(0, valor, 0);
ejer1 = (miQuat1 * new Vec3(ejer1));
// ---------------
Vector3Debugger.UpdatePosition("primero", ejer1);
break;
case Funciones.Dos:
Vector3Debugger.EnableEditorView("segundo");
Vector3Debugger.DisableEditorView("primero");
Vector3Debugger.DisableEditorView("tercero");
// ---------------
MyQuatern miQuat2 = MyQuatern.Euler(0, valor, 0);
ejer2[1] = (miQuat2 * new Vec3(ejer2[1]));
ejer2[2] = (miQuat2 * new Vec3(ejer2[2]));
ejer2[3] = (miQuat2 * new Vec3(ejer2[3]));
// ---------------
Vector3Debugger.UpdatePositionsSecuence("segundo", ejer2);
break;
case Funciones.Tres:
Vector3Debugger.EnableEditorView("tercero");
Vector3Debugger.DisableEditorView("primero");
Vector3Debugger.DisableEditorView("segundo");
// ---------------
MyQuatern miQuat3 = MyQuatern.Euler(valor * 1.5f, valor * 1.5f, 0);
ejer3[1] = (miQuat3 * new Vec3(ejer3[1]));
ejer3[3] = (MyQuatern.Inverse(miQuat3) * new Vec3(ejer3[3]));
// ---------------
Vector3Debugger.UpdatePositionsSecuence("tercero", ejer3);
break;
}
}
IEnumerator UpdateBlueVector()
{
for (int i = 0; i < 100; i++)
{
Vector3Debugger.UpdatePosition("elAzul", new Vector3(2.4f, 6.3f, 0.5f) * (i * 0.05f));
yield return(new WaitForSeconds(0.2f));
}
}
void Update()
{
if (ejercicios != lastEjercicios)
{
go1.transform.rotation = Quaternion.Euler(origRot);
go2.transform.rotation = Quaternion.Euler(origRot);
lastEjercicios = ejercicios;
}
Vector3 a;
Vector3 b;
switch (ejercicios)
{
case Ejercicio.uno:
go1.transform.rotation = go1.transform.rotation * Quaternion.Euler(new Vector3(0, angle * Time.deltaTime * speed, 0));
a = go1.transform.forward;
White = a * 10.0f;
Black = Vector3.zero;
Red = Vector3.zero;
Green = Vector3.zero;
break;
case Ejercicio.dos:
go1.transform.rotation = go1.transform.rotation * Quaternion.Euler(new Vector3(0, angle * Time.deltaTime * speed, 0));
a = go1.transform.forward;
White = a * 10;
Black = White + Vector3.up * 10;
Red = Black + a * 10.0f;
Green = Red;
break;
case Ejercicio.tres:
go1.transform.rotation = go1.transform.rotation * Quaternion.Euler(0, angle * Time.deltaTime * speed, angle * Time.deltaTime * speed);
a = go1.transform.forward;
go2.transform.rotation = go2.transform.rotation * Quaternion.Euler(0, -angle * Time.deltaTime * speed, -angle * Time.deltaTime * speed);
b = go2.transform.forward;
White = a * 10.0f;
Black = White + (go1.transform.up) * 10;
Red = Black + b * 10.0f;
Green = Red + (go2.transform.up) * 10;
break;
default:
break;
}
Vector3Debugger.UpdatePosition("Blanco", White);
Vector3Debugger.UpdatePosition("Negro", White, Black);
Vector3Debugger.UpdatePosition("Rojo", Black, Red);
Vector3Debugger.UpdatePosition("Verde", Red, Green);
}
void Start()
{
Vector3Debugger.AddVector(resultado, colorVec, "elResultado");
Vector3Debugger.EnableEditorView("elResultado");
Vector3Debugger.AddVector(ejerA, Color.black, "elNegro");
Vector3Debugger.EnableEditorView("elNegro");
Vector3Debugger.AddVector(ejerB, Color.white, "elBlanco");
Vector3Debugger.EnableEditorView("elBlanco");
timeLerp = 0;
timeLerpUnclamp = 1;
}
void Start()
{
FirstVector = new Vector3(10.0f, 10.0f, 10.0f);
SecondVector = new Vector3(25.0f, 20.0f, 20.0f);
first = new Vec3(FirstVector);
second = new Vec3(SecondVector);
Vector3Debugger.AddVector(FirstVector, Color.white, "First");
Vector3Debugger.AddVector(SecondVector, Color.black, "Second");
Vector3Debugger.AddVector(ThirdVector, Color.red, "Third");
Vector3Debugger.EnableEditorView();
}
void Start()
{
a = new Vec3(A);
b = new Vec3(B);
value = Vec3.Zero;
Vector3Debugger.AddVector(a, Color.blue, "Blue");
Vector3Debugger.EnableEditorView("Blue");
Vector3Debugger.AddVector(a, Color.green, "Green");
Vector3Debugger.EnableEditorView("Green");
Vector3Debugger.AddVector(value, vectorColor, "value");
Vector3Debugger.EnableEditorView("value");
}
void Start()
{
White = origVec;
Black = new Vector3(25.0f, 20.0f, 20.0f);
Vector3Debugger.AddVector(White, Color.white, "Blanco");
Vector3Debugger.AddVector(Black, Color.black, "Negro");
Vector3Debugger.AddVector(Red, Color.red, "Rojo");
Vector3Debugger.AddVector(Red, Color.green, "Verde");
Vector3Debugger.TurnOffVector("Blanco");
Vector3Debugger.TurnOffVector("Negro");
Vector3Debugger.TurnOffVector("Rojo");
Vector3Debugger.TurnOffVector("Verde");
Vector3Debugger.EnableEditorView();
}
void Start()
{
List <Vector3> vectors = new List <Vector3>();
vectors.Add(new Vec3(10.0f, 0.0f, 0.0f));
vectors.Add(new Vec3(10.0f, 10.0f, 0.0f));
vectors.Add(new Vec3(20.0f, 10.0f, 0.0f));
vectors.Add(new Vec3(20.0f, 20.0f, 0.0f));
Vector3Debugger.AddVectorsSecuence(vectors, false, Color.red, "secuencia");
Vector3Debugger.EnableEditorView("secuencia");
Vector3Debugger.AddVector(new Vector3(10, 10, 0), Color.blue, "elAzul");
Vector3Debugger.EnableEditorView("elAzul");
Vector3Debugger.AddVector(Vector3.down * 7, Color.green, "elVerde");
Vector3Debugger.EnableEditorView("elVerde");
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.L))
{
StartCoroutine(UpdateBlueVector());
}
if (Input.GetKeyDown(KeyCode.O))
{
Vector3Debugger.TurnOffVector("elAzul");
}
if (Input.GetKeyDown(KeyCode.P))
{
Vector3Debugger.TurnOnVector("elAzul");
}
}
void Inputs()
{
if (Input.GetKeyDown(KeyCode.Alpha1))
{
Vector3Debugger.SetVectorState("Test Blue", !Vector3Debugger.IsVectorActive("Test Blue"));
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
Vector3Debugger.SetVectorState("Test Green", !Vector3Debugger.IsVectorActive("Test Green"));
}
if (Input.GetKeyDown(KeyCode.Alpha3))
{
Vector3Debugger.SetVectorState("Test Red", !Vector3Debugger.IsVectorActive("Test Red"));
}
}
void InitMainTest()
{
List <Vector3> vectors = new List <Vector3>();
vectors.Add(new Vec3(10.0f, 0.0f, 0.0f));
vectors.Add(new Vec3(10.0f, 10.0f, 0.0f));
vectors.Add(new Vec3(20.0f, 10.0f, 0.0f));
vectors.Add(new Vec3(20.0f, 20.0f, 0.0f));
Vector3Debugger.AddVectorsSecuence(vectors, false, Color.red, "secuencia");
Vector3Debugger.EnableEditorView("secuencia");
Vector3Debugger.AddVector(new Vector3(10, 10, 0), Color.blue, "Vector3 Blue");
Vector3Debugger.EnableEditorView("Vector3 Blue");
Vector3Debugger.AddVector(Vector3.down * 7, Color.green, "Vector3 Green");
Vector3Debugger.EnableEditorView("Vector3 Green");
}
void Update()
{
//timer += Time.deltaTime;
a = new Vec3(A);
b = new Vec3(B);
//value2 = Vec3.Reflect(a, b);
value = Vector3.Angle(A, B);
value2 = Vec3.Angle(a, b);
Vector3Debugger.UpdatePosition("Test Blue", a);
Vector3Debugger.UpdatePosition("Test Green", b);
//Vector3Debugger.UpdatePosition("Test Red", value2);
if (Input.GetKeyDown(KeyCode.Space))
{
Debug.Log("1: " + value);
Debug.Log("2: " + value2);
}
Inputs();
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
DoNextExcercise();
}
switch (excersice)
{
case Excersice.FIRST:
point1.rotation *= MyQuaternion.Euler(0, angle * Time.deltaTime * speed, 0);
secuencePointList[1] = point1.forward * 10f;
break;
case Excersice.SECOND:
point1.rotation *= MyQuaternion.Euler(0, angle * Time.deltaTime * speed, 0);
secuencePointList[1] = point1.forward * 10f;
secuencePointList[2] = secuencePointList[1] + (Vector3.up * 10f);
secuencePointList[3] = secuencePointList[2] + (point1.forward * 10f);
break;
case Excersice.THIRD:
point1.rotation *= Quaternion.Euler(0, angle * Time.deltaTime * speed, angle * Time.deltaTime * speed);
point2.rotation *= Quaternion.Euler(0, -angle * Time.deltaTime * speed, -angle * Time.deltaTime * speed);
secuencePointList[1] = point1.transform.forward * 10f;
secuencePointList[2] = secuencePointList[1] + (point1.up * 10f);
secuencePointList[3] = secuencePointList[2] + (point2.forward * 10f);
secuencePointList[4] = secuencePointList[3] + (point2.up * 10f);
break;
}
Vector3Debugger.UpdatePositionsSecuence("Secuence", secuencePointList);
}
// Update is called once per frame
void Update()
{
a = new Vec3(A);
b = new Vec3(B);
Vector3Debugger.UpdatePosition("Blue", a);
Vector3Debugger.UpdatePosition("Green", b);
switch (excersice)
{
case EXCERSICE.EX_1:
value = a + b;
break;
case EXCERSICE.EX_2:
value = b - a;
break;
case EXCERSICE.EX_3:
Vec3 aux3 = a;
aux3.Scale(b);
value = aux3;
break;
case EXCERSICE.EX_4:
value = Vec3.Cross(b, a);
break;
case EXCERSICE.EX_5:
timer += Time.deltaTime;
if (timer >= 1)
{
timer = 0;
}
value = Vec3.Lerp(b, a, timer);
break;
case EXCERSICE.EX_6:
value = Vec3.Max(a, b);
break;
case EXCERSICE.EX_7:
value = Vec3.Project(a, b);
break;
case EXCERSICE.EX_8:
//value = Vec3.ClampMagnitude(??????????)
break;
case EXCERSICE.EX_9:
value = Vec3.Reflect(b, a);
break;
case EXCERSICE.EX_10:
timer += Time.deltaTime;
if (timer >= 10)
{
timer = 0;
}
value = Vec3.LerpUnclamped(b, a, timer);
break;
}
Vector3Debugger.UpdateColor("value", vectorColor);
Vector3Debugger.UpdatePosition("value", value);
}
void Update()
{
Vec3 A = new Vec3(ejerA);
Vec3 B = new Vec3(ejerB);
Vec3 C = new Vec3(resultado);
switch (funcion)
{
case Funciones.Uno: // Suma de Dos Vectores3
C = A + B;
break;
case Funciones.Dos: // Resta de dos Vectores3
C = B - A;
break;
case Funciones.Tres: // Se hace una escala entre los dos Vectores Existentes
C = A;
C.Scale(B);
break;
case Funciones.Cuatro: // Se hace un producto Cruz entre los dos vectores
C = Vec3.Cross(B, A);
break;
case Funciones.Cinco: // Se hace un Lerp entre los dos vectores
if (timeLerp > 1)
{
timeLerp = 0;
}
else
{
timeLerp += Time.deltaTime;
}
C = Vec3.Lerp(A, B, timeLerp);
break;
case Funciones.Seis: // Se hace se saca los valores maximos de cada vector
C = Vec3.Max(A, B);
break;
case Funciones.Siete: // Se saca la Proyeccion entre dos vectores
C = Vec3.Project(A, B);
break;
case Funciones.Ocho: // Se hace un normalize de los dos vectores y despues se multiplica a la distancia entre los mismos Pdt. Este costo porque era raro
Vec3 suma = A + B;
C = suma.normalized * Vec3.Distance(A, B);
break;
case Funciones.Nueve: // Se hace un reflect utilizando los los vertores
C = Vec3.Reflect(B, A);
break;
case Funciones.Diez: // Se hace un LerpUnclamped para que no se detenga cuando llega al limite permitido y asi siga avanzando
timeLerpUnclamp -= Time.deltaTime;
C = Vec3.LerpUnclamped(A, B, timeLerpUnclamp);
break;
}
ejerA = A;
ejerB = B;
resultado = C;
Vector3Debugger.UpdatePosition("elResultado", resultado);
Vector3Debugger.UpdatePosition("elNegro", ejerA);
Vector3Debugger.UpdatePosition("elBlanco", ejerB);
}
// Update is called once per frame
void Update()
{
first = new Vec3(FirstVector);
second = new Vec3(SecondVector);
switch (opciones)
{
case Options.uno:
third = first + second;
break;
case Options.dos:
third = second - first;
break;
case Options.tres:
third = Vec3.Scale(first, second);
break;
case Options.cuatro:
third = Vec3.Cross(second, first);
break;
case Options.cinco:
third = Vec3.Lerp(first, second, t);
t += Time.deltaTime;
if (t >= 1f)
{
t = 0f;
}
break;
case Options.seis:
third = Vec3.Max(first, second);
break;
case Options.siete:
third = Vec3.Project(first, second);
break;
case Options.ocho:
float val = Vec3.Distance(first, second);
Vec3 sum = first + second;
third = val * sum.normalized;
break;
case Options.nueve:
third = Vec3.Reflect(first, second);
break;
case Options.diez:
third = Vec3.LerpUnclamped(second, first, t);
t += Time.deltaTime;
if (t >= 10f)
{
t = 0f;
}
break;
default:
break;
}
Vector3Debugger.UpdatePosition("First", first);
Vector3Debugger.UpdatePosition("Second", second);
Vector3Debugger.UpdatePosition("Third", third);
}
