#include "quaternion.h"

void CQuaternion::Set ( float a, float b, float c, float d )
// sets a quaternion to given values
{
	A = a;
	B = b;
	C = c;
	D = d;
}

CQuaternion CQuaternion::operator * ( const CQuaternion &quaternion ) const
// performs multiplication of two quaternions
{
	float a, b, c, d;

	// calculate
	a = ( A * quaternion.D ) + ( D * quaternion.A ) + ( B * quaternion.C ) - ( C * quaternion.B );
	b = ( B * quaternion.D ) + ( D * quaternion.B ) + ( C * quaternion.A ) - ( A * quaternion.C );
	c = ( C * quaternion.D ) + ( D * quaternion.C ) + ( A * quaternion.B ) - ( B * quaternion.A );
	d = ( D * quaternion.D ) - ( A * quaternion.A ) - ( B * quaternion.B ) - ( C * quaternion.C );

	return CQuaternion ( a, b, c, d );
}

CQuaternion & CQuaternion::operator *= ( const CQuaternion &quaternion )
// performs multiplication of two quaternions
{
	// calculate
	A = ( A * quaternion.D ) + ( D * quaternion.A ) + ( B * quaternion.C ) - ( C * quaternion.B );
	B = ( B * quaternion.D ) + ( D * quaternion.B ) + ( C * quaternion.A ) - ( A * quaternion.C );
	C = ( C * quaternion.D ) + ( D * quaternion.C ) + ( A * quaternion.B ) - ( B * quaternion.A );
	D = ( D * quaternion.D ) - ( A * quaternion.A ) - ( B * quaternion.B ) - ( C * quaternion.C );

	return *this;
}

CQuaternion Conjugate ( CQuaternion &quaternion )
// conjugates a quaternion
{
	CQuaternion ConjugatedQuaternion;

	// negate first three elements
	ConjugatedQuaternion.Set ( -quaternion.A, -quaternion.B, -quaternion.C, quaternion.D );

	return ConjugatedQuaternion;
}

CVertex RotateVertexAroundAxis ( CVertex vertex, CVector3 axis, float angle )
// rotates a vertex a given angle around axis
{
	float short_term;
	CQuaternion VertexQuaternion, RotationQuaternion, ResultingQuaternion;

	// get quaternion from vertex
	VertexQuaternion.Set ( vertex.GetX ( ), vertex.GetY ( ), vertex.GetZ ( ), 1.0f );

	// normalize length for safety purposes
	//Normalize ( axis );

	// use short-cut to avoid redundant calculations
	short_term = ( float ) ::sin ( angle / 2.0f );

	// get quaternion from axis
	RotationQuaternion.Set ( axis.X * short_term, axis.Y * short_term, axis.Z * short_term, ( float ) ::cos ( angle / 2.0f ) );

	// calculate result
	//ResultingQuaternion = RotationQuaternion * VertexQuaternion * Conjugate ( RotationQuaternion );
	ResultingQuaternion = Conjugate ( RotationQuaternion ) * VertexQuaternion * RotationQuaternion;

	// return rotated vertex
	return CVertex ( ResultingQuaternion.A, ResultingQuaternion.B, ResultingQuaternion.C );
}

CVertex Point;
CVector3 Axis;

Point.Set ( 3.0f, 7.0f, -2.0f );
Axis.Set ( 0.156f, -0.312f, 0.937f );
CVertex Result = RotateVertexAroundAxis ( Point, Axis, 30.0f );
printf ( "result: %f %f %f", Result.GetX ( ), Result.GetY ( ), Result.GetZ ( ) );

result: 2.999555 6.998961 -1.999703

ResultingQuaternion = Conjugate ( RotationQuaternion ) * VertexQuaternion * RotationQuaternion;

ResultingQuaternion = RotationQuaternion * VertexQuaternion * Conjugate ( RotationQuaternion );

Quote:Original post by jyk
Here's a guess though: you appear to be passing the angle argument in degrees, but C++ trig functions work with radians.

Quote:Original post by jyk
First, whenever I see someone implementing a general game math library from scratch, I feel compelled to point out there are many such libraries already available.

Quote:Original post by jyk
1. I would call the elements x, y, z, and w, rather than A, B, C, and D. It is the convention, and will make your code easier to read and to compare with written examples. It will also make it easier to follow the code, since (at least in the context of rotations), the named elements x, y, z, and w each has its own significance. (I see that the paper you're referencing uses A, B, C, and D, but I would still suggest that you use the other convention.)

Quote:Original post by jyk
3. I would argue that there is nothing in particular to be gained by prefixing your class names with 'C'.

5. In C++ it's preferred to declare and initialize variables at first use, rather than declaring them at the top of the function (as was required by earlier versions of the C standard).

Quote:Original post by jyk
6. I would suggest starting variable names with a lower-case letter rather than upper-case, to distinguish them from function and class names.

Quote:Original post by jyk
2. If you don't already, you should include a constructor that takes four real-number values (i.e. x, y, z, and w). Then, many of the places where you create a quaternion and then assign values to it can be streamlined, code-wise.

Quote:Original post by jyk
4. You'll want a function to build a rotation quaternion from an axis-angle pair (this is a common enough operation that you won't want to code it from scratch every time you encounter it).

Quote:Original post by Nyarlath
I say this only as a side-note, since it appears that the operator *= is not used anywhere in the code: To calculate B you should use the previous value of A, not the one computed at the line above. Same for C and D.

Quote:Original post by d h k
These two are regarding "style" and to be honest, I've just had it with these discussions... ;) I respect your comments and maybe, if looked at from this or that angle, they would actually make this or that aspect a bit more clear or read better or whatever, but, to be honest, everybody has a different style, and back when I posted my vector header-file for criticism, people told me to use the C-prefix, for example (well, some did, others said: "NOO! DON'T!") - I prefer concentrating on getting the code to work in a good way (as long as nobody comes up with real, rational reasons of why people should use this or that way which are a little more elaborate than "doing this might improve readibility").

Quote:
One more question: is there a nicer way than writing your own deg2rad-conversion functions (in my engine, there's no real place for these functions as of now)? I'd really prefer using functions from cmath for that, but it seems it has no such functions (or I can't find them). Right now, I just do the conversion on the spot, but that's very ugly, obviously.