GraphicalObject.cpp

#include "GraphicalObject.h"
#include "Utility.h"


GraphicalObject::GraphicalObject (RawObject * raw_obj)
{

        // Initialize variables
        first_child = NULL;
        raw_object = raw_obj;
        position = new PositionPath ();

        // Set default position
        position->SetConstantPosition (0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);

        // initialize bounding radius
        if (raw_object != NULL)
        {bounding_radius = raw_object->GetBoundingRadius ();}
        else
        {bounding_radius = 0.0;}

        // initialize bounding box
        if (raw_object != NULL)
        {bounding_box = raw_object->GetBoundingBox ();}
        else
        {
                bounding_box.xmax = 0.0f;
                bounding_box.xmin = 0.0f;
                bounding_box.ymax = 0.0f;
                bounding_box.ymin = 0.0f;
                bounding_box.zmax = 0.0f;
                bounding_box.zmin = 0.0f;
        }

        // initialize extended culling
        UpdateBoxCorners ();
        last_outside = 0;
}

GraphicalObject::~GraphicalObject ()
{
        // do nothing
}

void GraphicalObject::ApplyTransformation (const Position & position, bool rotation)
{
        // translate and rotate according to the actual position (don't use glPushMatrix () because may want to allow
        // more than 32 consecutive calls of this routine).
        glTranslatef (position.x, position.y, position.z);
        if (rotation)
        {
                glRotatef (position.yaw, 0.0f, 0.0f, 1.0f);
                glRotatef (position.pitch, 0.0f, 1.0f, 0.0f);
                glRotatef (position.roll, 1.0f, 0.0f, 0.0f);
        }
}

void GraphicalObject::UndoTransformation (const Position & position, bool rotation)
{
        // undo rotation and translation
        if (rotation)
        {
                glRotatef (-position.roll, 1.0f, 0.0f, 0.0f);
                glRotatef (-position.pitch, 0.0f, 1.0f, 0.0f);
                glRotatef (-position.yaw, 0.0f, 0.0f, 1.0f);
        }
        glTranslatef (-position.x, -position.y, -position.z);
}

void GraphicalObject::UpdateBoundingRadius (bool recurse)
{
        ChildListElem * current_child;
        BoundingBox child_translation;
        Point corner;
        double temp;
        double max;
        int index;
        
        // update children if we are supposed to recurse
        if (recurse)
        {
                current_child = first_child;
                while (current_child != NULL)
                {
                        current_child->object->UpdateBoundingRadius (recurse);
                        current_child = current_child->next;
                }
        }

        // initialize own radius
        ComputeBoundingRadius ();

        // check children
        current_child = first_child;
        max = 0.0;

        while (current_child != NULL)
        {
                child_translation = current_child->object->position->GetTranslationBox ();
                
                // find fartherst point and add the child radius
                for (index = 0; index < 8; index++)
                {
                        corner = Utility::GetPointFromBox (child_translation, index);
                        temp = sqrt (corner.x * corner.x + corner.y * corner.y + corner.z * corner.z);
                        temp += current_child->object->bounding_radius;
                        if (temp > max) max = temp;
                }
        
                current_child = current_child ->next;
        }

        // update only if maximal radius found is indeed larger than the current radius
        if (max > bounding_radius) bounding_radius = max;
}

void GraphicalObject::UpdateBoundingBox (bool recurse)
{
        ChildListElem * current_child;
        BoundingBox child_box;
        BoundingBox child_translation;
        Position child_position;

        // update children first if we are supposed to recurse
        if (recurse)
        {
                current_child = first_child;
                while (current_child != NULL)
                {
                        current_child->object->UpdateBoundingBox (recurse);
                        current_child = current_child->next;
                }
        }

        // initialize own box
        ComputeBoundingBox ();

        // update box depending on children
        current_child = first_child;
        while (current_child != NULL)
        {
                // first, we retrieve information about the child
                child_translation = current_child->object->position->GetTranslationBox ();
                child_box = current_child->object->bounding_box;

                if (current_child->object->position->HasDynamicRotation ())
                {
                        // if changing rotation angles are allowed, we have to make a conservative guess...
                        double max_dist;
                        double x_max, y_max, z_max;

                        // find the maximal distance that a box may extend (for a cube this would be sqrt(3) * side_length / 2)
                        abs (child_box.xmax) > abs (child_box.xmin) ? x_max = abs (child_box.xmax): x_max = abs (child_box.xmin);
                        abs (child_box.ymax) > abs (child_box.ymin) ? y_max = abs (child_box.ymax): y_max = abs (child_box.ymin);
                        abs (child_box.zmax) > abs (child_box.zmin) ? z_max = abs (child_box.zmax): z_max = abs (child_box.zmin);
                        max_dist = sqrt (x_max * x_max + y_max * y_max + z_max * z_max);
                        
                        // update the own box according to this maximal distance
                        if (bounding_box.xmax < child_translation.xmax + max_dist) bounding_box.xmax = child_translation.xmax + max_dist;
                        if (bounding_box.xmin > child_translation.xmin - max_dist) bounding_box.xmin = child_translation.xmin - max_dist;
                        if (bounding_box.ymax < child_translation.ymax + max_dist) bounding_box.ymax = child_translation.ymax + max_dist;
                        if (bounding_box.ymin > child_translation.ymin - max_dist) bounding_box.ymin = child_translation.ymin - max_dist;
                        if (bounding_box.zmax < child_translation.zmax + max_dist) bounding_box.zmax = child_translation.zmax + max_dist;
                        if (bounding_box.zmin > child_translation.zmin - max_dist) bounding_box.zmin = child_translation.zmin - max_dist;

                }
                else
                {
                        // if we know that the rotation angles of the child does not change, we can update our own box in a 
                        // much better way by projecting the box corners of the child back into the own coordinate system
                        // and update the own box accordingly...
                        float matrix[16];
                        Point corner;
                        Point result;

                        // since rotation is static, we can get the position at an arbitrary time.
                        child_position = current_child->object->position->GetPosition (0);
                        child_position.x = 0.0f;
                        child_position.y = 0.0f;
                        child_position.z = 0.0f;

                        // retrieve the transformation matrix (only care about rotations)
                        glPushMatrix ();
                        glLoadIdentity ();
                        
                                current_child->object->ApplyTransformation (child_position, true);
                                glGetFloatv (GL_MODELVIEW_MATRIX, matrix);

                        glPopMatrix ();

                        // project all 8 corners and update box if necessary
                        for (int index = 0; index < 8; index++)
                        {
                                corner = Utility::GetPointFromBox (child_box, index);
                                Geometry::VectorMultiply (matrix, corner, result);

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

                current_child = current_child->next;
        }

        UpdateBoxCorners ();
}

void GraphicalObject::DrawBoundingSphere (int culling_result)
{
        if (culling_result == C_OUTSIDE)
        {glColor3f (1.0f, 0.2f, 0.2f);}
        if (culling_result == C_PARTIAL)
        {glColor3f (1.0f, 0.7f, 0.4f);}
        if (culling_result == C_INSIDE)
        {glColor3f (0.0f, 1.0f, 0.2f);}

        glutWireSphere (bounding_radius, 8, 8);
}

void GraphicalObject::DrawBoundingBox (int culling_result)
{
        if (culling_result == C_OUTSIDE)
        {Utility::SetColor (1.0f, 0.2f, 0.2f, 1.0f);}
        if (culling_result == C_PARTIAL)
        {Utility::SetColor (1.0f, 0.7f, 0.4f, 1.0f);}
        if (culling_result == C_INSIDE)
        {Utility::SetColor (0.0f, 1.0f, 0.2f, 1.0f);}

        Utility::DrawBoundingBox (bounding_box);
}

int GraphicalObject::CullObject (Camera * camera, Camera * monitor, int culling_mode, bool show)
{
        int result;

        glDisable (GL_LIGHTING);
        
        switch (culling_mode)
        {
                case    C_SPHERE:                       if (monitor == NULL)
                                                                        {result = SphereCulling2 (camera);}
                                                                        else
                                                                        {result = SphereCulling (camera, monitor);}
                                                                        if (show)
                                                                        {DrawBoundingSphere (result);}
                                                                        break;
                case    C_BOUNDING_BOX:         if (monitor == NULL)
                                                                        {result = BoxCulling2 (camera);}
                                                                        else
                                                                        {result = BoxCulling (camera, monitor);}        
                                                                        if (show)
                                                                        {DrawBoundingBox (result);}
                                                                        break;
                case    C_MIXED:                        if (monitor == NULL)
                                                                        {
                                                                                result = SphereCulling2 (camera);
                                                                                if (show)
                                                                                {DrawBoundingSphere (result);}
                                                                                if (result == C_PARTIAL)
                                                                                {
                                                                                        result = BoxCulling2 (camera);
                                                                                        if (show)
                                                                                        {DrawBoundingBox (result);}
                                                                                }
                                                                        }
                                                                        else
                                                                        {
                                                                                result = SphereCulling (camera, monitor);
                                                                                if (show)
                                                                                {DrawBoundingSphere (result);}
                                                                                if (result == C_PARTIAL)
                                                                                {
                                                                                        result = BoxCulling (camera, monitor);
                                                                                        if (show)
                                                                                        {DrawBoundingBox (result);}
                                                                                }
                                                                        }
                                                                        break;
                case    C_NONE:                         result = C_INSIDE;
                                                                        break;
                default:                                        break;
        }

        glEnable (GL_LIGHTING);

        return result;
}

void GraphicalObject::UpdateBoxCorners ()
{
        for (int index = 0; index < 8; index++)
        {
                box_corners.p[index] = Utility::GetPointFromBox (bounding_box, index);
        }
        last_outside = 0;
}


void GraphicalObject::CalculateRelativePositions ()
{
        ChildListElem * current_object;
        Position child_pos;
        Point average = {0.0f, 0.0f, 0.0f};
        int num_children = 0;

        // first calculate for all the children
        current_object = first_child;
        while (current_object != NULL)
        {
                num_children++;
                current_object->object->CalculateRelativePositions ();
                current_object = current_object->next;
        }

        // reinitialize bounding volumes
        ComputeBoundingRadius ();
        ComputeBoundingBox ();

        if (num_children == 0) return;

        // now calculate the average position of the objects...
        current_object = first_child;
        while (current_object != NULL)
        {
                child_pos = current_object->object->position->GetPosition (0);
                average.x += child_pos.x;
                average.y += child_pos.y;
                average.z += child_pos.z;
                current_object = current_object->next;
        }
        average.x /= num_children;
        average.y /= num_children;
        average.z /= num_children;

        // finally, shift all positions
        current_object = first_child;
        while (current_object != NULL)
        {
                current_object->object->position->Shift (-average.x, -average.y, -average.z);
                current_object = current_object->next;
        }
        position->Shift (average.x, average.y, average.z);
        
        UpdateBoundingRadius (true);
        UpdateBoundingBox (true);
}

int GraphicalObject::SphereCulling (Camera * camera, Camera * monitor)
{
        Point pos;
        Point origin;
        float temp_left, temp_right, temp_front, temp_back, temp_bottom, temp_top;
        float mod[16];
        float * inv_view;

        glGetFloatv (GL_MODELVIEW_MATRIX, mod);
        inv_view = monitor->GetInverseView ();
        
        /* since hierarchical objects are defined in local coordinate systems, we have to retrieve the absolute coordinates
           of our object */
        origin.x = mod[12];
        origin.y = mod[13];
        origin.z = mod[14];

        pos.x = origin.x * inv_view[0] + origin.y * inv_view[4] + origin.z * inv_view[8] + inv_view[12];
        pos.y = origin.x * inv_view[1] + origin.y * inv_view[5] + origin.z * inv_view[9] + inv_view[13];
        pos.z = origin.x * inv_view[2] + origin.y * inv_view[6] + origin.z * inv_view[10] + inv_view[14];

        // test left side
        temp_left = camera->left.n.x * pos.x + camera->left.n.y * pos.y + camera->left.n.z * pos.z + camera->left.d;
        if (temp_left < - bounding_radius)
        {return C_OUTSIDE;}

        // test right side
        temp_right = camera->right.n.x * pos.x + camera->right.n.y * pos.y + camera->right.n.z * pos.z + camera->right.d;
        if (temp_right < - bounding_radius)
        {return C_OUTSIDE;}

        // test top side
        temp_top = camera->top.n.x * pos.x + camera->top.n.y * pos.y + camera->top.n.z * pos.z + camera->top.d;
        if (temp_top < - bounding_radius)
        {return C_OUTSIDE;}

        // test bottom side
        temp_bottom = camera->bottom.n.x * pos.x + camera->bottom.n.y * pos.y + camera->bottom.n.z * pos.z + camera->bottom.d;
        if (temp_bottom < - bounding_radius)
        {return C_OUTSIDE;}

        // test front side
        temp_front = camera->front.n.x * pos.x + camera->front.n.y * pos.y + camera->front.n.z * pos.z + camera->front.d;
        if (temp_front < - bounding_radius)
        {return C_OUTSIDE;}

        // test back side
        temp_back = camera->back.n.x * pos.x + camera->back.n.y * pos.y + camera->back.n.z * pos.z + camera->back.d;
        if (temp_back < - bounding_radius)
        {return C_OUTSIDE;}

        // test partial stuff
        if (temp_left < bounding_radius || temp_right < bounding_radius || temp_top < bounding_radius || 
                temp_bottom < bounding_radius || temp_front < bounding_radius || temp_back < bounding_radius)
        {return C_PARTIAL;}

        return C_INSIDE;
}

int GraphicalObject::SphereCulling2 (Camera * camera)
{
        float mod[16];
        float res[6];
        float x, y, z;

        glGetFloatv (GL_MODELVIEW_MATRIX, mod);

        // since the center of the sphere is at (0, 0, 0) it is sufficient to look at the translation-part of the
        // matrix
        x = mod[12];
        y = mod[13];
        z = mod[14];

        for (int index = 0; index < 6; index++)
        {       
                res[index] = x * camera->planes[index].n.x + y * camera->planes[index].n.y + z * camera->planes[index].n.z + camera->planes[index].d;
                if (res[index] < - bounding_radius) return C_OUTSIDE;
        }

        if (res[0] < bounding_radius || res[1] < bounding_radius || res[2] < bounding_radius ||
                res[3] < bounding_radius || res[4] < bounding_radius || res[5] < bounding_radius )
        {
                return C_PARTIAL;
        }

        return C_INSIDE;

}

int GraphicalObject::BoxCulling (Camera * camera, Camera * monitor)
{
        int index;
        float mod[16];
        float * inv_view;
        Point temp_point[8];
        Point corner[8];
        bool inside;
        bool outside;

        // retrieve inverse view matrix of the monitor
        glGetFloatv (GL_MODELVIEW_MATRIX, mod);
        inv_view = monitor->GetInverseView ();

        // transform into global coordinates
        for (index = 0; index < 8; index++)
        {
                Geometry::VectorMultiply (mod, box_corners.p[index], temp_point[index]);
                Geometry::VectorMultiply (inv_view, temp_point[index], corner[index]);
        }

        // just test all points against all planes (non optimized)
        inside = true;
        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->left.n.x + corner[index].y * camera->left.n.y + 
                        corner[index].z * camera->left.n.z + camera->left.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->right.n.x + corner[index].y * camera->right.n.y + 
                        corner[index].z * camera->right.n.z + camera->right.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->top.n.x + corner[index].y * camera->top.n.y + 
                        corner[index].z * camera->top.n.z + camera->top.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->bottom.n.x + corner[index].y * camera->bottom.n.y + 
                        corner[index].z * camera->bottom.n.z + camera->bottom.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->front.n.x + corner[index].y * camera->front.n.y + 
                        corner[index].z * camera->front.n.z + camera->front.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        outside = true;
        for (index = 0; index < 8; index++)
        {
                if (corner[index].x * camera->back.n.x + corner[index].y * camera->back.n.y + 
                        corner[index].z * camera->back.n.z + camera->back.d >= 0) 
                {outside = false;}
                else
                {inside = false;}
        }
        if (outside) return C_OUTSIDE;

        if (inside) return C_INSIDE;
        
        return C_PARTIAL;
}

int GraphicalObject::BoxCulling2 (Camera * camera)
{
        int point_index, plane_index, counter;
        float mod[16];
        Point corner[8];
        bool inside;
        bool outside;

        // retrieve stuff
        glGetFloatv (GL_MODELVIEW_MATRIX, mod);

        // transform into global coordinates
        for (point_index = 0; point_index < 8; point_index++)
        {Geometry::VectorMultiply (mod, box_corners.p[point_index], corner[point_index]);}

        // test the plane where the test failed the last time first.
        inside = true;
        for (counter = 0, plane_index = last_outside; counter < 6; counter++, plane_index < 5 ? plane_index++ : plane_index = 0)
        {
                outside = true;
                for (point_index = 0; point_index < 8; point_index++)
                {
                        if (corner[point_index].x * camera->planes[plane_index].n.x + corner[point_index].y * camera->planes[plane_index].n.y + 
                        corner[point_index].z * camera->planes[plane_index].n.z + camera->planes[plane_index].d >= 0) 
                        {outside = false;}
                        else
                        {inside = false;}
                }
                if (outside)
                {
                        last_outside = plane_index;
                        return C_OUTSIDE;
                }
        }
        if (inside) return C_INSIDE;

        return C_PARTIAL;
}

---