GroupExporter.cpp

Go to the documentation of this file.

/*
 * $Id: GroupExporter.cpp 40019 2011-09-07 18:23:30Z jesterking $
 *
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Contributor(s): Chingiz Dyussenov, Arystanbek Dyussenov, Jan Diederich, Tod Liverseed.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#include "GroupExporter.h"

GroupExporter::GroupExporter(COLLADASW::StreamWriter *sw, ArmatureExporter *arm, const ExportSettings *export_settings)
    : LibraryNodes(sw), arm_exporter(arm), export_settings(export_settings)
{}
    
void GroupExporter::exportScene(Scene *sce)
{
    this->scene = sce;
    // <library_visual_scenes> <visual_scene>
    std::string id_naming = id_name(this->scene);
    openNode(translate_id(id_naming), id_naming);
    exportGroups();
    closeNode();
    closeLibrary();
}

void GroupExporter::exportGroups()
{
    Base *base= (Base*) this->scene->base.first;
    while(base) {
        Object *ob = base->object;

        if (!ob->parent) {
            if(this->scene->lay & ob->lay) {
                switch(ob->type) {
                    case OB_EMPTY:
                        if (this->export_settings->selected && !(ob->flag & SELECT) && (ob->transflag & OB_DUPLIGROUP) == OB_DUPLIGROUP && ob->dup_group) {
                            // write groups ....
                            writeGroups(ob);
                        }
                        break;
                }
            }
        }

        base= base->next;
    }
}

void GroupExporter::createGroupsList()
{
    Base *base; //= (Base*) this->scene->base.first;
    for(base = (Base *)this->scene->base.first; base; base=base->next) {
        Object *ob = base->object;

        if (!ob->parent) {
            if(this->scene->lay & ob->lay) {
                switch(ob->type) {
                    case OB_EMPTY:
                        if (this->export_settings->selected && !(ob->flag & SELECT) && (ob->transflag & OB_DUPLIGROUP) == OB_DUPLIGROUP && ob->dup_group) {
                            addGroupToList(ob);
                        }
                }
            }
        }
    }
}

void GroupExporter::addGroupToList(Object *ob)
{
    //if(this->groups
    this->groups.push_back(ob->dup_group);
    // write nodes for child objects
    Base *b;
    for(b = (Base *)this->scene->base.first; b; b=b->next) {
        // cob - child object
        Object *cob = b->object;
        if(cob->parent==ob) {
        }
    }
}

void GroupExporter::writeGroups(Object *ob)
{
    COLLADASW::Node node(mSW);
    node.setNodeId(translate_id(id_name(ob)));
    node.setType(COLLADASW::Node::NODE);

    node.start();

    bool is_skinned_mesh = arm_exporter->is_skinned_mesh(ob);

    if (ob->type == OB_MESH && is_skinned_mesh)
        // for skinned mesh we write obmat in <bind_shape_matrix>
        TransformWriter::add_node_transform_identity(node);
    else
        TransformWriter::add_node_transform_ob(node, ob);

    // <instance_geometry>
    if (ob->type == OB_MESH) {
        if (is_skinned_mesh) {
            arm_exporter->add_instance_controller(ob);
        }
        else {
            COLLADASW::InstanceGeometry instGeom(mSW);
            instGeom.setUrl(COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_geometry_id(ob)));

            InstanceWriter::add_material_bindings(instGeom.getBindMaterial(), ob);

            instGeom.add();
        }
    }

    // <instance_controller>
    else if (ob->type == OB_ARMATURE) {
        arm_exporter->add_armature_bones(ob, this->scene);

        // XXX this looks unstable...
        node.end();
    }

    // <instance_camera>
    else if (ob->type == OB_CAMERA) {
        COLLADASW::InstanceCamera instCam(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_camera_id(ob)));
        instCam.add();
    }

    // <instance_light>
    else if (ob->type == OB_LAMP) {
        COLLADASW::InstanceLight instLa(mSW, COLLADASW::URI(COLLADABU::Utils::EMPTY_STRING, get_light_id(ob)));
        instLa.add();
    }

    // empty object
    else if (ob->type == OB_EMPTY) { // TODO: handle groups (OB_DUPLIGROUP
        if((ob->transflag & OB_DUPLIGROUP) == OB_DUPLIGROUP && ob->dup_group) {
            GroupObject *go = NULL;
            Group *gr = ob->dup_group;
            /*printf("group detected %u\n", gr);
            for(go = (GroupObject*)(gr->gobject.first); go; go=go->next) {
                printf("\t%s\n", go->ob->id.name);
            }*/
        }
    }

    // write nodes for child objects
    Base *b = (Base*) this->scene->base.first;
    while(b) {
        // cob - child object
        Object *cob = b->object;

        if (cob->parent == ob) {
            switch(cob->type) {
                case OB_MESH:
                case OB_CAMERA:
                case OB_LAMP:
                case OB_EMPTY:
                case OB_ARMATURE:
                    // write node...
                    writeGroups(cob);
                    break;
            }
        }

        b = b->next;
    }

    if (ob->type != OB_ARMATURE)
        node.end();
}