GroupObject.cpp

#include "GroupObject.h"


GroupObject::GroupObject () : GraphicalObject (NULL)
{
        // nothing to do
}

GroupObject::~GroupObject ()
{
        // nothing to do
}

void GroupObject::Draw (int time, Camera * camera, Camera * monitor, bool show_bounding_volume, int culling_mode, bool level_of_detail)
{
        Position pos;
        ChildListElem * current_child;
        int     culling_result;
        bool rotation;

        // return if position is not defined for the current time
        if (!(position->IsDefined (time))) return;

        // retrieve actual position
        pos = position->GetPosition (time);

        // check if there is rotation
        rotation = position->HasStaticRotation ();

        // change modelview matrix
        ApplyTransformation (pos, rotation);

        // cull the actual object
        culling_result = CullObject (camera, monitor, culling_mode, show_bounding_volume);

        // if the object does not lie completely outside, ...
        if (culling_result != C_OUTSIDE)
        {
                // ... , draw all children
                current_child = first_child;
                while (current_child != NULL)
                {
                        // suppress further culling if the object lies completely inside the viewing frustum
                        if (culling_result == C_PARTIAL)
                        {current_child->object->Draw (time, camera, monitor, show_bounding_volume, culling_mode, level_of_detail);}
                        else
                        {current_child->object->Draw (time, camera, monitor, show_bounding_volume, C_NONE, level_of_detail);}

                        current_child = current_child->next;
                }
        }

        // finally, undo the change to the modelview matrix
        UndoTransformation (pos, rotation);
}

void GroupObject::AddChild (GraphicalObject * child)
{
        ChildListElem * current_child;

        if (first_child == NULL)
        {
                first_child = new ChildListElem;
                first_child->object = child;
                first_child->next = NULL;
        }
        else
        {
                current_child = first_child;
                while (current_child->next != NULL) current_child = current_child->next;
                
                current_child->next = new ChildListElem;
                current_child->next->next = NULL;
                current_child->next->object = child;
        }

        UpdateBoundingRadius (false);
        UpdateBoundingBox (false);
}

void GroupObject::ComputeBoundingRadius ()
{
        bounding_radius = 0.0;
}

void GroupObject::ComputeBoundingBox ()
{
        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;
}

void GroupObject::PrintToConsole ()
{
        Position pos = position->GetPosition (0);
        ChildListElem * current_object;

        printf ("GroupObject: {%g, %g, %g, %g, %g, %g}\n", pos.x, pos.y, pos.z, pos.roll, pos.pitch, pos.yaw);
        
        if (first_child != NULL)
        {
                printf ("Printing Children: ----------------------------------\n");
                current_object = first_child;
                while (current_object != NULL)
                {
                        current_object->object->PrintToConsole ();
                        current_object = current_object->next;
                }
                printf("End Printing Children: -------------------------------\n");
        }
        else
        {printf ("No Children detected\n");}
}

---