Hi there,
I am just messing around trying to set up a spot light which will rotate from and to 5 different rotations looping back to 1 when it reaches 5. Anyhow, I am using this code…
Obviously it means that the values I am plugging in are in valid, correct? Anyhow, going on what the error says, only quaternion values are excepted into the method. However, quaternion are complex numbers and I thought that plugging in transform.rotation values would be appropriate. What am I doing wrong?
I just passed the var as a Quaternion and I get more errors. First of all passing it as such did seem weird, but… I thought a transform.rotation is a quaternion so if you declare a ver as a transform, it can translate no?
Also, how should I declare my var for rotations then?
And it is quite right. “transform” is ambiguous between the public variable you declared named “transform” and the MonoBehaviour property named “transform”. I would suggest you make it less ambiguous by renaming your variable.
Ok thanks, that did clear up the ambiguous. But I thought
var transform : Transform;
was common and that then using transform throughout your script would refer to the owner of that script. No??
///
Anyhow, beyond that I am still having issues with this, perhaps some one can help me out…
var ownerTransform : Transform;
///each "rot#" val is a rotation to be plugged in
var rot1 : Quaternion;
var rot2 : Quaternion;
var rot3 : Quaternion;
//crntRot will be used in update to measure the currnet rotation
var crntRot : Quaternion;
///speed at whcih owner will rotate
var speed : float;
function Update () {
///retrieve currnet rotation value of object.
crntRot = ownerTransform.transform.rotation;
print("ownerTransform.rotation " + ownerTransform.rotation);
print("rot1 " + rot1);
print("rot2 " + rot2);
print("rot3 " + rot3);
print("crntRot " + crntRot);
///compare
if(rot1 == crntRot)
{
print("at rot1 pos");
ownerTransform.transform.rotation = Quaternion.Slerp (rot1, rot2, Time.time * speed);
return;
}
///compare
if(rot2 == crntRot)
{
print("at rot2 pos");
ownerTransform.transform.rotation = Quaternion.Slerp (rot2, rot3, Time.time * speed);
return;
}
///compare
if(rot3 == crntRot)
{
print("at rot3 pos");
ownerTransform.transform.rotation = Quaternion.Slerp (rot3, rot1, Time.time * speed);
return;
}
}
}
The problem I am having is this…
the prints return …
a. the owner, does not rotate.
b. are the quarternion values always no greater than 1? If so, plugging in desired rotation values as I have, is this incorrect?
c. w in the quaternion can be set, but should “not be messed with”, what value should it hold?
ownerTransform.transform.rotation = Quaternion.Slerp (rot1, rot2, Time.time * speed);
?¿?¿
a transform can’t have another .transform. …
and…
tip: you don’t need any ownerTransform because if this file.js is in one Object, then… you can use transform.rotation, transform.Translate, transfrom. all you want, and it refers your Object which has the script.
var ownerTransform : Transform;
///each "rot#" val is a rotation to be plugged in
var rot1 : Quaternion;
var rot2 : Quaternion;
var rot3 : Quaternion;
///speed at whcih owner will rotate
var speed : float;
function Update () {
///retrieve currnet rotation value of object.
var crntRot = ownerTransform.rotation;
print("ownerTransform.rotation " + ownerTransform.rotation);
print("rot1 " + rot1);
print("rot2 " + rot2);
print("rot3 " + rot3);
print("crntRot " + crntRot);
///compare
if(rot1 == crntRot)
{
print("at rot1 pos");
ownerTransform.rotation = Quaternion.Slerp (rot1, rot2, Time.time * speed);
return;
}
///compare
if(rot2 == crntRot)
{
print("at rot2 pos");
ownerTransform.rotation = Quaternion.Slerp (rot2, rot3, Time.time * speed);
return;
}
///compare
if(rot3 == crntRot)
{
print("at rot3 pos");
ownerTransform.rotation = Quaternion.Slerp (rot3, rot1, Time.time * speed);
return;
}
}
From this, can you see or tell me what I am doing wrong? I ask because “crntRot” always returns a value not equal to rot1 but the print also implies I am in the if(rot1 == crntRot).
You know, you might be best off trying out iTween instead. I’m pretty sure a series of iTween.RotateTo functions would do exactly what you’re looking for.
Yes, I did assign values to the rot# val’s. Interesting this is…
var crntRot = transform.rotation;
print(crntRot);
anyone value never exceeds 1.0
also, the camera seems to just stall, shaking and vibrating in one virtual (as it moves a little bit) direction/rotation. Very weird. Again this code is not too important I just wanted to mess around a bit.
var ownerTransform : Transform;
///each "rot#" val is a rotation to be plugged in
var rot1 : Quaternion;
var rot2 : Quaternion;
var rot3 : Quaternion;
///speed at whcih owner will rotate
var speed : float;
function Update () {
///retrieve currnet rotation value of object.
var crntRot = ownerTransform.rotation;
print("rot1 " + rot1);
print("rot2 " + rot2);
print("rot3 " + rot3);
print("crntRot " + crntRot);
///compare
if(rot1 == crntRot)
{
print("at rot1 pos");
ownerTransform.rotation = Quaternion.Slerp (rot1, rot2, Time.deltaTime * 0.1f);
return;
}
///compare
if(rot2 == crntRot)
{
print("at rot2 pos");
ownerTransform.rotation = Quaternion.Slerp (rot2, rot3, Time.deltaTime * 0.1f);
return;
}
///compare
if(rot3 == crntRot)
{
print("at rot3 pos");
ownerTransform.rotation = Quaternion.Slerp (rot3, rot1, Time.deltaTime * 0.1f);
return;
}
}
one thing. the var ownerTransform asks for an object in the inspector. Ideally I want this to be the script owner. So naming it as such is not an issue correct? It just seems odd, defining the owner as the ownerTransform. Regardless. that is the code I am working with. The initial rotation of the object is == to rot1 value I plugged in, so that should get the ball rolling as they say, but it just stays still. Still.
You don’t need to define the ownerTransform at all. The script knows who its owner is.
transform.rotation = slerp(…)
also, you have taken my suggestion and gotten it backwards… Time.deltaTime is usually in the vicinity of 0.01 (very small), 0.01 * 0.1 = very small value (ie hardly rotate at all).
You need to keep in mind that Update() is called as fast as it can, which is likely to be up around 100 times/second, if you specify a rotation float of over 1, you are going to see some really fast rotation, so fast it might be doing several full spins in one update.
ok, so here are my readings at what is happening.
At start…
readings…
rot1 (0.0, 0.0, 0.0, 1); //// this is fine, set in the inspector, matching…
crntRot (the owners rotation).
Result with 0.1f, is an instant switch from rot1 to rot 2, a near 180 with out any of the desired effect I had wanted of seeing the light rotate at human speed.
then, at rot 2
the console spits out that the crntRot is (-0.7, -0.6, 0.4, 0.0);
and it sits there, at that rotation infinitely.
