SceneExporter.cpp

Go to the documentation of this file.

/*
 * ***** 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 "SceneExporter.h"

SceneExporter::SceneExporter(COLLADASW::StreamWriter *sw, ArmatureExporter *arm, const ExportSettings *export_settings)
    : COLLADASW::LibraryVisualScenes(sw), arm_exporter(arm), export_settings(export_settings)
{}
    
void SceneExporter::exportScene(Scene *sce)
{
    // <library_visual_scenes> <visual_scene>
    std::string id_naming = id_name(sce);
    openVisualScene(translate_id(id_naming), id_naming);
    exportHierarchy(sce);
    closeVisualScene();
    closeLibrary();
}

void SceneExporter::exportHierarchy(Scene *sce)
{
    Base *base= (Base*) sce->base.first;
    while(base) {
        Object *ob = base->object;

        if (!ob->parent) {
            if(sce->lay & ob->lay) {
                switch(ob->type) {
                    case OB_MESH:
                    case OB_CAMERA:
                    case OB_LAMP:
                    case OB_ARMATURE:
                    case OB_EMPTY:
                        if (this->export_settings->selected && !(ob->flag & SELECT)) {
                            break;
                        }
                        // write nodes....
                        writeNodes(ob, sce);
                        break;
                }
            }
        }

        base= base->next;
    }
}

void SceneExporter::writeNodes(Object *ob, Scene *sce)
{
    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, sce);

        // 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 '%s'\n", gr->id.name+2); */
            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*) sce->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...
                    writeNodes(cob, sce);
                    break;
            }
        }

        b = b->next;
    }

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