I\'m working on a simple rotate routine which normalizes an objects rotation between 0 and 360 degrees. My C# code seems to be working but I\'m not entirely happy with it. Can a
I'd recommend making separate function for normalizing angle - it's a cleaner solution.
public static float NormalizeEulerAngle(float angle){
var normalized = angle % 360;
if(normalized < 0)
normalized += 360;
return normalized;
}
Fiddle proving that such function works as intended: https://dotnetfiddle.net/Vh4CUa
And then you can use it like here:
public void Rotate(int degrees){
orientation = NormalizeEulerAngle(orientation + degrees);
}
Function that comes handy when normalizing angles (degrees) into interval [0, 360> :
float normalize_angle(float angle)
{
float k = angle;
while(k < 0.0)
k += 360.0;
while(k >= 360.0)
k -= 360.0;
return k;
}
This can be simplified to the following.
public void Rotate (int degrees) {
this.orientation = (this.orientation + degrees) % 360;
if (this.orientation < 0) this.orientation += 360;
}
C# follows the same rules as C and C++ and i % 360
will give you a value between -359
and 359
for any integer, then the second line is to ensure it's in the range 0 through 359 inclusive.
If you wanted to be shifty, you could get it down to one line:
this.orientation = (this.orientation + (degrees % 360) + 360) % 360;
which would keep it positive under all conditions but that's a nasty hack for saving one line of code, so I wouldn't do it, but I will explain it.
From degrees % 360
you will get a number between -359
and 359
. Adding 360
will modify the range to between 1
and 719
. If orientation
is already positive, adding this will guarantee it still is, and the final % 360
will bring it back to the range 0
through 359
.
At a bare minimum, you could simplify your code since the if
s and while
s can be combined. For example, the result of the conditions in these two lines:
if (this.orientation < 0)
while (this.orientation < 0)
is always the same, hence you don't need the surrounding if
.
So, to that end, you could do:
public void Rotate (int degrees) {
this.orientation += degrees;
while (this.orientation < 0) this.orientation += 360;
while (this.orientation > 359) this.orientation -= 360;
}
but I'd still go for the modulus version since it avoids loops. This will be important when a user enters 360,000,000,000 for the rotation (and they will do this, believe me) and then find they have to take an early lunch while your code grinds away :-)
I prefer to avoid loops, conditionals, arbitrary offsets (3600), and Math.____()
calls:
var degrees = -123;
degrees = (degrees % 360 + 360) % 360;
// degrees: 237
Use modulo arithmetic:
this.orientation += degrees;
this.orientation = this.orientation % 360;
if (this.orientation < 0)
{
this.orientation += 360;
}
This is one that normalizes to any range. Useful for normalizing between [-180,180], [0,180] or [0,360].
( it's in C++ though )
// Normalizes any number to an arbitrary range
// by assuming the range wraps around when going below min or above max
double normalize( const double value, const double start, const double end )
{
const double width = end - start ; //
const double offsetValue = value - start ; // value relative to 0
return ( offsetValue - ( floor( offsetValue / width ) * width ) ) + start ;
// + start to reset back to start of original range
}
For ints
// Normalizes any number to an arbitrary range
// by assuming the range wraps around when going below min or above max
int normalize( const int value, const int start, const int end )
{
const int width = end - start ; //
const int offsetValue = value - start ; // value relative to 0
return ( offsetValue - ( ( offsetValue / width ) * width ) ) + start ;
// + start to reset back to start of original range
}
So basically the same but without the floor. The version I personally use is a generic one that works for all numeric types and it also uses a redefined floor that does nothing in case of integral types.