Merge branch 'master' into blender2.8
[blender.git] / source / blender / collada / DocumentImporter.cpp
index 24b7fc4317dad60bb27123ef079d9cecf494b152..3df47b71598856f67e56e54017b2f7b05309eccb 100644 (file)
@@ -57,16 +57,15 @@ extern "C" {
 #include "BLI_fileops.h"
 
 #include "BKE_camera.h"
-#include "BKE_main.h"
-#include "BKE_lamp.h"
-#include "BKE_library.h"
-#include "BKE_texture.h"
+#include "BKE_collection.h"
 #include "BKE_fcurve.h"
-#include "BKE_depsgraph.h"
-#include "BKE_scene.h"
 #include "BKE_global.h"
-#include "BKE_material.h"
 #include "BKE_image.h"
+#include "BKE_layer.h"
+#include "BKE_lamp.h"
+#include "BKE_library.h"
+#include "BKE_material.h"
+#include "BKE_scene.h"
 
 #include "BLI_path_util.h"
 
@@ -82,6 +81,9 @@ extern "C" {
 
 }
 
+#include "DEG_depsgraph.h"
+#include "DEG_depsgraph_build.h"
+
 #include "ExtraHandler.h"
 #include "ErrorHandler.h"
 #include "DocumentImporter.h"
@@ -89,7 +91,7 @@ extern "C" {
 
 #include "collada_internal.h"
 #include "collada_utils.h"
-
+#include "Materials.h"
 
 /*
  * COLLADA Importer limitations:
@@ -102,11 +104,12 @@ extern "C" {
 
 DocumentImporter::DocumentImporter(bContext *C, const ImportSettings *import_settings) :
        import_settings(import_settings),
-       mImportStage(General),
+       mImportStage(Fetching_Scene_data),
        mContext(C),
-       armature_importer(&unit_converter, &mesh_importer, CTX_data_main(C), CTX_data_scene(C), import_settings),
-       mesh_importer(&unit_converter, &armature_importer, CTX_data_main(C), CTX_data_scene(C)),
-       anim_importer(&unit_converter, &armature_importer, CTX_data_scene(C))
+       view_layer(CTX_data_view_layer(mContext)),
+       armature_importer(&unit_converter, &mesh_importer, CTX_data_main(C), CTX_data_scene(C), view_layer, import_settings),
+       mesh_importer(&unit_converter, &armature_importer, CTX_data_main(C), CTX_data_scene(C), view_layer),
+       anim_importer(C, &unit_converter, &armature_importer, CTX_data_scene(C))
 {
 }
 
@@ -130,7 +133,7 @@ bool DocumentImporter::import()
        loader.registerExtraDataCallbackHandler(ehandler);
 
        // deselect all to select new objects
-       BKE_scene_base_deselect_all(CTX_data_scene(mContext));
+       BKE_view_layer_base_deselect_all(view_layer);
 
        std::string mFilename = std::string(this->import_settings->filepath);
        const std::string encodedFilename = bc_url_encode(mFilename);
@@ -146,9 +149,7 @@ bool DocumentImporter::import()
        }
 
        /** TODO set up scene graph and such here */
-
-       mImportStage = Controller;
-
+       mImportStage = Fetching_Controller_data;
        COLLADASaxFWL::Loader loader2;
        COLLADAFW::Root root2(&loader2, this);
 
@@ -179,7 +180,7 @@ void DocumentImporter::start()
 
 void DocumentImporter::finish()
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return;
 
        Main *bmain = CTX_data_main(mContext);
@@ -222,6 +223,7 @@ void DocumentImporter::finish()
                }
 
                // Write nodes to scene
+               fprintf(stderr, "+-- Import Scene --------\n");
                const COLLADAFW::NodePointerArray& roots = (*sit)->getRootNodes();
                for (unsigned int i = 0; i < roots.getCount(); i++) {
                        std::vector<Object *> *objects_done = write_node(roots[i], NULL, sce, NULL, false);
@@ -229,10 +231,6 @@ void DocumentImporter::finish()
                        delete objects_done;
                }
 
-               // update scene
-               DAG_relations_tag_update(bmain);
-               WM_event_add_notifier(mContext, NC_OBJECT | ND_TRANSFORM, NULL);
-
        }
 
 
@@ -241,7 +239,6 @@ void DocumentImporter::finish()
        armature_importer.set_tags_map(this->uid_tags_map);
        armature_importer.make_armatures(mContext, *objects_to_scale);
        armature_importer.make_shape_keys(mContext);
-       DAG_relations_tag_update(bmain);
 
 #if 0
        armature_importer.fix_animation();
@@ -257,35 +254,29 @@ void DocumentImporter::finish()
 
        if (libnode_ob.size()) {
 
-               fprintf(stderr, "got %d library nodes to free\n", (int)libnode_ob.size());
+               fprintf(stderr, "| Cleanup: free %d library nodes\n", (int)libnode_ob.size());
                // free all library_nodes
-               std::vector<Object *>::iterator lit;
-               for (lit = libnode_ob.begin(); lit != libnode_ob.end(); lit++) {
-                       Object *ob = *lit;
-
-                       Base *base = BKE_scene_base_find(sce, ob);
-                       if (base) {
-                               BLI_remlink(&sce->base, base);
-                               BKE_libblock_free_us(bmain, base->object);
-                               if (sce->basact == base)
-                                       sce->basact = NULL;
-                               MEM_freeN(base);
-                       }
+               std::vector<Object *>::iterator it;
+               for (it = libnode_ob.begin(); it != libnode_ob.end(); it++) {
+                       Object *ob = *it;
+                       BKE_scene_collections_object_remove(bmain, sce, ob, true);
                }
                libnode_ob.clear();
-
-               DAG_relations_tag_update(bmain);
        }
 
        bc_match_scale(objects_to_scale, unit_converter, !this->import_settings->import_units);
 
        delete objects_to_scale;
+
+       // update scene
+       DEG_id_tag_update(&sce->id, DEG_TAG_COPY_ON_WRITE);
+       DEG_relations_tag_update(bmain);
+       WM_event_add_notifier(mContext, NC_OBJECT | ND_TRANSFORM, NULL);
 }
 
 
 void DocumentImporter::translate_anim_recursive(COLLADAFW::Node *node, COLLADAFW::Node *par = NULL, Object *parob = NULL)
 {
-       Main *bmain = CTX_data_main(mContext);
        // The split in #29246, rootmap must point at actual root when
        // calculating bones in apply_curves_as_matrix. - actual root is the root node.
        // This has to do with inverse bind poses being world space
@@ -320,7 +311,7 @@ void DocumentImporter::translate_anim_recursive(COLLADAFW::Node *node, COLLADAFW
                translate_anim_recursive(node, node, parob);
        }
        else {
-               anim_importer.translate_Animations(bmain, node, root_map, object_map, FW_object_map, uid_material_map);
+               anim_importer.translate_Animations(node, root_map, object_map, FW_object_map, uid_material_map);
                COLLADAFW::NodePointerArray &children = node->getChildNodes();
                for (i = 0; i < children.getCount(); i++) {
                        translate_anim_recursive(children[i], node, NULL);
@@ -384,7 +375,7 @@ Object *DocumentImporter::create_camera_object(COLLADAFW::InstanceCamera *camera
        }
 
        Main *bmain = CTX_data_main(mContext);
-       Object *ob = bc_add_object(bmain, sce, OB_CAMERA, NULL);
+       Object *ob = bc_add_object(bmain, sce, view_layer, OB_CAMERA, NULL);
        Camera *cam = uid_camera_map[cam_uid];
        Camera *old_cam = (Camera *)ob->data;
        ob->data = cam;
@@ -396,12 +387,12 @@ Object *DocumentImporter::create_lamp_object(COLLADAFW::InstanceLight *lamp, Sce
 {
        const COLLADAFW::UniqueId& lamp_uid = lamp->getInstanciatedObjectId();
        if (uid_lamp_map.find(lamp_uid) == uid_lamp_map.end()) {
-               fprintf(stderr, "Couldn't find lamp by UID.\n");
+               fprintf(stderr, "Couldn't find light by UID.\n");
                return NULL;
        }
 
        Main *bmain = CTX_data_main(mContext);
-       Object *ob = bc_add_object(bmain, sce, OB_LAMP, NULL);
+       Object *ob = bc_add_object(bmain, sce, view_layer, OB_LAMP, NULL);
        Lamp *la = uid_lamp_map[lamp_uid];
        Lamp *old_lamp = (Lamp *)ob->data;
        ob->data = la;
@@ -411,12 +402,12 @@ Object *DocumentImporter::create_lamp_object(COLLADAFW::InstanceLight *lamp, Sce
 
 Object *DocumentImporter::create_instance_node(Object *source_ob, COLLADAFW::Node *source_node, COLLADAFW::Node *instance_node, Scene *sce, bool is_library_node)
 {
-       fprintf(stderr, "create <instance_node> under node id=%s from node id=%s\n", instance_node ? instance_node->getOriginalId().c_str() : NULL, source_node ? source_node->getOriginalId().c_str() : NULL);
+       //fprintf(stderr, "create <instance_node> under node id=%s from node id=%s\n", instance_node ? instance_node->getOriginalId().c_str() : NULL, source_node ? source_node->getOriginalId().c_str() : NULL);
 
        Main *bmain = CTX_data_main(mContext);
        Object *obn = BKE_object_copy(bmain, source_ob);
-       DAG_id_tag_update(&obn->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
-       BKE_scene_base_add(sce, obn);
+       DEG_id_tag_update(&obn->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
+       BKE_collection_object_add_from(bmain, sce, source_ob, obn);
 
        if (instance_node) {
                anim_importer.read_node_transform(instance_node, obn);
@@ -511,15 +502,16 @@ std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLA
        std::vector<Object *> *root_objects = new std::vector<Object *>();
 
        fprintf(stderr,
-               "Writing node id='%s', name='%s'\n",
-               id.c_str(),
-               name.c_str());
+               "| %s id='%s', name='%s'\n",
+               is_joint ? "JOINT" : "NODE ",
+               id.c_str(),
+        name.c_str() );
 
        if (is_joint) {
                if (parent_node == NULL && !is_library_node) {
                        // A Joint on root level is a skeleton without root node.
                        // Here we add the armature "on the fly":
-                       par = bc_add_object(bmain, sce, OB_ARMATURE, std::string("Armature").c_str());
+                       par = bc_add_object(bmain, sce, view_layer, OB_ARMATURE, std::string("Armature").c_str());
                        objects_done->push_back(par);
                        root_objects->push_back(par);
                        object_map.insert(std::pair<COLLADAFW::UniqueId, Object *>(node->getUniqueId(), par));
@@ -551,8 +543,7 @@ std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLA
                // maybe join multiple <instance_...> meshes into 1, and link object with it? not sure...
                // <instance_geometry>
                while (geom_done < geom.getCount()) {
-                       ob = mesh_importer.create_mesh_object(node, geom[geom_done], false, uid_material_map,
-                                                             material_texture_mapping_map);
+                       ob = mesh_importer.create_mesh_object(node, geom[geom_done], false, uid_material_map);
                        if (ob == NULL) {
                                report_unknown_reference(*node, "instance_mesh");
                        }
@@ -592,7 +583,7 @@ std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLA
                }
                while (controller_done < controller.getCount()) {
                        COLLADAFW::InstanceGeometry *geometry = (COLLADAFW::InstanceGeometry *)controller[controller_done];
-                       ob = mesh_importer.create_mesh_object(node, geometry, true, uid_material_map, material_texture_mapping_map);
+                       ob = mesh_importer.create_mesh_object(node, geometry, true, uid_material_map);
                        if (ob == NULL) {
                                report_unknown_reference(*node, "instance_controller");
                        }
@@ -633,10 +624,10 @@ std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLA
                if ( (geom_done + camera_done + lamp_done + controller_done + inst_done) < 1) {
                        //Check if Object is armature, by checking if immediate child is a JOINT node.
                        if (is_armature(node)) {
-                               ob = bc_add_object(bmain, sce, OB_ARMATURE, name.c_str());
+                               ob = bc_add_object(bmain, sce, view_layer, OB_ARMATURE, name.c_str());
                        }
                        else {
-                               ob = bc_add_object(bmain, sce, OB_EMPTY, NULL);
+                               ob = bc_add_object(bmain, sce, view_layer, OB_EMPTY, NULL);
                        }
                        objects_done->push_back(ob);
                        if (parent_node == NULL) {
@@ -709,7 +700,7 @@ finally:
  */
 bool DocumentImporter::writeVisualScene(const COLLADAFW::VisualScene *visualScene)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        // this method called on post process after writeGeometry, writeMaterial, etc.
@@ -732,19 +723,19 @@ bool DocumentImporter::writeVisualScene(const COLLADAFW::VisualScene *visualScen
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeLibraryNodes(const COLLADAFW::LibraryNodes *libraryNodes)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        Scene *sce = CTX_data_scene(mContext);
 
        const COLLADAFW::NodePointerArray& nodes = libraryNodes->getNodes();
 
+       fprintf(stderr, "+-- Read Library nodes ----------\n");
        for (unsigned int i = 0; i < nodes.getCount(); i++) {
                std::vector<Object *> *child_objects;
                child_objects = write_node(nodes[i], NULL, sce, NULL, true);
                delete child_objects;
        }
-
        return true;
 }
 
@@ -752,7 +743,7 @@ bool DocumentImporter::writeLibraryNodes(const COLLADAFW::LibraryNodes *libraryN
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeGeometry(const COLLADAFW::Geometry *geom)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        return mesh_importer.write_geometry(geom);
@@ -762,7 +753,7 @@ bool DocumentImporter::writeGeometry(const COLLADAFW::Geometry *geom)
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeMaterial(const COLLADAFW::Material *cmat)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        Main *bmain = CTX_data_main(mContext);
@@ -775,181 +766,18 @@ bool DocumentImporter::writeMaterial(const COLLADAFW::Material *cmat)
        return true;
 }
 
-// create mtex, create texture, set texture image
-MTex *DocumentImporter::create_texture(COLLADAFW::EffectCommon *ef, COLLADAFW::Texture &ctex, Material *ma,
-                                       int i, TexIndexTextureArrayMap &texindex_texarray_map)
-{
-       COLLADAFW::SamplerPointerArray& samp_array = ef->getSamplerPointerArray();
-       COLLADAFW::Sampler *sampler = samp_array[ctex.getSamplerId()];
-
-       const COLLADAFW::UniqueId& ima_uid = sampler->getSourceImage();
-
-       if (uid_image_map.find(ima_uid) == uid_image_map.end()) {
-               fprintf(stderr, "Couldn't find an image by UID.\n");
-               return NULL;
-       }
-
-       Main *bmain = CTX_data_main(mContext);
-       ma->mtex[i] = BKE_texture_mtex_add();
-       ma->mtex[i]->texco = TEXCO_UV;
-       ma->mtex[i]->tex = BKE_texture_add(bmain, "Texture");
-       ma->mtex[i]->tex->type = TEX_IMAGE;
-       ma->mtex[i]->tex->ima = uid_image_map[ima_uid];
-
-       texindex_texarray_map[ctex.getTextureMapId()].push_back(ma->mtex[i]);
-
-       return ma->mtex[i];
-}
 
 void DocumentImporter::write_profile_COMMON(COLLADAFW::EffectCommon *ef, Material *ma)
 {
-       COLLADAFW::EffectCommon::ShaderType shader = ef->getShaderType();
-
-       // blinn
-       if (shader == COLLADAFW::EffectCommon::SHADER_BLINN) {
-               ma->spec_shader = MA_SPEC_BLINN;
-               ma->spec = ef->getShininess().getFloatValue();
-       }
-       // phong
-       else if (shader == COLLADAFW::EffectCommon::SHADER_PHONG) {
-               ma->spec_shader = MA_SPEC_PHONG;
-               ma->har = ef->getShininess().getFloatValue();
-       }
-       // lambert
-       else if (shader == COLLADAFW::EffectCommon::SHADER_LAMBERT) {
-               ma->diff_shader = MA_DIFF_LAMBERT;
-       }
-       // default - lambert
-       else {
-               ma->diff_shader = MA_DIFF_LAMBERT;
-               fprintf(stderr, "Current shader type is not supported, default to lambert.\n");
-       }
-       // reflectivity
-       ma->ray_mirror = ef->getReflectivity().getFloatValue();
-       // index of refraction
-       ma->ang = ef->getIndexOfRefraction().getFloatValue();
-
-       int i = 0;
-       COLLADAFW::Color col;
-       MTex *mtex = NULL;
-       TexIndexTextureArrayMap texindex_texarray_map;
-
-       // DIFFUSE
-       // color
-       if (ef->getDiffuse().isColor()) {
-               /* too high intensity can create artefacts (fireflies)
-                  So here we take care that intensity is set to 0.8 wherever possible
-               */
-               col = ef->getDiffuse().getColor();
-               ma->ref = max_ffff(col.getRed(), col.getGreen(), col.getBlue(), 0.8);
-               ma->r = col.getRed()   / ma->ref;
-               ma->g = col.getGreen() / ma->ref;
-               ma->b = col.getBlue()  / ma->ref;
-       }
-       // texture
-       else if (ef->getDiffuse().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getDiffuse().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_COL;
-                       ma->texact = (int)i;
-                       i++;
-               }
-       }
-       // AMBIENT
-       // color
-       if (ef->getAmbient().isColor()) {
-               col = ef->getAmbient().getColor();
-               ma->ambr = col.getRed();
-               ma->ambg = col.getGreen();
-               ma->ambb = col.getBlue();
-       }
-       // texture
-       else if (ef->getAmbient().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getAmbient().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_AMB;
-                       i++;
-               }
-       }
-       // SPECULAR
-       // color
-       if (ef->getSpecular().isColor()) {
-               col = ef->getSpecular().getColor();
-               ma->specr = col.getRed();
-               ma->specg = col.getGreen();
-               ma->specb = col.getBlue();
-       }
-       // texture
-       else if (ef->getSpecular().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getSpecular().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_SPEC;
-                       i++;
-               }
-       }
-       // REFLECTIVE
-       // color
-       if (ef->getReflective().isColor()) {
-               col = ef->getReflective().getColor();
-               ma->mirr = col.getRed();
-               ma->mirg = col.getGreen();
-               ma->mirb = col.getBlue();
-       }
-       // texture
-       else if (ef->getReflective().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getReflective().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_REF;
-                       i++;
-               }
-       }
-
-       // EMISSION
-       // color
-       if (ef->getEmission().isColor()) {
-               // XXX there is no emission color in blender
-               // but I am not sure
-       }
-       // texture
-       else if (ef->getEmission().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getEmission().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_EMIT;
-                       i++;
-               }
-       }
-
-       // TRANSPARENT
-       // color
-       if (ef->getOpacity().isColor()) {
-               col = ef->getTransparent().getColor();
-               float alpha = ef->getTransparency().getFloatValue();
-               if (col.isValid()) {
-                       alpha *= col.getAlpha(); // Assuming A_ONE opaque mode
-               }
-               if (col.isValid() || alpha < 1.0) {
-                       ma->alpha = alpha;
-                       ma->mode |= MA_ZTRANSP | MA_TRANSP;
-               }
-       }
-       // texture
-       else if (ef->getOpacity().isTexture()) {
-               COLLADAFW::Texture ctex = ef->getOpacity().getTexture();
-               mtex = create_texture(ef, ctex, ma, i, texindex_texarray_map);
-               if (mtex != NULL) {
-                       mtex->mapto = MAP_ALPHA;
-                       i++;
-                       ma->spectra = ma->alpha = 0;
-                       ma->mode |= MA_ZTRANSP | MA_TRANSP;
-               }
-       }
-
-       material_texture_mapping_map[ma] = texindex_texarray_map;
+       MaterialNode matNode = MaterialNode(mContext, ef, ma, uid_image_map);
+       matNode.set_reflectivity(ef->getReflectivity().getFloatValue());
+       matNode.set_ior(ef->getIndexOfRefraction().getFloatValue());
+       matNode.set_diffuse(ef->getDiffuse(), "Diffuse");
+       matNode.set_ambient(ef->getAmbient(), "Ambient");
+       matNode.set_specular(ef->getSpecular(), "Specular");
+       matNode.set_reflective(ef->getReflective(), "Reflective");
+       matNode.set_emission(ef->getEmission(), "Emission");
+       matNode.set_opacity(ef->getOpacity(), "Opacity");
 }
 
 /** When this method is called, the writer must write the effect.
@@ -957,7 +785,7 @@ void DocumentImporter::write_profile_COMMON(COLLADAFW::EffectCommon *ef, Materia
 
 bool DocumentImporter::writeEffect(const COLLADAFW::Effect *effect)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        const COLLADAFW::UniqueId& uid = effect->getUniqueId();
@@ -994,7 +822,7 @@ bool DocumentImporter::writeEffect(const COLLADAFW::Effect *effect)
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeCamera(const COLLADAFW::Camera *camera)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        Main *bmain = CTX_data_main(mContext);
@@ -1120,7 +948,7 @@ bool DocumentImporter::writeCamera(const COLLADAFW::Camera *camera)
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeImage(const COLLADAFW::Image *image)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        const std::string& imagepath = image->getImageURI().toNativePath();
@@ -1137,7 +965,7 @@ bool DocumentImporter::writeImage(const COLLADAFW::Image *image)
        else {
                // Maybe imagepath was already absolute ?
                if (!BLI_exists(imagepath.c_str())) {
-                       fprintf(stderr, "Image not found: %s.\n", imagepath.c_str() );
+                       fprintf(stderr, "|! Image not found: %s\n", imagepath.c_str() );
                        return true;
                }
                workpath = imagepath.c_str();
@@ -1145,11 +973,11 @@ bool DocumentImporter::writeImage(const COLLADAFW::Image *image)
 
        Image *ima = BKE_image_load_exists(CTX_data_main(mContext), workpath);
        if (!ima) {
-               fprintf(stderr, "Cannot create image: %s\n", workpath);
+               fprintf(stderr, "|! Cannot create image: %s\n", workpath);
                return true;
        }
        this->uid_image_map[image->getUniqueId()] = ima;
-
+       fprintf(stderr, "| import Image: %s\n", workpath);
        return true;
 }
 
@@ -1157,7 +985,7 @@ bool DocumentImporter::writeImage(const COLLADAFW::Image *image)
  * \return The writer should return true, if writing succeeded, false otherwise.*/
 bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        Main *bmain = CTX_data_main(mContext);
@@ -1177,7 +1005,7 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
        else lamp = (Lamp *)BKE_lamp_add(bmain, (char *)la_id.c_str());
 
        if (!lamp) {
-               fprintf(stderr, "Cannot create lamp.\n");
+               fprintf(stderr, "Cannot create light.\n");
                return true;
        }
 
@@ -1198,7 +1026,6 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
                et->setData("spotsize", &(lamp->spotsize));
                lamp->spotsize = DEG2RADF(lamp->spotsize);
                et->setData("spotblend", &(lamp->spotblend));
-               et->setData("halo_intensity", &(lamp->haint));
                et->setData("att1", &(lamp->att1));
                et->setData("att2", &(lamp->att2));
                et->setData("falloff_type", &(lamp->falloff_type));
@@ -1206,38 +1033,12 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
                et->setData("clipend", &(lamp->clipend));
                et->setData("bias", &(lamp->bias));
                et->setData("soft", &(lamp->soft));
-               et->setData("compressthresh", &(lamp->compressthresh));
                et->setData("bufsize", &(lamp->bufsize));
-               et->setData("samp", &(lamp->samp));
                et->setData("buffers", &(lamp->buffers));
-               et->setData("filtertype", &(lamp->filtertype));
-               et->setData("bufflag", &(lamp->bufflag));
-               et->setData("buftype", &(lamp->buftype));
-               et->setData("ray_samp", &(lamp->ray_samp));
-               et->setData("ray_sampy", &(lamp->ray_sampy));
-               et->setData("ray_sampz", &(lamp->ray_sampz));
-               et->setData("ray_samp_type", &(lamp->ray_samp_type));
                et->setData("area_shape", &(lamp->area_shape));
                et->setData("area_size", &(lamp->area_size));
                et->setData("area_sizey", &(lamp->area_sizey));
                et->setData("area_sizez", &(lamp->area_sizez));
-               et->setData("adapt_thresh", &(lamp->adapt_thresh));
-               et->setData("ray_samp_method", &(lamp->ray_samp_method));
-               et->setData("shadhalostep", &(lamp->shadhalostep));
-               et->setData("sun_effect_type", &(lamp->shadhalostep));
-               et->setData("skyblendtype", &(lamp->skyblendtype));
-               et->setData("horizon_brightness", &(lamp->horizon_brightness));
-               et->setData("spread", &(lamp->spread));
-               et->setData("sun_brightness", &(lamp->sun_brightness));
-               et->setData("sun_size", &(lamp->sun_size));
-               et->setData("backscattered_light", &(lamp->backscattered_light));
-               et->setData("sun_intensity", &(lamp->sun_intensity));
-               et->setData("atm_turbidity", &(lamp->atm_turbidity));
-               et->setData("atm_extinction_factor", &(lamp->atm_extinction_factor));
-               et->setData("atm_distance_factor", &(lamp->atm_distance_factor));
-               et->setData("skyblendfac", &(lamp->skyblendfac));
-               et->setData("sky_exposure", &(lamp->sky_exposure));
-               et->setData("sky_colorspace", &(lamp->sky_colorspace));
        }
        else {
                float constatt = light->getConstantAttenuation().getValue();
@@ -1277,11 +1078,10 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
                lamp->energy = e;
                lamp->dist = d;
 
-               COLLADAFW::Light::LightType type = light->getLightType();
-               switch (type) {
+               switch (light->getLightType()) {
                        case COLLADAFW::Light::AMBIENT_LIGHT:
                        {
-                               lamp->type = LA_HEMI;
+                               lamp->type = LA_SUN; //TODO needs more thoughts
                        }
                        break;
                        case COLLADAFW::Light::SPOT_LIGHT:
@@ -1301,7 +1101,6 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
                        {
                                /* our sun is very strong, so pick a smaller energy level */
                                lamp->type = LA_SUN;
-                               lamp->mode |= LA_NO_SPEC;
                        }
                        break;
                        case COLLADAFW::Light::POINT_LIGHT:
@@ -1317,7 +1116,7 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
                        break;
                        case COLLADAFW::Light::UNDEFINED:
                        {
-                               fprintf(stderr, "Current lamp type is not supported.\n");
+                               fprintf(stderr, "Current light type is not supported.\n");
                                lamp->type = LA_LOCAL;
                        }
                        break;
@@ -1332,7 +1131,7 @@ bool DocumentImporter::writeLight(const COLLADAFW::Light *light)
 // this function is called only for animations that pass COLLADAFW::validate
 bool DocumentImporter::writeAnimation(const COLLADAFW::Animation *anim)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        // return true;
@@ -1342,7 +1141,7 @@ bool DocumentImporter::writeAnimation(const COLLADAFW::Animation *anim)
 // called on post-process stage after writeVisualScenes
 bool DocumentImporter::writeAnimationList(const COLLADAFW::AnimationList *animationList)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        // return true;
@@ -1354,7 +1153,7 @@ bool DocumentImporter::writeAnimationList(const COLLADAFW::AnimationList *animat
 // called on post-process stage after writeVisualScenes
 bool DocumentImporter::writeAnimationClip(const COLLADAFW::AnimationClip *AnimationClip)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        return true;
@@ -1372,7 +1171,7 @@ bool DocumentImporter::writeSkinControllerData(const COLLADAFW::SkinControllerDa
 // this is called on postprocess, before writeVisualScenes
 bool DocumentImporter::writeController(const COLLADAFW::Controller *controller)
 {
-       if (mImportStage != General)
+       if (mImportStage == Fetching_Controller_data)
                return true;
 
        return armature_importer.write_controller(controller);