VertexArrayObject.cpp

#include "VertexArrayObject.h"
#include "Textures.h"

VertexArrayObject::VertexArrayObject ()
{
        // initialize
        vertex_pointer = NULL;
        num_vertices = 0;
        index_pointer = NULL;
        num_faces = 0;
        normal_pointer = NULL;
        texture_pointer = NULL;

        bounding_volumes_computed = false;
}

VertexArrayObject::~VertexArrayObject ()
{
        if (vertex_pointer != NULL) delete vertex_pointer;
        if (index_pointer != NULL) delete index_pointer;
        if (normal_pointer != NULL) delete normal_pointer;
        if (texture_pointer != NULL) delete texture_pointer;
}

void VertexArrayObject::SetVertexData (float * data, int num_vertices_)
{
        vertex_pointer = data;
        num_vertices = num_vertices_;
        bounding_volumes_computed = false;
}

void VertexArrayObject::SetVertexIndices (GLuint * indices, int num_faces_)
{
        index_pointer = indices;
        num_faces = num_faces_;
}

void VertexArrayObject::SetTextureCoordinates (float * data, GLuint texture_id_)
{
        texture_pointer = data;
        texture_id = texture_id_;
}

double VertexArrayObject::GetBoundingRadius ()
{
        if (!bounding_volumes_computed)
        {ComputeBoundingVolumes ();}

        return bounding_radius;
}

BoundingBox VertexArrayObject::GetBoundingBox ()
{
        if (!bounding_volumes_computed)
        {ComputeBoundingVolumes ();}

        return bounding_box;
}

void VertexArrayObject::Draw ()
{
        // enable everything needed to draw the object
        glEnableClientState (GL_VERTEX_ARRAY);
        if (normal_pointer != NULL) glEnableClientState (GL_NORMAL_ARRAY);
        if (texture_pointer != NULL) glEnableClientState (GL_TEXTURE_COORD_ARRAY);

        glVertexPointer (3, GL_FLOAT, 0, vertex_pointer);
        if (normal_pointer != NULL) glNormalPointer (GL_FLOAT, 0 , normal_pointer);
        if (texture_pointer != NULL)
        {
                glEnable (GL_TEXTURE_2D);
                glBindTexture (GL_TEXTURE_2D, texture_id);
                glTexCoordPointer (2, GL_FLOAT, 0, texture_pointer);
        }

        // set up color and draw the arrays
        glColor4fv (color);
        glDrawElements (GL_TRIANGLES, num_faces * 3, GL_UNSIGNED_INT, index_pointer);

        // restore the state by disabling
        if (texture_pointer != NULL) 
        {
                glDisable (GL_TEXTURE_2D);
                glDisableClientState (GL_TEXTURE_COORD_ARRAY);
        }
        if (normal_pointer != NULL) glDisableClientState (GL_NORMAL_ARRAY);
        glDisableClientState (GL_VERTEX_ARRAY);

        if (show_normals)
        {Draw_Normals ();}
}

void VertexArrayObject::Draw_Normals ()
{
        Point p2;

        glColor3f (0.4f, 0.4f, 0.8f);
        glBegin (GL_LINES);

        for (int index = 0; index < num_vertices; index++)
        {
                glVertex3f (vertex_pointer[3*index], vertex_pointer[3*index+1], vertex_pointer[3*index+2]);
                p2.x = vertex_pointer[3*index] + normal_pointer[3*index] * normal_length;
                p2.y = vertex_pointer[3*index+1] + normal_pointer[3*index+1] * normal_length;
                p2.z = vertex_pointer[3*index+2] + normal_pointer[3*index+2] * normal_length;
                glVertex3f (p2.x, p2.y, p2.z);
        }

        glEnd ();
}

void VertexArrayObject::ComputeNormals (bool clock_wise)
{
        Point p1, p2, p3;
        Vector v1, v2;
        Vector cross_result;
        Vector normal;
        float weight;
        int base, i1, i2, i3;

        // check if there already is an array
        if (normal_pointer != NULL) delete [] normal_pointer;

        normal_pointer = new float[num_vertices*3];

        for (int curr_vertex = 0; curr_vertex < num_vertices; curr_vertex++)
        {
                normal.x = 0.0f;
                normal.y = 0.0f;
                normal.z = 0.0f;

                for (int curr_index = 0; curr_index < num_faces*3; curr_index ++)
                {
                        if (index_pointer[curr_index] == curr_vertex)
                        {
                                base = curr_index / 3;
                                i1 = index_pointer[curr_index];
                                i2 = index_pointer[3*base + (curr_index+1)%3];
                                i3 = index_pointer[3*base + (curr_index+2)%3];

                                p1.x = vertex_pointer[3*i1];
                                p1.y = vertex_pointer[3*i1 + 1];
                                p1.z = vertex_pointer[3*i1 + 2];

                                p2.x = vertex_pointer[3*i2];
                                p2.y = vertex_pointer[3*i2 + 1];
                                p2.z = vertex_pointer[3*i2 + 2];

                                p3.x = vertex_pointer[3*i3];
                                p3.y = vertex_pointer[3*i3 + 1];
                                p3.z = vertex_pointer[3*i3 + 2];

                                v1.x = p3.x - p1.x;
                                v1.y = p3.y - p1.y;
                                v1.z = p3.z - p1.z;

                                v2.x = p2.x - p1.x;
                                v2.y = p2.y - p1.y;
                                v2.z = p2.z - p1.z;

                                cross_result = Geometry::CrossProduct (v1, v2);
                                weight = Geometry::EnclosingAngle (v1, v2);

                                cross_result.x *= weight;
                                cross_result.y *= weight;
                                cross_result.z *= weight;                       

                                normal.x += cross_result.x;
                                normal.y += cross_result.y;
                                normal.z += cross_result.z;
                        }
                }

                Geometry::VectorNormalize (normal);

                if (!clock_wise)
                {
                        normal.x *= -1;
                        normal.y *= -1;
                        normal.z *= -1;
                }

                normal_pointer[3*curr_vertex] = normal.x;
                normal_pointer[3*curr_vertex+1] = normal.y;
                normal_pointer[3*curr_vertex+2] = normal.z;
        }
}

void VertexArrayObject::ComputeSphericalTextureCoordinates (GLuint texture_id_)
{
        int curr_vertex;

        if (normal_pointer == NULL) return;
        
        if (texture_pointer != NULL) delete texture_pointer;
        texture_pointer = new float[2*num_vertices];

        texture_id = texture_id_;

        for (curr_vertex = 0; curr_vertex < num_vertices; curr_vertex++)
        {
                texture_pointer[2*curr_vertex] = asin (normal_pointer[3*curr_vertex]) / MY_PI + 0.5;
                texture_pointer[2*curr_vertex+1] = asin (normal_pointer[3*curr_vertex+1]) / MY_PI + 0.5;
        }
}

void VertexArrayObject::ComputeBoundingVolumes ()
{
        float x, y, z;
        float dist;

        // initialize
        bounding_radius = 0.0;
        bounding_box.xmin = 0.0;
        bounding_box.xmax = 0.0;
        bounding_box.ymin = 0.0;
        bounding_box.ymax = 0.0;
        bounding_box.zmin = 0.0;
        bounding_box.zmax = 0.0;

        for (int curr_vertex = 0; curr_vertex < num_vertices; curr_vertex++)
        {
                // update radius if necessary
                x = vertex_pointer[curr_vertex*3];
                y = vertex_pointer[curr_vertex*3+1];
                z = vertex_pointer[curr_vertex*3+2];

                dist = x*x + y*y + z*z;

                if ( dist > bounding_radius) bounding_radius = dist;

                if (x > bounding_box.xmax) bounding_box.xmax = x;
                if (x < bounding_box.xmin) bounding_box.xmin = x;
                if (y > bounding_box.ymax) bounding_box.ymax = y;
                if (y < bounding_box.ymin) bounding_box.ymin = y;
                if (z > bounding_box.zmax) bounding_box.zmax = z;
                if (z < bounding_box.zmin) bounding_box.zmin = z;
        }

        bounding_radius = sqrt (bounding_radius);
        bounding_volumes_computed = true;
}

void VertexArrayObject::PrintToConsole ()
{
        int index;

        printf ("------------ Printing Vertex Data ---------------\n");
        for (index = 0; index < num_vertices; index++)
        {
                printf ("{%g, %g, %g}\n", vertex_pointer[3*index], vertex_pointer[3*index+1], vertex_pointer[3*index+2]);
        }

        printf ("------------ Printing Vertex Indices --------------\n");
        for (index = 0; index < num_faces; index++)
        {
                printf ("{%u, %u, %u}\n", index_pointer[3*index], index_pointer[3*index+1], index_pointer[3*index+2]);
        }
        printf ("------------ Printing Faces --------------\n");
        for (index = 0; index < num_faces; index ++)
        {
                printf ("{%g, %g, %g}, ", vertex_pointer[index_pointer[3*index]*3], vertex_pointer[index_pointer[3*index]*3+1], vertex_pointer[index_pointer[3*index]*3+2]);
                printf ("{%g, %g, %g}, ", vertex_pointer[index_pointer[3*index+1]*3], vertex_pointer[index_pointer[3*index+1]*3+1], vertex_pointer[index_pointer[3*index+1]*3+2]);
                printf ("{%g, %g, %g}\n", vertex_pointer[index_pointer[3*index+2]*3], vertex_pointer[index_pointer[3*index+2]*3+1], vertex_pointer[index_pointer[3*index+2]*3+2]);
        }

        if (normal_pointer != NULL)
        {
                printf ("------------ Printing Normals ---------------\n");
                for (index = 0; index < num_vertices; index++)
                {
                        printf ("{%g, %g, %g}\n", normal_pointer[3*index], normal_pointer[3*index+1], normal_pointer[3*index+2]);
                }
        }
        else
        {printf ("------------ No Normals Detected ---------------\n");}

        printf ("----------- End Of Vertex Array Component ---------------\n");
}

bool VertexArrayObject::show_normals = false;
float VertexArrayObject::normal_length = 3.0f;

---