quaternion_rotation.cpp

#define _USE_MATH_DEFINES

#include "allegro5/allegro.h"
#include "allegro5/allegro_primitives.h"
#include "math.h"
#include "quat.h"
#include "matrix.h"
#include <iostream>

const int SCREEN_X = 800;
const int SCREEN_Y = 600;

const float FPS = 10.0f;

const int CUBE_LINES = 12;
const int CUBE_VERTS = 8;
// *********************************
typedef float matrix[3][3];
// *********************************
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *event_queue;
ALLEGRO_TIMER *timer;

struct verts
{
        float vx;
        float vy;
        float vz;
};
// *********************************
struct lines
{
        int start;
        int end;
};
// *********************************
float deg_to_rad(float deg)
{
    return deg * ((float)M_PI / 180.0f);
}



// *********************************
void check_angles(float &x_ang, float &y_ang, float &z_ang)
{
        if(x_ang >= 180.0f)
            x_ang -= 360.0f;
        else if(x_ang < -180.0f)
            x_ang += 360.f;

        if(y_ang >= 180.0f)
            y_ang -= 360.0f;
        else if(y_ang < -180.0f)
            y_ang += 360.f;

        if(z_ang >= 180.0f)
            z_ang -= 360.0f;
        else if(z_ang < -180.0f)
            z_ang += 360.f;
}
// *********************************
void set_polygon_verts(verts *polygon_verts)
{
        polygon_verts[0].vx = 00.0f;
        polygon_verts[0].vy = 00.0f;
        polygon_verts[0].vz = 00.0f;

        polygon_verts[1].vx = -100.0f;
        polygon_verts[1].vy = 100.0f;
        polygon_verts[1].vz = 00.0f;

        polygon_verts[2].vx = 100.0f;
        polygon_verts[2].vy = 100.0f;
        polygon_verts[2].vz = 0.0f;
}
void set_polygon_lines(lines *polygon_lines)
{
        polygon_lines[0].start = 0;
        polygon_lines[0].end = 1;

        polygon_lines[1].start = 1;
        polygon_lines[1].end = 2;

        polygon_lines[2].start = 2;
        polygon_lines[2].end = 0;
}
// *********************************
CVec3 RotatePoint( float t, CVec3 P1,
                  float angle_i, float angle_f,
                  int x1, int y1, int z1
                  , int x2, int y2, int z2)
{
    CQuat QRot;
    CQuat Q1( angle_i, CVec3( x1, y1, z1)); // Set by axis-angle
    CQuat Q2( angle_f, CVec3( x2, y2, z2));
    //QRot.Slerp( Q1, Q2, t, false);
    QRot.QuaternionSlerp( Q1, Q2, t);

    CMatrix M;
    QRot.ToMatrix( M.mf);
    return M*P1;
}
void calc_quaternion_verts( verts *c_verts, verts *s_verts,
                                    int vertices_count, float t,
                                    float angle_i, float angle_f,
                                    int x1, int y1, int z1,
                                    int x2, int y2, int z2)
{
        CVec3 P1;
        float new_x = 0.0f;
        float new_y = 0.0f;
        float new_z = 0.0f;
        float x_center = (float)SCREEN_X / 2.0f;
        float y_center = (float)SCREEN_Y / 2.0f;

        for( int i = 0; i < vertices_count; i++)
        {
            P1.x = c_verts[i].vx;
            P1.y = c_verts[i].vy;
            P1.z = c_verts[i].vz;

            //P1 = RotatePoint( t, P1, angle_i, angle_f, x1, 0.0f, 0.0f, x2, 0.0f, 0.0f);
            //P1 = RotatePoint( t, P1, angle_i, angle_f, 0.0f, y1, 0.0f, 0.0f, y2, 0.0f);
            //P1 = RotatePoint( t, P1, angle_i, angle_f, 0.0f, 0.0f, z1, 0.0f, 0.0f, z2);
            P1 = RotatePoint( t, P1, angle_i, angle_f, x1, y1, z1, x2, y2, z2);

            new_x = P1.x;
            new_y = P1.y;
            new_z = P1.z;

            s_verts[i].vx = new_x + x_center;
            s_verts[i].vy = new_y + y_center;
            s_verts[i].vz = new_z;
        }
}
// *********************************
void Draw_Shape(verts *s_verts, lines *c_lines, int lines_count)
{
        int i;
        for(i = 0; i < lines_count; i++)
        {
            al_draw_line(
                         s_verts[c_lines[i].start].vx,
                         s_verts[c_lines[i].start].vy,
                         s_verts[c_lines[i].end].vx,
                         s_verts[c_lines[i].end].vy,
                         al_map_rgb(0,255,0), 0
                         );
        }
}
// *********************************
void allegro_initialization()
{
        display = NULL;
        event_queue = NULL;
        timer = NULL;

        al_init();
        al_init_primitives_addon();

        al_set_new_display_option(ALLEGRO_VSYNC, 1, ALLEGRO_SUGGEST);
        display = al_create_display(SCREEN_X, SCREEN_Y);
        event_queue = al_create_event_queue();
        timer = al_create_timer(1.0f / FPS);

        al_register_event_source(event_queue, al_get_display_event_source(display));
        al_register_event_source(event_queue, al_get_timer_event_source(timer));

        al_start_timer(timer);
}
void swap( float &temp1, float &temp2)
{
    std::cout<<"swapping angles"<<std::endl;
        float temp3 = temp1;
        temp1 = temp2;
        temp2 = temp3;
}
int main(int argc, char *argv[])
{
        allegro_initialization();
        bool loop = true;
        bool draw = false;
        verts qpolygon_verts[3];
        set_polygon_verts(qpolygon_verts);
        verts qpolygon_screen_verts[3];
        lines qpolygon_lines[3];
        set_polygon_lines(qpolygon_lines);

        float t = 0.0f;
        float angle_i, angle_f, x1, y1, z1, x2, y2, z2;

        angle_i = 0.0f;
        angle_f = 180.0f;
        x1 = 1.0f;
        x2 = -1.0f;
        y1 = 1.0f;
        y2 = -1.0f;
        z1 = 1.0f;
        z2 = -1.0f;

        while(loop)
        {
            ALLEGRO_EVENT event;
            al_wait_for_event(event_queue, &event);

            switch(event.type)
            {
                case ALLEGRO_EVENT_DISPLAY_CLOSE:
                    loop = false;
                    break;
                case ALLEGRO_EVENT_TIMER:
                    draw = true;
                    break;
                default:
                    break;
            }
            if(draw && al_event_queue_is_empty(event_queue))
            {
                draw = false;
                al_clear_to_color(al_map_rgb(0,0,25));
                calc_quaternion_verts( qpolygon_verts, qpolygon_screen_verts, 3, t, angle_i, angle_f, x1, y1, z1, x2, y2, z2);
                Draw_Shape(qpolygon_screen_verts, qpolygon_lines, 3);
                al_flip_display();

                t += .01;
                if(t > 1)
                {
                    t = 0;
                    swap(angle_i, angle_f);//this makes sure that the polygon rotates 360 degrees by flipping the signs and swapping
                    //the angles.
                    x2*= -1;
                    y2*= -1;
                    z2*= -1;
                }
            }
        }

        al_stop_timer(timer);
        al_flush_event_queue(event_queue);
        al_destroy_event_queue(event_queue);
        al_destroy_timer(timer);
        al_destroy_display(display);

        return 0;
}