Object *DocumentImporter::create_lamp_object(COLLADAFW::InstanceLight *lamp, Scene *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"); return NULL; } Object *ob = bc_add_object(sce, OB_LAMP, NULL); Lamp *la = uid_lamp_map[lamp_uid]; Lamp *old_lamp = (Lamp *)ob->data; ob->data = la; id_us_min(&old_lamp->id); if (old_lamp->id.us == 0) BKE_libblock_free(G.main, old_lamp); return ob; }
Object *DocumentImporter::create_camera_object(COLLADAFW::InstanceCamera *camera, Scene *sce) { const COLLADAFW::UniqueId& cam_uid = camera->getInstanciatedObjectId(); if (uid_camera_map.find(cam_uid) == uid_camera_map.end()) { // fprintf(stderr, "Couldn't find camera by UID.\n"); return NULL; } Object *ob = bc_add_object(sce, OB_CAMERA, NULL); Camera *cam = uid_camera_map[cam_uid]; Camera *old_cam = (Camera *)ob->data; ob->data = cam; id_us_min(&old_cam->id); if (old_cam->id.us == 0) BKE_libblock_free(G.main, old_cam); return ob; }
std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLADAFW::Node *parent_node, Scene *sce, Object *par, bool is_library_node) { Object *ob = NULL; bool is_joint = node->getType() == COLLADAFW::Node::JOINT; bool read_transform = true; std::string id = node->getOriginalId(); std::string name = node->getName(); // if node has child nodes write them COLLADAFW::NodePointerArray &child_nodes = node->getChildNodes(); std::vector<Object *> *objects_done = new std::vector<Object *>(); std::vector<Object *> *root_objects = new std::vector<Object *>(); fprintf(stderr, "Writing node id='%s', name='%s'\n", id.c_str(), name.c_str()); if (is_joint) { if (parent_node == NULL) { // A Joint on root level is a skeleton without root node. // Here we add the armature "on the fly": par = bc_add_object(sce, 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)); node_map[node->getUniqueId()] = node; } if (parent_node == NULL || parent_node->getType() != COLLADAFW::Node::JOINT) { armature_importer.add_root_joint(node, par); } if (parent_node == NULL) { // for skeletons without root node all has been done above. // Skeletons with root node are handled further down. goto finally; } } else { COLLADAFW::InstanceGeometryPointerArray &geom = node->getInstanceGeometries(); COLLADAFW::InstanceCameraPointerArray &camera = node->getInstanceCameras(); COLLADAFW::InstanceLightPointerArray &lamp = node->getInstanceLights(); COLLADAFW::InstanceControllerPointerArray &controller = node->getInstanceControllers(); COLLADAFW::InstanceNodePointerArray &inst_node = node->getInstanceNodes(); size_t geom_done = 0; size_t camera_done = 0; size_t lamp_done = 0; size_t controller_done = 0; size_t inst_done = 0; // XXX linking object with the first <instance_geometry>, though a node may have more of them... // 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); if (ob == NULL) { report_unknown_reference(*node, "instance_mesh"); } else { objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } ++geom_done; } while (camera_done < camera.getCount()) { ob = create_camera_object(camera[camera_done], sce); if (ob == NULL) { report_unknown_reference(*node, "instance_camera"); } else { objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } ++camera_done; } while (lamp_done < lamp.getCount()) { ob = create_lamp_object(lamp[lamp_done], sce); if (ob == NULL) { report_unknown_reference(*node, "instance_lamp"); } else { objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } ++lamp_done; } while (controller_done < controller.getCount()) { COLLADAFW::InstanceGeometry *geom = (COLLADAFW::InstanceGeometry *)controller[controller_done]; ob = mesh_importer.create_mesh_object(node, geom, true, uid_material_map, material_texture_mapping_map); if (ob == NULL) { report_unknown_reference(*node, "instance_controller"); } else { objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } ++controller_done; } // XXX instance_node is not supported yet while (inst_done < inst_node.getCount()) { const COLLADAFW::UniqueId& node_id = inst_node[inst_done]->getInstanciatedObjectId(); if (object_map.find(node_id) == object_map.end()) { fprintf(stderr, "Cannot find object for node referenced by <instance_node name=\"%s\">.\n", inst_node[inst_done]->getName().c_str()); ob = NULL; } else { std::pair<std::multimap<COLLADAFW::UniqueId, Object *>::iterator, std::multimap<COLLADAFW::UniqueId, Object *>::iterator> pair_iter = object_map.equal_range(node_id); for (std::multimap<COLLADAFW::UniqueId, Object *>::iterator it2 = pair_iter.first; it2 != pair_iter.second; it2++) { Object *source_ob = (Object *)it2->second; COLLADAFW::Node *source_node = node_map[node_id]; ob = create_instance_node(source_ob, source_node, node, sce, is_library_node); objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } } ++inst_done; read_transform = false; } // if node is empty - create empty object // XXX empty node may not mean it is empty object, not sure about this 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(sce, OB_ARMATURE, name.c_str()); } else { ob = bc_add_object(sce, OB_EMPTY, NULL); } objects_done->push_back(ob); if (parent_node == NULL) { root_objects->push_back(ob); } } // XXX: if there're multiple instances, only one is stored if (!ob) { goto finally; } for (std::vector<Object *>::iterator it = objects_done->begin(); it != objects_done->end(); ++it) { ob = *it; std::string nodename = node->getName().size() ? node->getName() : node->getOriginalId(); BKE_libblock_rename(G.main, &ob->id, (char *)nodename.c_str()); object_map.insert(std::pair<COLLADAFW::UniqueId, Object *>(node->getUniqueId(), ob)); node_map[node->getUniqueId()] = node; if (is_library_node) libnode_ob.push_back(ob); } //create_constraints(et,ob); } for (std::vector<Object *>::iterator it = objects_done->begin(); it != objects_done->end(); ++it) { ob = *it; if (read_transform) anim_importer.read_node_transform(node, ob); // overwrites location set earlier if (!is_joint) { if (par && ob) { ob->parent = par; ob->partype = PAROBJECT; ob->parsubstr[0] = 0; //bc_set_parent(ob, par, mContext, false); } } } if (objects_done->size() > 0) { ob = *objects_done->begin(); } else { ob = NULL; } for (unsigned int i = 0; i < child_nodes.getCount(); i++) { std::vector<Object *> *child_objects; child_objects = write_node(child_nodes[i], node, sce, ob, is_library_node); delete child_objects; } finally: delete objects_done; return root_objects; }
Object *MeshImporter::create_mesh_object(COLLADAFW::Node *node, COLLADAFW::InstanceGeometry *geom, bool isController, std::map<COLLADAFW::UniqueId, Material *>& uid_material_map, std::map<Material *, TexIndexTextureArrayMap>& material_texture_mapping_map) { const COLLADAFW::UniqueId *geom_uid = &geom->getInstanciatedObjectId(); // check if node instanciates controller or geometry if (isController) { geom_uid = armature_importer->get_geometry_uid(*geom_uid); if (!geom_uid) { fprintf(stderr, "Couldn't find a mesh UID by controller's UID.\n"); return NULL; } } else { if (uid_mesh_map.find(*geom_uid) == uid_mesh_map.end()) { // this could happen if a mesh was not created // (e.g. if it contains unsupported geometry) fprintf(stderr, "Couldn't find a mesh by UID.\n"); return NULL; } } if (!uid_mesh_map[*geom_uid]) return NULL; // name Object const std::string& id = node->getName().size() ? node->getName() : node->getOriginalId(); const char *name = (id.length()) ? id.c_str() : NULL; // add object Object *ob = bc_add_object(scene, OB_MESH, name); bc_set_mark(ob); // used later for material assignement optimization // store object pointer for ArmatureImporter uid_object_map[*geom_uid] = ob; imported_objects.push_back(ob); // replace ob->data freeing the old one Mesh *old_mesh = (Mesh *)ob->data; Mesh *new_mesh = uid_mesh_map[*geom_uid]; BKE_mesh_assign_object(ob, new_mesh); BKE_mesh_calc_normals(new_mesh); if (old_mesh->id.us == 0) BKE_libblock_free(G.main, old_mesh); char layername[100]; layername[0] = '\0'; MTFace *texture_face = NULL; COLLADAFW::MaterialBindingArray& mat_array = geom->getMaterialBindings(); // loop through geom's materials for (unsigned int i = 0; i < mat_array.getCount(); i++) { if (mat_array[i].getReferencedMaterial().isValid()) { texture_face = assign_material_to_geom(mat_array[i], uid_material_map, ob, geom_uid, layername, texture_face, material_texture_mapping_map, i); } else { fprintf(stderr, "invalid referenced material for %s\n", mat_array[i].getName().c_str()); } } return ob; }
// called from write_controller Object *SkinInfo::create_armature(Scene *scene) { ob_arm = bc_add_object(scene, OB_ARMATURE, NULL); return ob_arm; }