示例#1
0
void ImporterGeometryTWM::build_skeleton(   std::vector<std::string> &joint_names,
                                            std::vector<Joint> &src_joints,
                                            std::vector<SkeletonJoint> &dst_joints)
{	
	if (src_joints.size() <= 0)
		return;
		
	// allocate space for destination joints
	dst_joints.resize(src_joints.size());

	for (DTuint i = 0; i < src_joints.size(); ++i) {
		Joint &joint = src_joints[i];
			
		// find index of joint in names
		DTsize joint_index = 0;
        std::size_t j;
		for (j = 0; j < joint_names.size(); ++j) {
			if (joint_names[j] == joint._name) {
				joint_index = j;
				break;
			}
		}
		
        if (j == joint_names.size()) {
            LOG_MESSAGE << "Warning: Unknown joint found in skeleton: " << joint._name;
            joint_names.push_back(joint._name);
            joint_index = joint_names.size()-1;
        }

		// Buid copy of joint
		SkeletonJoint &dest_joint = dst_joints[i];
		dest_joint.set_name(joint._name);
		dest_joint.set_joint_index( static_cast<DTuint>(joint_index) );
		dest_joint.set_local_transform(joint._local_transform);
		dest_joint.set_world_transform(joint._world_transform);
		
		// Build child joints
		std::vector<SkeletonJoint> dest_joints;
		build_skeleton(joint_names, joint._children, dest_joints);
		dest_joint.set_children(dest_joints);
	}
}
示例#2
0
void class2(graph_t* g)
{
	int		c;
	node_t	*n,*t,*h;
	edge_t	*e,*prev,*opp;

	g->u.nlist = NULL;

	g->u.n_nodes = 0;	/* new */

	mark_clusters(g);
	for (c = 1; c <= g->u.n_cluster; c++)
		build_skeleton(g,g->u.clust[c]);
	for (n = agfstnode(g); n; n = agnxtnode(g,n))
		for (e = agfstout(g,n); e; e = agnxtout(g,e)) {
			if (e->head->u.weight_class <= 2) e->head->u.weight_class++;
			if (e->tail->u.weight_class <= 2) e->tail->u.weight_class++;
	}

	for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
		if ((n->u.clust == NULL) && (n == UF_find(n))) {fast_node(g,n); g->u.n_nodes++;}
		prev = NULL;
		for (e = agfstout(g,n); e; e = agnxtout(g,e)) {

				/* already processed */
			if (e->u.to_virt) continue;

				/* edges involving sub-clusters of g */
			if (is_cluster_edge(e)) {
				/* following is new cluster multi-edge code */
				if (mergeable(prev,e)) {
					if (prev->u.to_virt) { 
						merge_chain(g,e,prev->u.to_virt,FALSE);
						other_edge(e);
					}
					else if (e->tail->u.rank == e->head->u.rank) {
						merge_oneway(e,prev);
						other_edge(e);
					}
					/* else is an intra-cluster edge */
					continue;
				}
				interclrep(g,e);
				prev = e;
				continue;
			}
				/* merge multi-edges */
			if (prev && (e->tail == prev->tail) && (e->head == prev->head)) {
				if (e->tail->u.rank == e->head->u.rank) {
					merge_oneway(e,prev);
					other_edge(e);
					continue;
				}
				if ((e->u.label == NULL) && (prev->u.label == NULL) && ports_eq(e,prev)) {
					if (Concentrate) 
						e->u.edge_type = IGNORED;
					else{
					merge_chain(g,e,prev->u.to_virt,TRUE);
					other_edge(e);
					}
					continue;
				}
				/* parallel edges with different labels fall through here */
			}

				/* self edges */
			if (e->tail == e->head) {
				other_edge(e);
				prev = e;
				continue;
			}

			t = UF_find(e->tail);
			h = UF_find(e->head);

				/* non-leader leaf nodes */
			if ((e->tail != t) || (e->head != h)) {
					/* ### need to merge stuff */
				continue;	
			}


				/* flat edges */
			if (e->tail->u.rank == e->head->u.rank) {
				flat_edge(g,e);
				prev = e;
				continue;
			}

				/* forward edges */
			if (e->head->u.rank > e->tail->u.rank) {
				make_chain(g,e->tail,e->head,e);
				prev = e;
				continue;
			}

				/* backward edges */
			else {
				/*other_edge(e);*/
				if ((opp = agfindedge(g,e->head,e->tail))) {
					/* shadows a forward edge */
					if (opp->u.to_virt == NULL)
						make_chain(g,opp->tail,opp->head,opp);
					if ((e->u.label == NULL) && (opp->u.label == NULL) && ports_eq(e,opp)) {
						if (Concentrate) {
							e->u.edge_type = IGNORED;
							opp->u.conc_opp_flag = TRUE;
						}
						else{	/* see above.  this is getting out of hand */
						other_edge(e);
						merge_chain(g,e,opp->u.to_virt,TRUE);
						}
						continue;
					}
				}
				make_chain(g,e->head,e->tail,e);
				prev = e;
			}
		}
	}
	/* since decompose() is not called on subgraphs */
	if (g != g->root) {
		g->u.comp.list = ALLOC(1,g->u.comp.list,node_t*);
		g->u.comp.list[0] = g->u.nlist;
	}
示例#3
-1
DTerr	ImporterGeometryTWM::import(GeometryResource *target, std::string args)
{
	FilePath pathname(target->path());
	
    // open the file
    BinaryFileStream	file;
	FileManager::open(file, pathname, true);
     
    // 
	// Read_ in header
	//
	
	DTuint magic;
	file >> magic;
    if (magic != MAGIC) {
        return DT3_ERR_FILE_WRONG_TYPE;
    }
	
	DTuint version;
	file >> version;
	
	//
	// Read_ in data
	//
	
	_normals_count = 0;
	_uv_set_0_count = 0;
	_uv_set_1_count = 0;
	_weights_count = 0;
	
	DTint section,size;
	file >> section >> size;
	switch(section) {
		case FILE:		read_file(file, size);			break;
		default:		WARNINGMSG("Invalid section");	break;
	};
	
	//
	// Build Streams
	//
    
	// Calculate sizes needed
	DTuint joints_size = 0;
	
	for (DTuint i = 0; i < _meshes.size(); ++i) {
		joints_size += _meshes[i]._joint_names.size();
	}

	// allocate joint names, force first one to always be identity
	std::vector<std::string>	joint_names;
	joint_names.resize(joints_size);	
	DTuint joint_offset = 0;	// Account for identity above

	for (DTuint i = 0; i < _meshes.size(); ++i) {
		MeshData &meshdata = _meshes[i];

        if (meshdata._vertices.size() == 0)
            continue;
    
        std::shared_ptr<Mesh> mesh = Mesh::create();
		
		// copy joint names
		for (DTuint j = 0; j < meshdata._joint_names.size(); ++j) {
			joint_names[joint_offset + j] = meshdata._joint_names[j];
		}
        
        std::vector<Vector3> vertex_stream;
        std::vector<Vector3> normals_stream;
        std::vector<Vector2> uvs_stream_0;
        std::vector<Vector2> uvs_stream_1;
        std::vector<Vector4> weights_strength;
        std::vector<WeightsIndex> weights_index;
        std::vector<Triangle> indices;
        
        vertex_stream = meshdata._vertices;
        normals_stream = meshdata._normals;
        uvs_stream_0 = meshdata._uv_sets[0]._uvs;
        uvs_stream_1 = meshdata._uv_sets[1]._uvs;
        indices = meshdata._indices;
		
        if (meshdata._weights.size()) {
            
            weights_index.resize(meshdata._weights.size());
            weights_strength.resize(meshdata._weights.size());
        
            for (DTuint j = 0; j < meshdata._weights.size(); ++j) {
                weights_strength[j] = Vector4(      meshdata._weights[j].weight_1(),
                                                    meshdata._weights[j].weight_2(),
                                                    meshdata._weights[j].weight_3(),
                                                    meshdata._weights[j].weight_4()    );

                weights_index[j] = WeightsIndex(    meshdata._weights[j].bone_1(),
                                                    meshdata._weights[j].bone_2(),
                                                    meshdata._weights[j].bone_3(),
                                                    meshdata._weights[j].bone_4()    );
            
            }
        }

        mesh->set_vertex_stream(vertex_stream);
        mesh->set_normals_stream(normals_stream);
        mesh->set_uv_stream0(uvs_stream_0);
        mesh->set_uv_stream1(uvs_stream_1);
        mesh->set_index_stream(indices);
        mesh->set_weights_index_stream(weights_index);
        mesh->set_weights_strength_stream(weights_strength);

        // Some stuff we can generate
        if (normals_stream.size() == 0)     mesh->generate_normals();
        if (uvs_stream_0.size() != 0)       mesh->generate_tangents();
        
        // Add the mesh
        target->add_mesh(mesh);

		joint_offset += (DTushort) meshdata._joint_names.size();
	}
		 	
	
	// Build skeleton
	std::vector<SkeletonJoint> s;
	build_skeleton(joint_names, _skeleton._joints, s);
    
    Skeleton skeleton;
    skeleton.set_skeleton(s);
    
	target->set_skeleton(skeleton);

	return DT3_ERR_NONE;
}