void *op_slider(t_brick *brick)
{
void *data = brick->plug_intern.data;
t_data_type type = brick->plug_intern.data_type;
switch( brick->state_pressed)
{
case BRICK_LEFT:
switch( type)
{
case dt_int: set_int( data, drf_int( data) - 1); break;
case dt_float: set_float( data, drf_float( data) - .1); break;
default: break;
}
break;
case BRICK_RIGHT:
switch( type)
{
case dt_int: set_int( data, drf_int( data) + 1); break;
case dt_float: set_float( data, drf_float( data) + .1); break;
default: break;
}
break;
default:
break;
}
return NULL;
}
void __cls_plug_flow_trigger(t_plug_mode mode,t_plug *plug,t_plug *src_plug)
{
if(src_plug)
{
t_brick *brick=plug->brick;
if(src_plug)
{
t_data_type src_type=src_plug->data_type;
int data;
switch(src_type)
{
case(dt_int):
data=drf_int(src_plug->data);
if(data == 1)
brick->action(brick);
break;
default:
plug_warning(plug,src_plug);
break;
}
}
}
}
void __cls_plug_flow_int(t_plug_mode mode,t_plug *plug,t_plug *src_plug)
{
if(src_plug)
{
t_data_type src_type=src_plug->data_type;
int *data=plug->data;
float increment=plug->brick->var.increment;
switch(src_type)
{
case dt_int:
*data=drf_int(src_plug->data);
break;
case dt_float:
*data=(int)drf_float(src_plug->data);
break;
case dt_lst:
break;
default:
plug_warning(plug,src_plug);
break;
}
if(increment) *data=*data * increment;
}
}
void vlst_float_add(t_vlst *vlst,t_data_type type,void *data)
{
int count=vlst->count;
int length=vlst->length;
int i,j;
float *data_dst=vlst->data;
for(i=0;i<count;i++)
{
for(j=0;j<length;j++)
{
switch(type)
{
case(dt_int): *data_dst += (float)drf_int(data); break;
case(dt_float): *data_dst += drf_float(data); break;
default:printf("? ? !!\n");
}
data_dst++;
}
}
}
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;
}
}
}
