t_node *add_plusplus(t_context *C)
{
t_node *node_block = add_slider_int_special(C,"++",op_plusplus);
t_block *block = ( t_block *) node_block->data;
t_brick *brick = block_brick_get(block,"++");
brick->plug_out.state.open_out = 0;
brick->plug_out.state.open_in = 0;
return node_block;
}
void *op_file_get_data( t_brick *brick, const char *name)
{
t_block *block = brick->block;
t_brick *brick_object = block_brick_get( block, "image");
t_plug *plug = &brick_object->plug_intern;
void *data = NULL;
if(plug->data)
{
t_id *id = (t_id *) plug->data;
t_node *node = id->node;
data = node->data;
}
else
{
printf("op_file_get_data: can't get object\n");
}
return data;
}
void __cls_plug_flow_operator_get(t_plug_mode mode,t_plug *plug,t_plug *plug_src)
{
t_brick *brick = plug->brick;
t_block *block = brick->block;
t_brick *brick_indice = block_brick_get(block,"indice");
t_brick *brick_result = block_brick_get(block,"result");
t_plug *plug_result = &brick_result->plug_intern;
t_plug *plug_indice = &brick_indice->plug_intern;
t_lst *lst;
t_vlst *vlst;
// IN
if(plug_src && mode == mode_in)
{
switch(plug_src->data_type)
{
// + LST
case (dt_lst):
// get lst
lst = plug_src->data;
// if lst
if(lst)
{
if(!lst->current)
{
// set first
if(lst->first)
{
lst->current = lst->first;
}
}
else
{
t_link *link = lst->current;
if(link->next)
{
lst->current = link->next;
}
else
{
//
}
//XXX change type
plug_result->data_type=dt_camera;
t_camera *camera=link->data;
plug_result->data=camera;
}
}
break;
// +VLST
case(dt_vlst):
// get vlst
vlst = plug_src->data;
if(vlst)
{
t_plug _plug;
_plug.data_type = dt_vector;
// change type to vector
if(brick_result->plug_intern.data_type != dt_vector)
brick_type_change(brick_result,&_plug);
// get indice
int i = drf_int(plug_indice->data);
// if < indice
if(i < vlst->count)
{
t_vector *vector = plug_result->data;
// get pointer
float *ptr = vlst->data;
// do pointer arithmetic
vector->data = ptr + (vlst->length * i);
}
else
{
t_vector *vector = plug_result->data;
set_int(plug_indice->data,vlst->count-1);
float *ptr = vlst->data;
vector->data = ptr + (vlst->length * (vlst->count-1));
}
t_plug *plug_result_out = &brick_result->plug_out;
//XXX
// open vector
if(plug_result_out->is_connected)
{
t_plug *plug_vector = plug_get_dst(plug_result);
if(plug_vector->data_type == dt_vector)
{
t_brick *brick_vector = plug_vector->brick;
t_plug *plug_vector_in = &brick_vector->plug_in;
// FLOW IN
plug_vector_in->flow_in=1;
t_block *block_vector = brick_vector->block;
t_brick *brick_x = block_brick_get(block_vector,"x");
t_brick *brick_y = block_brick_get(block_vector,"y");
t_brick *brick_z = block_brick_get(block_vector,"z");
brick_x->state.draw_value=1;
brick_y->state.draw_value=1;
brick_z->state.draw_value=1;
brick_x->action = op_slider;
brick_y->action = op_slider;
brick_z->action = op_slider;
}
}
}
break;
default:
printf(">> %s\n",data_name_get(plug_src->data_type));
break;
}
}
}
void __cls_plug_flow_vector(t_plug_mode mode,t_plug *plug,t_plug *src_plug)
{
t_brick *brick = plug->brick;
t_block *block = brick->block;
// get X Y Z bricks
t_brick *brick_x = block_brick_get(block,"x");
t_brick *brick_y;
t_brick *brick_z;
t_plug *plug_x;
t_plug *plug_y;
t_plug *plug_z;
t_plug *plug_x_in;
t_plug *plug_y_in;
t_plug *plug_z_in;
// Not All Vectors have x y z in block
// Reset once
if(brick_x && mode == mode_in)
{
brick_y = block_brick_get(block,"y");
brick_z = block_brick_get(block,"z");
plug_x = &brick_x->plug_intern;
plug_y = &brick_y->plug_intern;
plug_z = &brick_z->plug_intern;
plug_x_in = &brick_x->plug_in;
plug_y_in = &brick_y->plug_in;
plug_z_in = &brick_z->plug_in;
// CLOSE X Y Z
plug_x_in->flow_in = 0;
plug_y_in->flow_in = 0;
plug_z_in->flow_in = 0;
// RESET X Y Z
plug_x->data = NULL;
plug_y->data = NULL;
plug_z->data = NULL;
brick_x->state.draw_value = 0;
brick_y->state.draw_value = 0;
brick_z->state.draw_value = 0;
}
t_vector *vector;
float *vector_data;
if(src_plug)
{
t_data_type type = src_plug->data_type;
switch(type)
{
// + VECTOR
case dt_vector:
vector = src_plug->data;
vector_data = vector->data;
//-- wait for initialisation from for loop
if(vector_data)
{
t_context *C = ctx_get();
if(C->ui->show_step) printf(":VECTOR is connected\n");
plug_x->data = vector_data;
plug_y->data = vector_data+1;
plug_z->data = vector_data+2;
// open x y z
plug_x_in->flow_in = 1;
plug_y_in->flow_in = 1;
plug_z_in->flow_in = 1;
brick_x->state.draw_value = 1;
brick_y->state.draw_value = 1;
brick_z->state.draw_value = 1;
/*
brick_x->cls->trigger(brick_x);
brick_y->cls->trigger(brick_y);
brick_z->cls->trigger(brick_z);
*/
}
else
{
t_context *C = ctx_get();
if(C->ui->show_step) printf(":VECTOR is NOT connected\n");
}
break;
default:
break;
}
}
else
{
}
}
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;
}
}
}
}
