Swith and split nodes

source/lagui/la_interface.h

@@ -1172,11 +1172,11 @@ laController* la_FindControllerWithID(int id);
 
 void la_RegisterInputMapperOperators();
 
-NEED_STRUCTURE(laInputMapperNode);
-typedef void (*laInputMapperNodeInitF)(laInputMapperNode*);
-typedef void (*laInputMapperNodeDestroyF)(laInputMapperNode*);
-typedef int (*laInputMapperNodeVisitF)(laInputMapperNode*, laListHandle*);
-typedef int (*laInputMapperNodeEvalF)(laInputMapperNode*);
+NEED_STRUCTURE(laBaseNode);
+typedef void (*laBaseNodeInitF)(laBaseNode*);
+typedef void (*laBaseNodeDestroyF)(laBaseNode*);
+typedef int (*laBaseNodeVisitF)(laBaseNode*, laListHandle*);
+typedef int (*laBaseNodeEvalF)(laBaseNode*);
 
 #define LA_DAG_FLAG_ERR  0
 #define LA_DAG_FLAG_TEMP 1
@@ -1192,17 +1192,17 @@ STRUCTURE(laInputRack){
     laSafeString* Name;
     laListHandle Nodes;
 };
-STRUCTURE(laInputMapperNodeType){
-    laInputMapperNodeInitF    Init;
-    laInputMapperNodeDestroyF Destroy;
-    laInputMapperNodeVisitF   Visit;
-    laInputMapperNodeEvalF    Eval;
+STRUCTURE(laBaseNodeType){
+    laBaseNodeInitF    Init;
+    laBaseNodeDestroyF Destroy;
+    laBaseNodeVisitF   Visit;
+    laBaseNodeEvalF    Eval;
     int NodeSize;
 };
-STRUCTURE(laInputMapperNode){
+STRUCTURE(laBaseNode){
     laListItem Item;
     laSafeString* Name;
-    laInputMapperNodeType* Type;
+    laBaseNodeType* Type;
     laInputRack* InRack;
     int Gap;
     int Eval;
@@ -1216,16 +1216,37 @@ STRUCTURE(laInputControllerNodeSocket){
     int IntVal[8]; real RealVal[8];
 };
 STRUCTURE(laInputControllerNode){
-    laInputMapperNode Base;
+    laBaseNode Base;
     laInputControllerNodeSocket Sockets[8];
     int UserID;
     int Mode;// btn/axis;
 };
 STRUCTURE(laInputVisualizerNode){
-    laInputMapperNode Base;
+    laBaseNode Base;
     laNodeInSocket* In;
     int IntVal[8]; real RealVal[8];
 };
+STRUCTURE(laInputSplitNodeOutSocket){
+    laNodeOutSocket* Out;
+};
+STRUCTURE(laInputSplitNode){
+    laBaseNode Base;
+    laNodeInSocket* In;
+    laInputSplitNodeOutSocket Out[8];
+    int IntVal[8]; real RealVal[8];
+    int ArrLen;
+};
+STRUCTURE(laInputSwitchNodeInSocket){
+    laNodeInSocket* In;
+};
+STRUCTURE(laInputSwitchNode){
+    laBaseNode Base;
+    laInputSwitchNodeInSocket In[8];
+    laNodeOutSocket* Out;
+    laNodeInSocket* SwitchIn;
+    real TempVal;
+    int Switch;
+};
 
 #define LA_INPUT_CONTROLLER_NODE_MODE_BTN 0
 #define LA_INPUT_CONTROLLER_NODE_MODE_AXIS 1

source/lagui/resources/la_input_mapping.c

@@ -4,16 +4,20 @@ extern LA MAIN;
 extern struct _tnsMain *T;
 
 
-laInputMapperNodeType LA_IDN_KEYBOARD;
-laInputMapperNodeType LA_IDN_MOUSE;
-laInputMapperNodeType LA_IDN_CONTROLLER;
-laInputMapperNodeType LA_IDN_VISUALIZER;
+laBaseNodeType LA_IDN_KEYBOARD;
+laBaseNodeType LA_IDN_MOUSE;
+laBaseNodeType LA_IDN_CONTROLLER;
+laBaseNodeType LA_IDN_VISUALIZER;
+laBaseNodeType LA_IDN_SPLIT;
+laBaseNodeType LA_IDN_SWITCH;
 
 laPropContainer* LA_PC_IDN_GENERIC;
 laPropContainer* LA_PC_IDN_KEYBOARD;
 laPropContainer* LA_PC_IDN_MOUSE;
 laPropContainer* LA_PC_IDN_CONTROLLER;
 laPropContainer* LA_PC_IDN_VISUALIZER;
+laPropContainer* LA_PC_IDN_SPLIT;
+laPropContainer* LA_PC_IDN_SWITCH;
 
 #define LA_IDN_CONTROLLER_RESET_SOCKET(ns)\
     {ns->IntVal[0]=0; ns->Out->DataType=LA_PROP_INT; ns->Offset=0; ns->Out->Data=&ns->IntVal;}
@@ -64,7 +68,7 @@ int IDN_ControllerEval(laInputControllerNode* n){
 }
 void laui_ControllerNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
     laColumn* c=laFirstColumn(uil); laInputControllerNode*n=This->EndInstance;
-    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,0); cr=laRightColumn(c,0);
+    laColumn* cl,*cr; laSplitColumn(uil,c,0.3); cl=laLeftColumn(c,0); cr=laRightColumn(c,0);
 
     laUiItem* b=laBeginRow(uil,c,0,0);
     laShowHeightAdjuster(uil,c,This,"base.__gap",0);
@@ -102,7 +106,7 @@ void IDN_InputVisualizeDestroy(laInputVisualizerNode* n){
 int IDN_InputVisualizeVisit(laInputVisualizerNode* n, laListHandle* l){
     n->Base.Eval=LA_DAG_FLAG_TEMP;
     if(n->In->Source){ int result;
-        laInputMapperNode* sn=n->In->Source->Parent; result=sn->Type->Visit(sn,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
+        laBaseNode* sn=n->In->Source->Parent; result=sn->Type->Visit(sn,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
     }
     n->Base.Eval=LA_DAG_FLAG_PERM;
     lstAppendPointer(l, n);
@@ -123,7 +127,7 @@ int IDN_InputVisualizerEval(laInputVisualizerNode* n){
     return 1;
 }
 void laui_InputVisualizeNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
-    laColumn* c=laFirstColumn(uil); laInputControllerNode*n=This->EndInstance;
+    laColumn* c=laFirstColumn(uil); laInputVisualizerNode*n=This->EndInstance;
     laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,1); cr=laRightColumn(c,0);
 
     laUiItem* b=laBeginRow(uil,c,0,0);
@@ -143,6 +147,129 @@ void laui_InputVisualizeNode(laUiList *uil, laPropPack *This, laPropPack *Extra,
     }laEndCondition(uil,b2);
 }
 
+void IDN_InputSplitInit(laInputSplitNode* n){
+    n->In=laCreateInSocket("in", 0); strSafeSet(&n->Base.Name,"Split");
+    for(int i=0;i<8;i++){ char str[4]; sprintf(str,"%d",i); n->Out[i].Out=laCreateOutSocket(n,str,0); }
+}
+void IDN_InputSplitDestroy(laInputSplitNode* n){
+    laDestroyInSocket(n->In); strSafeDestroy(&n->Base.Name);
+    for(int i=0;i<8;i++){ laDestroyOutSocket(n->Out[i].Out); }
+}
+int IDN_InputSplitVisit(laInputSplitNode* n, laListHandle* l){
+    if(n->Base.Eval==LA_DAG_FLAG_TEMP||n->Base.Eval==LA_DAG_FLAG_PERM) return LA_DAG_FLAG_ERR;
+    n->Base.Eval=LA_DAG_FLAG_TEMP;
+    if(n->In->Source){ int result;
+        laBaseNode* sn=n->In->Source->Parent; result=sn->Type->Visit(sn,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
+    }
+    n->Base.Eval=LA_DAG_FLAG_PERM;
+    lstAppendPointer(l, n);
+    return LA_DAG_FLAG_PERM;
+}
+int IDN_InputSplitEval(laInputSplitNode* n){
+    if(!n->In->Source) return 0;
+    laNodeOutSocket* os=n->In->Source; int arrlen=1;
+    switch(os->DataType){
+    case LA_PROP_FLOAT|LA_PROP_ARRAY:
+    case LA_PROP_FLOAT: if(os->ArrLen) n->ArrLen=os->ArrLen;
+        for(int i=0;i<TNS_MIN2(n->ArrLen,8);i++){ n->Out[i].Out->DataType=LA_PROP_FLOAT; n->Out[i].Out->Data=&n->RealVal[i]; }
+        memcpy(n->RealVal,os->Data,sizeof(real)*n->ArrLen); n->In->ArrLen=arrlen; break;
+    case LA_PROP_ENUM|LA_PROP_ARRAY:
+    case LA_PROP_ENUM: if(os->ArrLen) n->ArrLen=os->ArrLen;
+        for(int i=0;i<TNS_MIN2(n->ArrLen,8);i++){ n->Out[i].Out->DataType=LA_PROP_ENUM; n->Out[i].Out->Data=&n->IntVal[i]; }
+        memcpy(n->IntVal,os->Data,sizeof(int)*n->ArrLen); n->In->ArrLen=arrlen; break;
+    default:
+        for(int i=0;i<TNS_MIN2(n->ArrLen,8);i++){ n->Out[i].Out->DataType=LA_PROP_ENUM; n->Out[i].Out->Data=&n->IntVal[i]; }
+        n->IntVal[0]=0; n->In->ArrLen=1; break;
+    }
+    n->In->DataType=os->DataType;
+    return 1;
+}
+void laui_InputSplitNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
+    laColumn* c=laFirstColumn(uil); laInputSplitNode*n=This->EndInstance;
+    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,1); cr=laRightColumn(c,0);
+
+    laUiItem* b=laBeginRow(uil,c,0,0);
+    laShowHeightAdjuster(uil,c,This,"base.__gap",0);
+    laShowItem(uil,c,This,"base.name");
+    laEndRow(uil,b);
+
+    b=laBeginRow(uil,c,0,0);
+    laShowNodeSocket(uil,c,This,"in",0);laShowSeparator(uil,c)->Expand=1;
+    laShowItemFull(uil,c,This,"array_length",LA_WIDGET_INT_PLAIN,0,0,0);
+    for(int i=0;i<8;i++){
+        char* buf[128]; sprintf(buf,"out%d.out",i); laShowNodeSocket(uil,cr,This,buf,0);
+    }
+    laEndRow(uil,b);
+}
+
+void IDN_InputSwitchInit(laInputSwitchNode* n){
+    n->SwitchIn=laCreateInSocket("sw in",0); n->Out=laCreateOutSocket(n,"out",0); strSafeSet(&n->Base.Name,"Switch");
+    for(int i=0;i<8;i++){ char str[4]; sprintf(str,"%d",i); n->In[i].In=laCreateInSocket(n,str); }
+}
+void IDN_InputSwitchDestroy(laInputSwitchNode* n){
+    laDestroyInSocket(n->SwitchIn); laDestroyOutSocket(n->Out); strSafeDestroy(&n->Base.Name);
+    for(int i=0;i<8;i++){ laDestroyInSocket(n->In[i].In); }
+}
+int IDN_InputSwitchVisit(laInputSwitchNode* n, laListHandle* l){
+    if(n->Base.Eval==LA_DAG_FLAG_TEMP||n->Base.Eval==LA_DAG_FLAG_PERM) return LA_DAG_FLAG_ERR;
+    n->Base.Eval=LA_DAG_FLAG_TEMP;
+    for(int i=0;i<8;i++){
+        if(n->In[i].In->Source){ int result;
+            laBaseNode* sn=n->In[i].In->Source->Parent; result=sn->Type->Visit(sn,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
+        }
+    }
+    laBaseNode* sw=n->SwitchIn->Source?n->SwitchIn->Source->Parent:0; if(sw){
+        int result=sw->Type->Visit(sw,l); if(result==LA_DAG_FLAG_TEMP) return LA_DAG_FLAG_ERR;
+    }
+    n->Base.Eval=LA_DAG_FLAG_PERM;
+    lstAppendPointer(l, n);
+    return LA_DAG_FLAG_PERM;
+}
+int IDN_InputSwitchEval(laInputSwitchNode* n){
+    int sw=n->Switch;
+    if(n->SwitchIn->Source){ laNodeOutSocket* os=n->SwitchIn->Source; int* id; real* fd;
+        switch(os->DataType){
+        case LA_PROP_ARRAY|LA_PROP_ENUM:
+            id=os->Data; for(int i=0;i<os->ArrLen;i++){ if(id[i]){sw=i; break;} } break;
+        case LA_PROP_ENUM: case LA_PROP_INT: case LA_PROP_INT|LA_PROP_ARRAY:
+            id=os->Data; sw=*id; break;
+        case LA_PROP_FLOAT: case LA_PROP_FLOAT|LA_PROP_ARRAY:
+            fd=os->Data; sw=(int)(*fd); break;
+        default: sw=0; break;
+        }
+    }
+    TNS_CLAMP(sw,0,7);
+    laInputSwitchNodeInSocket *is=&n->In[sw];
+    if(is->In->Source){ n->Out->Data=is->In->Source->Data; n->Out->DataType=is->In->Source->DataType; n->Out->ArrLen=is->In->Source->ArrLen; }
+    else{ n->Out->Data=&n->TempVal; n->Out->DataType=LA_PROP_FLOAT; n->Out->ArrLen=1; }
+    return 1;
+}
+void laui_InputSwitchNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
+    laColumn* c=laFirstColumn(uil); laInputSwitchNode*n=This->EndInstance;
+    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,1); cr=laRightColumn(c,0);
+
+    laUiItem* b=laBeginRow(uil,c,0,0);
+    laShowHeightAdjuster(uil,c,This,"base.__gap",0);
+    laShowItem(uil,c,This,"base.name");
+    laEndRow(uil,b);
+
+    b=laBeginRow(uil,c,0,0);
+    for(int i=0;i<8;i++){
+        char* buf[128]; sprintf(buf,"in%d.in",i); laShowNodeSocket(uil,cr,This,buf,0);
+    } laShowSeparator(uil,c)->Expand=1;
+    laEndRow(uil,b);
+
+    b=laBeginRow(uil,c,0,0);
+    laShowItem(uil,c,This,"switch_in");
+    laUiItem* b2=laOnConditionThat(uil,c,laNot(laPropExpression(This,"switch_in.source")));{
+        laShowItem(uil,c,This,"switch");
+    };laEndCondition(uil,b2);
+    laShowSeparator(uil,c)->Expand=1; 
+    laShowNodeSocket(uil,c,This,"out",0);
+    laEndRow(uil,b);
+}
+
+
 int OPINV_AddInputMapperRack(laOperator* a, laEvent *e){
     laInputRack* pivot=a->This?a->This->EndInstance:0;
     laInputRack* ir=memAcquire(sizeof(laInputRack));
@@ -155,16 +282,16 @@ int OPINV_AddInputMapperRack(laOperator* a, laEvent *e){
     return LA_FINISHED;
 }
 
-laInputMapperNode* la_CreateInputMapperNode(laInputRack* ir, laInputMapperNodeType* NodeType){
-    laInputMapperNode* imn=memAcquire(NodeType->NodeSize);
-    imn->Type=NodeType; NodeType->Init(imn); lstAppendItem(&ir->Nodes, imn); imn->InRack=ir;
+laBaseNode* la_CreateInputMapperNode(laInputRack* ir, laBaseNodeType* NodeType){
+    laBaseNode* bn=memAcquire(NodeType->NodeSize);
+    bn->Type=NodeType; NodeType->Init(bn); lstAppendItem(&ir->Nodes, bn); bn->InRack=ir;
     laNotifyUsers("la.input_racks");
-    return imn;
+    return bn;
 }
-void la_DestroyInputMapperNode(laInputMapperNode* imn){
-    lstRemoveItem(imn->InRack, imn); imn->Type->Destroy(imn);
+void la_DestroyInputMapperNode(laBaseNode* bn){
+    lstRemoveItem(bn->InRack, bn); bn->Type->Destroy(bn);
     laNotifyUsers("la.input_racks");
-    memFree(imn);
+    memFree(bn);
 }
 
 int OPINV_AddInputMapperNode(laOperator* a, laEvent *e){
@@ -176,6 +303,8 @@ int OPINV_AddInputMapperNode(laOperator* a, laEvent *e){
     elif(strSame(type, "MOUSE")){}
     elif(strSame(type, "CONTROLLER")){ la_CreateInputMapperNode(ir, &LA_IDN_CONTROLLER); }
     elif(strSame(type, "VISUALIZER")){ la_CreateInputMapperNode(ir, &LA_IDN_VISUALIZER); }
+    elif(strSame(type, "SPLIT")){ la_CreateInputMapperNode(ir, &LA_IDN_SPLIT); }
+    elif(strSame(type, "SWITCH")){ la_CreateInputMapperNode(ir, &LA_IDN_SWITCH); }
 
     return LA_FINISHED;
 }
@@ -185,26 +314,30 @@ void laui_AddInputMapperNode(laUiList *uil, laPropPack *This, laPropPack *Extra,
     laShowItemFull(uil,c,This,"add_node",0,"type=MOUSE;text=Mouse",0,0);
     laShowItemFull(uil,c,This,"add_node",0,"type=CONTROLLER;text=Controller",0,0);
     laShowSeparator(uil,c);
+    laShowItemFull(uil,c,This,"add_node",0,"type=SPLIT;text=Split",0,0);
+    laShowItemFull(uil,c,This,"add_node",0,"type=SWITCH;text=Switch",0,0);
     laShowItemFull(uil,c,This,"add_node",0,"type=VISUALIZER;text=Visualizer",0,0);
 }
 
-laPropContainer* laget_InputNodeType(laInputMapperNode* imn){
-    if(imn->Type==&LA_IDN_CONTROLLER) return LA_PC_IDN_CONTROLLER;
-    if(imn->Type==&LA_IDN_VISUALIZER) return LA_PC_IDN_VISUALIZER;
+laPropContainer* laget_InputNodeType(laBaseNode* bn){
+    if(bn->Type==&LA_IDN_CONTROLLER) return LA_PC_IDN_CONTROLLER;
+    if(bn->Type==&LA_IDN_VISUALIZER) return LA_PC_IDN_VISUALIZER;
+    if(bn->Type==&LA_IDN_SPLIT) return LA_PC_IDN_SPLIT;
+    if(bn->Type==&LA_IDN_SWITCH) return LA_PC_IDN_SWITCH;
     return LA_PC_IDN_GENERIC;
 }
-int laget_InputNodeGap(laInputRack* rack_unused, laInputMapperNode* n){
+int laget_InputNodeGap(laInputRack* rack_unused, laBaseNode* n){
     return n->Gap;
 }
-void laset_InputNodeGap(laInputMapperNode* n, int gap){
+void laset_InputNodeGap(laBaseNode* n, int gap){
     if(gap<0){
         int done=0;
-        laInputMapperNode* nn=n; while(nn){ if(nn->Gap>0){ nn->Gap--; done=1; break; } nn=nn->Item.pPrev; }
+        laBaseNode* nn=n; while(nn){ if(nn->Gap>0){ nn->Gap--; done=1; break; } nn=nn->Item.pPrev; }
         if(done){ nn=n->Item.pNext; while(nn){ if(nn->Gap>0){ nn->Gap++; break; } nn=nn->Item.pNext; } }
     }
     if(gap>0){
         n->Gap+=gap;
-        laInputMapperNode* nn=n->Item.pNext; while(nn){ if(nn->Gap>0){ nn->Gap--; break; } nn=nn->Item.pNext; }
+        laBaseNode* nn=n->Item.pNext; while(nn){ if(nn->Gap>0){ nn->Gap--; break; } nn=nn->Item.pNext; }
     }
 }
 void laset_InputNodeUserID(laInputControllerNode* n, int i){
@@ -231,6 +364,8 @@ void la_RegisterInputMapperOperators(){
 
     LA_IDN_REGISTER(LA_IDN_CONTROLLER, IDN_ControllerInit, IDN_ControllerDestroy, IDN_ControllerVisit, IDN_ControllerEval, laInputControllerNode);
     LA_IDN_REGISTER(LA_IDN_VISUALIZER, IDN_InputVisualizeInit, IDN_InputVisualizeDestroy, IDN_InputVisualizeVisit, IDN_InputVisualizerEval, laInputVisualizerNode);
+    LA_IDN_REGISTER(LA_IDN_SPLIT, IDN_InputSplitInit, IDN_InputSplitDestroy, IDN_InputSplitVisit, IDN_InputSplitEval, laInputSplitNode);
+    LA_IDN_REGISTER(LA_IDN_SWITCH, IDN_InputSwitchInit, IDN_InputSwitchDestroy, IDN_InputSwitchVisit, IDN_InputSwitchEval, laInputSwitchNode);
 
     laCreateOperatorType("LA_add_input_mapper_rack", "Add Rack", "Add a rack for input mapper nodes", 0,0,0,OPINV_AddInputMapperRack,0,'+',0);
     at=laCreateOperatorType("LA_add_input_mapper_node", "Add Node", "Add a input mapper node",0,0,0,OPINV_AddInputMapperNode,OPMOD_FinishOnData,'+',0);
@@ -242,10 +377,10 @@ void la_RegisterInputMapperOperators(){
     laSubGroupExtraFunctions(p,0,0,laget_InputNodeGap);
     laAddOperatorProperty(pc,"add_node","Add Node","Add a node into this rack","LA_add_input_mapper_node",'+',0);
 
-    pc=laAddPropertyContainer("la_input_node", "Input Node", "Input logic node",0,0,sizeof(laInputMapperNode),0,0,1);
+    pc=laAddPropertyContainer("la_input_node", "Input Node", "Input logic node",0,0,sizeof(laBaseNode),0,0,1);
     LA_PC_IDN_GENERIC=pc;
-    laAddStringProperty(pc,"name","Name","Name of this input node",0,0,0,0,1,offsetof(laInputMapperNode,Name),0,0,0,0,LA_AS_IDENTIFIER);
-    laAddIntProperty(pc,"__gap", "Gap", "Gap of the node", 0,0,0,0,0,0,0,0,offsetof(laInputMapperNode,Gap),0,laset_InputNodeGap,0,0,0,0,0,0,0,0,0);
+    laAddStringProperty(pc,"name","Name","Name of this input node",0,0,0,0,1,offsetof(laBaseNode,Name),0,0,0,0,LA_AS_IDENTIFIER);
+    laAddIntProperty(pc,"__gap", "Gap", "Gap of the node", 0,0,0,0,0,0,0,0,offsetof(laBaseNode,Gap),0,laset_InputNodeGap,0,0,0,0,0,0,0,0,0);
 
     pc=laAddPropertyContainer("la_input_controller_node", "Controller output", "Output controller values",0,laui_ControllerNode,sizeof(laInputControllerNode),0,0,1);
     LA_PC_IDN_CONTROLLER=pc;
@@ -278,6 +413,42 @@ void la_RegisterInputMapperOperators(){
     p=laAddEnumProperty(pc,"switch", "SW", "Switch value", LA_WIDGET_ENUM_HIGHLIGHT,0,0,0,0,offsetof(laInputVisualizerNode,IntVal),0,0,0,laget_VisualizerArrayLength,0,0,0,0,0,LA_READ_ONLY);
     laAddEnumItemAs(p,"IDLE", "Idle", "Button is not pressed", 0, 0);
     laAddEnumItemAs(p,"ACTIVE", "Active", "Button is pressed", 1, 0);
+
+    pc=laAddPropertyContainer("la_input_split_node", "Split", "Split node",0,laui_InputSplitNode,sizeof(laInputSplitNode),0,0,1);
+    LA_PC_IDN_SPLIT=pc;
+    laAddSubGroup(pc,"base","Base","Base node","la_input_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in", "In","Input value","la_in_socket",0,0,0,offsetof(laInputSplitNode,In),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    laAddSubGroup(pc,"out0","Out 0","Output 0","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[0]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out1","Out 1","Output 1","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[1]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out2","Out 2","Output 2","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[2]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out3","Out 3","Output 3","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[3]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out4","Out 4","Output 4","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[4]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out5","Out 5","Output 5","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[5]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out6","Out 6","Output 6","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[6]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out7","Out 7","Output 7","la_input_split_node_out_socket",0,0,0,offsetof(laInputSplitNode, Out[7]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddIntProperty(pc, "array_length", "Array Length", "Array length of data", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laInputSplitNode, ArrLen), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
+
+    pc=laAddPropertyContainer("la_input_split_node_out_socket", "Split Out", "One value from an array input",0,0,sizeof(laInputSplitNodeOutSocket),0,0,1|LA_PROP_OTHER_ALLOC);
+    laAddSubGroup(pc, "out", "Out","Output value","la_out_socket",0,0,0,offsetof(laInputSplitNodeOutSocket,Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+
+    pc=laAddPropertyContainer("la_input_switch_node", "Switch", "Switch node",0,laui_InputSwitchNode,sizeof(laInputSwitchNode),0,0,1);
+    LA_PC_IDN_SWITCH=pc;
+    laAddSubGroup(pc,"base","Base","Base node","la_input_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"out", "Out","Output value","la_out_socket",0,0,0,offsetof(laInputSwitchNode, Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    laAddSubGroup(pc,"in0","In 0","Input 0","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[0]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in1","In 1","Input 1","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[1]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in2","In 2","Input 2","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[2]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in3","In 3","Input 3","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[3]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in4","In 4","Input 4","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[4]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in5","In 5","Input 5","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[5]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in6","In 6","Input 6","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[6]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in7","In 7","Input 7","la_input_switch_node_in_socket",0,0,0,offsetof(laInputSwitchNode, In[7]),0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddIntProperty(pc, "switch", "Switch", "Switch which input to use", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laInputSwitchNode, Switch), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    laAddSubGroup(pc,"switch_in", "Switch In","Switch control","la_in_socket",0,0,0,offsetof(laInputSwitchNode,SwitchIn),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+
+    pc=laAddPropertyContainer("la_input_switch_node_in_socket", "Switch In", "Input of many values",0,0,sizeof(laInputSwitchNodeInSocket),0,0,1|LA_PROP_OTHER_ALLOC);
+    laAddSubGroup(pc, "in", "In","Input value","la_in_socket",0,0,0,offsetof(laInputSwitchNodeInSocket,In),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+
 }
 
 
@@ -288,7 +459,7 @@ void laMappingRequestEval(){ MAIN.MappingNeedEval=1; }
 int la_RunInputMapping(){
     MAIN.MappingNeedEval = 0;
     for(laListItemPointer*lip=MAIN.InputMappingEval.pFirst;lip;lip=lip->pNext){
-        laInputMapperNode* n=lip->p; n->Type->Eval(n);
+        laBaseNode* n=lip->p; n->Type->Eval(n);
     }
     return 1;
 }
@@ -297,9 +468,9 @@ int la_RebuildInputMapping(){
     while(lstPopPointer(&MAIN.InputMappingEval));
     laListHandle pending={0};
     for(laInputRack* ir=MAIN.InputMappingRacks.pFirst;ir;ir=ir->Item.pNext){
-        for(laInputMapperNode*imn=ir->Nodes.pFirst;imn;imn=imn->Item.pNext){ lstAppendPointer(&pending,imn); imn->Eval=0; }
+        for(laBaseNode*bn=ir->Nodes.pFirst;bn;bn=bn->Item.pNext){ lstAppendPointer(&pending,bn); bn->Eval=0; }
     }
-    laInputMapperNode*n;int result=LA_DAG_FLAG_PERM; laListItemPointer*NextLip;
+    laBaseNode*n;int result=LA_DAG_FLAG_PERM; laListItemPointer*NextLip;
     for(laListItemPointer*lip=pending.pFirst;lip;lip=NextLip){ n=lip->p; NextLip=lip->pNext;
         if(n->Eval&LA_DAG_FLAG_PERM) continue;
         result=n->Type->Visit(n,&MAIN.InputMappingEval); if(result==LA_DAG_FLAG_ERR){ while(lstPopPointer(&pending)); break; }

source/lagui/resources/la_properties.c

@@ -1165,12 +1165,14 @@ void la_RegisterInternalProps(){
         p = laAddPropertyContainer("la_out_socket", "Output Socket", "Output socket for nodes", 0, 0, sizeof(laNodeOutSocket), 0, 0, 1);{
             laAddStringProperty(p, "label", "Label", "Socket's label", 0, 0, 0, 0, 1, offsetof(laNodeOutSocket, Label), 0, 0, 0, 0, LA_AS_IDENTIFIER);
             laAddIntProperty(p, "data_type", "Data type", "User defined data type", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeOutSocket, DataType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
+            laAddIntProperty(p, "array_length", "Array Length", "Array length of data", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeOutSocket, ArrLen), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
         } LA_PC_SOCKET_OUT = p;
         p = laAddPropertyContainer("la_in_socket", "Input Socket", "Input socket for nodest", 0, 0, sizeof(laNodeInSocket), 0, 0, 1);{
             laAddStringProperty(p, "label", "Label", "Socket's label", 0, 0, 0, 0, 1, offsetof(laNodeInSocket, Label), 0, 0, 0, 0, LA_AS_IDENTIFIER);
             laAddSubGroup(p, "source", "Source", "Source socket", "la_out_socket",0, 0, offsetof(laNodeInSocket, Source), 0, 0, 0, 0, 0, 0, 0, 0, LA_UDF_REFER);
             laAddIntProperty(p, "data_type", "Data type", "User defined data type", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, DataType), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
             laAddIntProperty(p, "color_id", "Color ID", "Color ID of the source wire", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, ColorId), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0);
+            laAddIntProperty(p, "array_length", "Array Length", "Array length of data", 0, 0, 0, 0, 0, 0, 0, 0, offsetof(laNodeInSocket, ArrLen), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,LA_READ_ONLY);
         } LA_PC_SOCKET_IN = p;
 
         // PROPERTIES ==========================================================================================