Пример #1
0
void justify_tree( t_block *block_previous, t_block *block_current, int dir)
{
	float box_previous[8];
	float box_current[8];

	bzero( box_previous, 8);
	bzero( box_current, 8);

	t_lst *lst_previous = block_branch_get( block_previous, dir);
	t_lst *lst_current = block_branch_get( block_current, dir);

	get_branch_bounding_box( block_previous, lst_previous, box_previous, dir);
	get_branch_bounding_box( block_current, lst_current, box_current, dir);

	do_justify_tree( block_current, lst_current, box_previous, box_current, dir);

	lst_free( lst_previous);
	lst_free( lst_current);
}
Пример #2
0
void __cls_plug_flow_operator_for(t_plug_mode mode,t_plug *plug,t_plug *plug_src)
{
	t_context *C =ctx_get();

	t_plug *plug_in = plug->src;
	t_brick *brick = plug->brick;

	// get bricks
	t_block *block = brick->block;
	t_brick *brick_indice = block_brick_get(block,"indice");
	t_brick *brick_vector = block_brick_get(block,"vector");

	t_plug *plug_indice = &brick_indice->plug_intern;
	t_plug *plug_vector = &brick_vector->plug_intern;
	t_plug *plug_vector_in = &brick_vector->plug_in;

	int *data_indice = plug_indice->data;
	t_vector *vector = plug_vector->data;

	// IN
	if(mode == mode_in)
	{
		// reset vector
		vector->data = NULL;

		// if for connected
		if(plug_in->is_connected )
		{
			// get src
			t_plug *src_plug = plug_get_src(plug);
			t_data_type src_type = src_plug->data_type;

			t_vlst *vlst=NULL;

			switch(src_type)
			{
				// + VLST
				case dt_vlst:

					// SET VLST
					vlst = src_plug->data;

					// SET vector
					if(vlst)
					{
						vector->data = vlst->data;
						vector->type = vlst->data_type;
						vector->length = vlst->length;
					}

					break;
					
				default:
					plug_warning(plug,src_plug);
					break;
			}

			// SET VECTOR
			if(plug_vector_in->is_connected)
			{
				if(vlst)
				{
					// set vector, open for fisrt loop
					//if(!plug->is_eval)
					if(!for_init)
					//if(1==2)
					{

						if(C->ui->show_step) term_log(":FOR loop (INIT) %d",brick->counter);
						plug->is_eval = 1;
						for_init = 1;

						// get pointer
						float *ptr = vlst->data;

						// set pointer
						vector->data = ptr;

						// set indice
						*data_indice=0;

						t_plug *plug_vector_src = plug_vector_in->src;
						t_brick *brick_vector_src = plug_vector_src->brick;

						brick_vector_src->cls->trigger(brick_vector_src);

						


							t_lst *BRICKS = ctx_links_lst_get();
							lst_add(BRICKS,brick,"for");
					}
					else
					{
						if(brick->counter < vlst->count)
						{
							if(C->ui->show_step) term_log(":FOR loop %d",brick->counter);
							// get pointer
							float *ptr = vlst->data;

							// set pointer
							vector->data = ptr + (vlst->length * brick->counter);

							// set indice
							*data_indice=brick->counter;

							// get branch (all bricks)
							t_lst *lst=lst_new("lst");
							block_branch_get(0,lst,block);

							// reset states
							ctx_links_reset(C,lst);

							// add to loop
							t_lst *BRICKS = ctx_links_lst_get();

							t_link *l;
							t_brick *b;
							for(l=lst->first;l;l=l->next)
							{

								b = l->data;
								lst_add(BRICKS,l->data,b->name);
							}

							// free
							lst_free(lst);


							// counter ++
							brick->counter++;

						}
						else
						{
							//XXX
							vector->data = NULL;
							// reset counter
							brick->counter = 0;

							for_init=0;
						}
					}
				}
			}
			else
			{
				*data_indice = 0;

			}
		}
	}
}