void ConvertRotationToHL(const btQuaternion& quat, QAngle& hl)
{
Quaternion q(quat.getX(), -quat.getZ(), quat.getY(), quat.getW());
RadianEuler radian(q);
hl = radian.ToQAngle();
}
float Encoder::value(){
return radian()*mltData;
}
void ConvertRotationToBull(const QAngle& angles, btQuaternion& bull) {
RadianEuler radian(angles);
Quaternion q(radian);
bull.setValue(q.x, q.z, -q.y, q.w);
}
void ConvertRotationToBull(const QAngle& angles, btMatrix3x3& bull) {
RadianEuler radian(angles);
Quaternion q(radian);
btQuaternion quat(q.x, q.z, -q.y, q.w);
bull.setRotation(quat);
}
bool
UnitQuaternion::TestClass()
{
SPEW((GROUP_STUFF_TEST, "Starting UnitQuaternion Test..."));
#if 0
// ofstream testout("gene.tst",ios::app); //GY
Vector3D
r_vec;
UnitQuaternion
// q[2],
q[NUMBER_OF_MULTIPLICATIONS+1],
multiplied_q(Identity),
converted_q;
LinearMatrix4D
// lm[2],
lm[NUMBER_OF_MULTIPLICATIONS+1],
multiplied_lm(true);
Scalar r_float;
//DEBUG_STREAM<<"Starting UnitQuaternion::TestClass()\n";
for (int k=0; k<TEST_SEQUENCE_LENGTH; ++k)
{
for(int i=0; i<=NUMBER_OF_MULTIPLICATIONS; ++i)
{
//----------------------
//Generate random vector
//----------------------
for ( int j=0; j<3; ++j)
{
r_float = 2.0f*Random - 1.0f;
r_vec[j] = r_float;
}
//----------------------
//Normalize it
//----------------------
// Tell("Normalize vector\n");
r_vec.Normalize(r_vec);
//Generate random angle
Radian radian(TWO_PI*Random - PI);
//----------------------
//Make random quaternion
//----------------------
// Tell("Make random quaternion\n");
SinCosPair p;
p = radian;
UnitQuaternion r_q(
r_vec.x * p.sine,
r_vec.y * p.sine,
r_vec.z * p.sine,
p.cosine
);
Check(&r_q);
q[i] = r_q;
lm[i] = r_q;
// }
//----------------------
//Multiply quaternions
//----------------------
// Tell("Multiply quaternions...\n");
// multiplied_q.Multiply(q[1],q[0]);
UnitQuaternion previous_q(multiplied_q);
//Tell("Multiply quaternions.\n");
multiplied_q.Multiply(q[i],previous_q);
//Tell("Multiplied quaternions\n");
Check(&multiplied_q);
if(i)
{
//----------------------
//Normalize quaternion
//----------------------
// Tell("Normalize quaternion\n");
multiplied_q.Normalize();
Check(&multiplied_q);
}
//----------------------
//Multiply matrices
//----------------------
// Tell("Multiply matrices...\n");
// multiplied_lm.Multiply(lm[0],lm[1]);
LinearMatrix4D previous_lm(multiplied_lm);
//Tell("Multiply matrices.\n");
multiplied_lm.Multiply(previous_lm,lm[i]);
//Tell("Multiplied matrices\n");
// if(i)
//DEBUG_STREAM<<"Multiplied "<<i<<" times\n";
}
//DEBUG_STREAM<<"Multiplied "<<(i-1)<<" times\n";
//----------------------
//Convert matrix to quaternian
//----------------------
//Tell("Convert matrix to quaternian \n");
converted_q = multiplied_lm;
Check(&converted_q);
//-----------------------
// Compare results
//-----------------------
//Tell("Compare results\n");
for (i=0; i<4; i++)
{
if (!Close_Enough(converted_q[i],
multiplied_q[i],
SMALL)//4.91e-3f)//2.62e-3f) //1.9874e-3f)//1.66e-4f)//1.35e-4f)//8.0e-6f) //2.75e-06f)//SMALL)
)
{
//DEBUG_STREAM<<"i= "<<i<<" delta= "<<(converted_q[i]-multiplied_q[i])<<endl;
//testout<<"i= "<<i<<" delta= "<<(converted_q[i]-multiplied_q[i])<<endl;
}
}
//DEBUG_STREAM<<"SUCCESS at "<<(k+1)<<" tests !!!!!\n";
}
// testout.close();
//DEBUG_STREAM<<"UnitQuaternion::TestClass done !\n";
//Tell(" UnitQuaternion::TestClass is stubbed out!\n");
#endif
return false;
}
void View::keyPressEvent(QKeyEvent *event)
{
if (event->key() == Qt::Key_Escape)
{
QApplication::quit();
}
else if (event->key() == Qt::Key_A)
{
m_camera.center.x -= 0.5;
updateCamera();
}
else if (event->key() == Qt::Key_D)
{
m_camera.center.x += 0.5;
updateCamera();
}
else if (event->key() == Qt::Key_C && drawComet == false)
{
cout << "reset !" << endl;
drawComet = true;
position_counter = 0;
CometPos.x = 50; CometPos.y = 50; CometPos.z = -10;
Vector3 collide_Pos;
double deg = -120.0;
collide_Pos.x = EarthPos.x*cos(radian(deg)) - EarthPos.z*sin(radian(deg));
collide_Pos.z = EarthPos.x*sin(radian(deg)) + EarthPos.z*cos(radian(deg));
collide_Pos.y = 0;
cout << "collide pos x : " << collide_Pos.x << endl;
cout << "collide pos y : " << collide_Pos.y << endl;
cout << "collide pos z : " << collide_Pos.z << endl;
m_points.clear();
for(int i=0 ; i < 360 ; i++)
{
Bcurve::computeBezier5points(m_points,CometPos,
Vector3(-50,0,0),Vector3(-150,20,-20),Vector3(-80,10,-10),
collide_Pos,
(float)i/360.0);
}
}
else if (event->key() == Qt::Key_R)
{
// Generate the random track
generate_random_track(this->m_random_track,400,5);
m_camera.center = EarthPos;
m_camera_random_track = true;
}
// Set camera back to the original position
else if (event->key() == Qt::Key_T)
{
setCameraDefaultValue();
updateCamera();
stop = false;
m_camera_random_track = false;
m_follow_comet = false;
flag_resetParticleCube = false;
collision = false;
m_emitter_explosion->setRadius(0.01);
globalcounter = 0;
}
// Let the camera follow the comet
else if (event->key() == Qt::Key_F)
{
this->m_follow_comet = true;
}
// Pause the movement of the moon and the earth
else if (event->key() == Qt::Key_P)
{
if(stop == false){
stop =true;
}
else{
stop = false;
}
}
// Switch the camera with different position
else if (event->key() == Qt::Key_3)
{
m_camera.center = EarthPos;
m_camera.zoom = 12;
stop = true;
updateCamera();
}
// Enable/Disable Bump Mapping
else if (event->key() == Qt::Key_B)
{
if(bumpmapping == false)
bumpmapping = true;
else
bumpmapping = false;
}
else if (event->key() == Qt::Key_L){
if( drawline == true)
drawline = false;
else
drawline = true;
}
else if (event->key() == Qt::Key_1){
stop = false;
m_camera_random_track = false;
m_follow_comet = false;
setCameraDefaultValue();
updateCamera();
}
}
void View::renderPlanet()
{
//Get the time in second
float time = m_increment / (float) 60.0;
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
/*****render earth ****************/
if(!collision){
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_cubeMap);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_texID_earth);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,m_texID_earth_normal);
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D,m_texID_earth_cloud);
if(bumpmapping)
{
m_shaderPrograms["bumpmapping"]->bind();
m_shaderPrograms["bumpmapping"]->setUniformValue("tex",1);
m_shaderPrograms["bumpmapping"]->setUniformValue("tex_normal",2);
m_shaderPrograms["bumpmapping"]->setUniformValue("tex_cloud",3);
m_shaderPrograms["bumpmapping"]->setUniformValue("envMap",0);
}
else
{
m_shaderPrograms["texture"]->bind();
m_shaderPrograms["texture"]->setUniformValue("tex",1);
}
glPushMatrix();
EarthPos.x = 10*cos(radian(time*20));
EarthPos.z = -10*sin(radian(time*20));
EarthPos.y = 0;
//cout << "earth pos x : " << EarthPos.x << endl;
//cout << "earth pos z : " << EarthPos.z << endl;
// rotate around the sun
glRotatef(time*20.0,0.0,1.0,0.0);
glTranslatef(10,0.0,0.0);
glPushMatrix();
glRotatef(90,-1.0,0,0.0);
//self rotate
glRotatef(time*50,0,0.0,-1.0);
gluQuadricNormals(m_quadric_earth,GLU_SMOOTH);
gluQuadricTexture(m_quadric_earth,GL_TRUE);
gluSphere(m_quadric_earth,1.5,25.0,25.0);
glPopMatrix();
m_shaderPrograms["bumpmapping"]->release();
m_shaderPrograms["texture"]->release();
glBindTexture(GL_TEXTURE_2D,0);
/*** render earth finised ***/
/*** Draw the orbit of the moon ***/
if(drawline){
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glPushMatrix();
glRotatef(90,1,0,0);
GLint circle_points = 100;
glBegin(GL_LINE_LOOP);
glColor3f(0.0f, 0.2f, 0.2f);
for (int i = 0; i < circle_points; i++) {
float angle = 2*PI*i/circle_points;
glVertex2f(2.5*(cos(angle)),2.5*(sin(angle)));
}
glEnd();
glPopMatrix();
glEnable(GL_TEXTURE_2D);
glColor4f(1.0f,1.0f,1.0f,0.0f);
}
/*** finish the orbit drawing *******/
/*** render moon ****/
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_texID_moon);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,m_texID_moon_normal);
if(bumpmapping)
{
m_shaderPrograms["bumpmapping2"]->bind();
m_shaderPrograms["bumpmapping2"]->setUniformValue("tex",1);
m_shaderPrograms["bumpmapping2"]->setUniformValue("tex_normal",2);
}
else
{
m_shaderPrograms["texture"]->bind();
m_shaderPrograms["texture"]->setUniformValue("tex",1);
}
glPushMatrix();
glRotatef(time*50,0,1.0,0);
glTranslatef(-2.5,0.0,0.0);
gluQuadricNormals(m_quadric_moon,GLU_SMOOTH);
gluQuadricTexture(m_quadric_moon,GL_TRUE);
gluSphere(m_quadric_moon,0.5,50.0,50.0);
glPopMatrix();
m_shaderPrograms["bumpmapping2"]->release();
m_shaderPrograms["texture"]->release();
glBindTexture(GL_TEXTURE_2D,0);
/*** render moon finished ***/
glPopMatrix();
}
/**** render Satrun ******/
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,m_texID_saturn);
m_shaderPrograms["phong"]->bind();
m_shaderPrograms["phong"]->setUniformValue("tex",1);
glPushMatrix();
glRotatef(-45*time,0,1.0,0);
glTranslatef(-25,0,0);
//glRotatef(time*50,0,0,1.0);
gluQuadricNormals(m_quadric_saturn,GLU_SMOOTH);
gluQuadricTexture(m_quadric_saturn,GL_TRUE);
gluSphere(m_quadric_saturn,1.0,50.0,50.0);
m_shaderPrograms["phong"]->release();
m_shaderPrograms["texture"]->bind();
m_shaderPrograms["texture"]->setUniformValue("tex",1);
glPushMatrix();
glRotatef(45,1,0,0);
//glTranslatef(cur.x,cur.y,cur.z);
gluQuadricNormals(this->m_quadric_saturn_disk,GLU_SMOOTH);
gluQuadricTexture(this->m_quadric_saturn_disk,GL_TRUE);
//glBindTexture(GL_TEXTURE_2D,this->id_sun);
gluDisk(this->m_quadric_saturn_disk,1.2,3,50,1);
glPopMatrix();
glPopMatrix();
m_shaderPrograms["texture"]->release();
glBindTexture(GL_TEXTURE_2D,0);
/********** render sun (every planet must render before the sun **************/
if(globalcounter < 265)
{
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glBlendFunc(GL_SRC_ALPHA,GL_ONE);
glActiveTexture(GL_TEXTURE4);
glBindTexture(GL_TEXTURE_2D,m_texID_sun);
glEnable(GL_BLEND);
m_shaderPrograms["texture"]->bind();
m_shaderPrograms["texture"]->setUniformValue("tex",4);
SunPos.x = 0.0;
SunPos.y = 0.0;
SunPos.z = 0.0;
gluQuadricNormals(m_quadric_sun,GLU_SMOOTH);
gluQuadricTexture(m_quadric_sun,GL_TRUE);
gluSphere(this->m_quadric_sun,3.0f,50,50);
m_shaderPrograms["texture"]->release();
glBindTexture(GL_TEXTURE_2D,0);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
}
/********************************/
// glBegin(GL_QUADS);
// //glMultiTexCoord2f(GL_TEXTURE1,1,1);
// glNormal3f(0.0,0.0,1.0);
// glTexCoord2f(1,1);
// glVertex3f( 1.5,1.5,0);
// //glMultiTexCoord2f(GL_TEXTURE1,0,1);
// glTexCoord2f(0,1);
// glVertex3f(-1.5,1.5,0);
// //glMultiTexCoord2f(GL_TEXTURE1,0,0);
// glTexCoord2f(0,0);
// glVertex3f(-1.5,-1.5,0);
// //glMultiTexCoord2f(GL_TEXTURE1,1,0);
// glTexCoord2f(1,0);
// glVertex3f( 1.5,-1.5,0);
// glEnd();
// Enable light again
glEnable(GL_LIGHTING);
}
