Vector math, random, handler fixes

la_interface.h

@@ -377,8 +377,8 @@ STRUCTURE(LA){
     void *ToPanel;
 
     int NextX, NextY, NextW, NextH;
-    laNodeInSocket tNodeIn;
-    laNodeOutSocket tNodeOut;
+    laNodeInSocket* tNodeIn;
+    laNodeOutSocket* tNodeOut;
 
 
     laAuthorInfo Author;
@@ -1327,6 +1327,17 @@ extern laNodeCategory* LA_NODE_CATEGORY_DRIVER;
 #define LA_MATH_NODE_OP_ATAN 11
 #define LA_MATH_NODE_OP_ATAN2 12
 
+#define LA_VECTOR_MATH_OP_ADD 0
+#define LA_VECTOR_MATH_OP_SUB 1
+#define LA_VECTOR_MATH_OP_MUL 2
+#define LA_VECTOR_MATH_OP_DIV 3
+#define LA_VECTOR_MATH_OP_POW 4
+#define LA_VECTOR_MATH_OP_LOG 5
+#define LA_VECTOR_MATH_OP_DOT 6
+#define LA_VECTOR_MATH_OP_CROSS 7
+#define LA_VECTOR_MATH_OP_LEN 8
+#define LA_VECTOR_MATH_OP_NORMALIZE 9
+
 STRUCTURE(laRackPage){
     laListItem Item;
     laSafeString* Name;
@@ -1429,6 +1440,18 @@ STRUCTURE(laMapperNode){
     laValueMapper* Mapper;
     int Clamp;
 };
+STRUCTURE(laRandomNode){
+    laBaseNode Base;
+    laNodeOutSocket* Out; real rOut;
+    real Min,Max;
+};
+STRUCTURE(laVectorMathNode){
+    laBaseNode Base;
+    laNodeInSocket *InL,*InR;
+    laNodeOutSocket* Out;
+    real rOut[4];
+    int Operation;
+};
 
 STRUCTURE(laNodeCategory){
     laListItem Item;

la_kernel.c

@@ -4795,7 +4795,7 @@ void la_SendWireVerts(real x1, real y1, real x2, real y2, real circle_r){
     }
 }
 void la_DrawNodeWires(laUiListDraw* uild){
-    if(!uild->SocketRecord.pFirst && !MAIN.tNodeIn.Source){ return; }
+    if(!uild->SocketRecord.pFirst && !MAIN.tNodeIn->Source){ return; }
     laBoxedTheme* bt=_LA_THEME_SOCKET;
 
     tnsUseNoTexture();
@@ -4806,7 +4806,7 @@ void la_DrawNodeWires(laUiListDraw* uild){
 
         int inx=sr->In->RuntimeX+sr->In->RuntimePX, iny=sr->In->RuntimeY+sr->In->RuntimePY;
         int outx=sr->Out->RuntimeX+sr->Out->RuntimePX, outy=sr->Out->RuntimeY+sr->Out->RuntimePY;
-        if(sr->Out==&MAIN.tNodeOut){ outx=inx+MAIN.tNodeOut.RuntimeX+MAIN.tNodeOut.RuntimePX; outy=iny+MAIN.tNodeOut.RuntimeY+MAIN.tNodeOut.RuntimePY; }
+        if(sr->Out==MAIN.tNodeOut){ outx=inx+MAIN.tNodeOut->RuntimeX+MAIN.tNodeOut->RuntimePX; outy=iny+MAIN.tNodeOut->RuntimeY+MAIN.tNodeOut->RuntimePY; }
 
         tnsMakeRing2d(v,idx,_RSLICES, inx, iny, r, r*0.6);
         tnsVertexArray2d(v,_RSLICES*2); tnsIndexArray(idx, _RSLICES*2+2);
@@ -4816,8 +4816,8 @@ void la_DrawNodeWires(laUiListDraw* uild){
         tnsVertexArray2d(v,_RSLICES*2); tnsIndexArray(idx, _RSLICES*2+2);
         tnsColor4d(LA_COLOR3(&MAIN.WireColorCache[cid]),1); tnsPackAs(GL_TRIANGLE_STRIP);
     }
-    if(MAIN.tNodeIn.Source){
-        laNodeInSocket* ins=&MAIN.tNodeIn; laNodeOutSocket* outs=ins->Source;
+    if(MAIN.tNodeIn->Source){
+        laNodeInSocket* ins=MAIN.tNodeIn; laNodeOutSocket* outs=ins->Source;
         int cid=ins->ColorId%MAIN.WireColorSlices*4;
 
         int outx=outs->RuntimeX+outs->RuntimePX, outy=outs->RuntimeY+outs->RuntimePY;
@@ -4840,13 +4840,13 @@ void la_DrawNodeWires(laUiListDraw* uild){
         int cid=sr->In->ColorId%MAIN.WireColorSlices*4;
         int inx=sr->In->RuntimeX+sr->In->RuntimePX, iny=sr->In->RuntimeY+sr->In->RuntimePY;
         int outx=sr->Out->RuntimeX+sr->Out->RuntimePX, outy=sr->Out->RuntimeY+sr->Out->RuntimePY;
-        if(sr->Out==&MAIN.tNodeOut){ outx=inx+MAIN.tNodeOut.RuntimeX+MAIN.tNodeOut.RuntimePX; outy=iny+MAIN.tNodeOut.RuntimeY+MAIN.tNodeOut.RuntimePY; }
+        if(sr->Out==MAIN.tNodeOut){ outx=inx+MAIN.tNodeOut->RuntimeX+MAIN.tNodeOut->RuntimePX; outy=iny+MAIN.tNodeOut->RuntimeY+MAIN.tNodeOut->RuntimePY; }
 
         la_SendWireVerts(inx, iny, outx, outy, r*0.9);
         tnsColor4dv(&MAIN.WireColorCache[cid]); tnsPackAs(GL_LINE_STRIP);
     }
-    if(MAIN.tNodeIn.Source){
-        laNodeInSocket* ins=&MAIN.tNodeIn; laNodeOutSocket* outs=ins->Source;
+    if(MAIN.tNodeIn->Source){
+        laNodeInSocket* ins=MAIN.tNodeIn; laNodeOutSocket* outs=ins->Source;
         int cid=ins->ColorId%MAIN.WireColorSlices*4;
 
         int outx=outs->RuntimeX+outs->RuntimePX, outy=outs->RuntimeY+outs->RuntimePY;

resources/la_nodes_basic.c

@@ -14,6 +14,8 @@ laBaseNodeType LA_IDN_VALUES;
 laBaseNodeType LA_IDN_MATRIX;
 laBaseNodeType LA_IDN_MATH;
 laBaseNodeType LA_IDN_MAPPER;
+laBaseNodeType LA_IDN_RANDOM;
+laBaseNodeType LA_IDN_VECTOR_MATH;
 
 laPropContainer* LA_PC_IDN_GENERIC;
 laPropContainer* LA_PC_IDN_KEYBOARD;
@@ -27,6 +29,8 @@ laPropContainer* LA_PC_IDN_VALUES;
 laPropContainer* LA_PC_IDN_MATRIX;
 laPropContainer* LA_PC_IDN_MATH;
 laPropContainer* LA_PC_IDN_MAPPER;
+laPropContainer* LA_PC_IDN_RANDOM;
+laPropContainer* LA_PC_IDN_VECTOR_MATH;
 
 laNodeCategory* LA_NODE_CATEGORY_INPUT;
 laNodeCategory* LA_NODE_CATEGORY_MATH;
@@ -312,9 +316,9 @@ void laui_CombineNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColu
 
     b=laBeginRow(uil,c,0,0);
     laUiItem* lu=laShowLabel(uil,c,"Combine 🡲",0,0); lu->Expand=1; lu->Flags|=LA_TEXT_ALIGN_RIGHT;
-    laShowNodeSocket(uil,c,This,"out_enum",0)->Flags|=LA_UI_SOCKET_LABEL_N;
-    laShowNodeSocket(uil,c,This,"out_int",0)->Flags|=LA_UI_SOCKET_LABEL_N;
-    laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_N;
+    laShowNodeSocket(uil,c,This,"out_enum",0)->Flags|=LA_UI_SOCKET_LABEL_W;
+    laShowNodeSocket(uil,c,This,"out_int",0)->Flags|=LA_UI_SOCKET_LABEL_W;
+    laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_W;
     laEndRow(uil,b);
 }
 
@@ -464,8 +468,8 @@ void laui_MathNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn
     b=laBeginRow(uil,c,0,0);
     laShowNodeSocket(uil,c,This,"in_r",0); b=laOnConditionThat(uil,c,laNot(laPropExpression(This,"in_r.source")));{ laShowItem(uil,c,This,"vr");}laEndCondition(uil,b);
     laShowSeparator(uil,c)->Expand=1;
-    laShowNodeSocket(uil,c,This,"out_int",0)->Flags|=LA_UI_SOCKET_LABEL_N;
-    laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_N;
+    laShowNodeSocket(uil,c,This,"out_int",0)->Flags|=LA_UI_SOCKET_LABEL_W;
+    laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_W;
     laEndRow(uil,b);
 }
 
@@ -510,6 +514,86 @@ void laui_MapperNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColum
     laEndRow(uil,b);
 }
 
+void IDN_RandomInit(laRandomNode* n){
+    strSafeSet(&n->Base.Name,"Random"); n->Out=laCreateOutSocket(n,"RAND",LA_PROP_FLOAT); n->Out->Data=&n->rOut; n->Min=0; n->Max=1;
+}
+void IDN_RandomDestroy(laRandomNode* n){
+    strSafeDestroy(&n->Base.Name); laDestroyOutSocket(n->Out);
+}
+int IDN_RandomVisit(laRandomNode* n, laListHandle* l){
+    LA_GUARD_THIS_NODE(n); n->Base.Eval=LA_DAG_FLAG_PERM; lstAppendPointer(l, n);
+    return LA_DAG_FLAG_PERM;
+}
+int IDN_RandomEval(laRandomNode* n){
+    n->rOut=n->Min+(real)rand()/(real)(RAND_MAX/(n->Max-n->Min));
+    return 1;
+}
+void laui_RandomNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
+    laColumn* c=laFirstColumn(uil); laRandomNode*n=This->EndInstance;
+    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,3); cr=laRightColumn(c,0);
+    laUiItem*b,*b2;
+    LA_BASE_NODE_HEADER(uil,c,This);
+
+    b=laBeginRow(uil,c,0,0);
+    laShowItem(uil,c,This,"range")->Expand=1;laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_W;
+    laEndRow(uil,b);
+}
+
+void IDN_VectorMathInit(laVectorMathNode* n){
+    strSafeSet(&n->Base.Name,"Math");
+    n->InL=laCreateInSocket("l",0); n->InR=laCreateInSocket("r",0);
+    n->Out=laCreateOutSocket(n,"OUT",LA_PROP_FLOAT);
+    n->Out->Data=n->rOut;
+}
+void IDN_VectorMathDestroy(laVectorMathNode* n){
+    strSafeDestroy(&n->Base.Name); laDestroyInSocket(n->InL); laDestroyInSocket(n->InR); laDestroyOutSocket(n->Out);
+}
+int IDN_VectorMathVisit(laVectorMathNode* n, laListHandle* l){
+    LA_GUARD_THIS_NODE(n);
+    if(LA_SRC_AND_PARENT(n->InL)){ laBaseNode* bn=n->InL->Source->Parent; LA_VISIT_NODE(bn); }
+    if(LA_SRC_AND_PARENT(n->InR)){ laBaseNode* bn=n->InR->Source->Parent; LA_VISIT_NODE(bn); }
+    n->Base.Eval=LA_DAG_FLAG_PERM;
+    lstAppendPointer(l, n);
+    return LA_DAG_FLAG_PERM;
+}
+#define LA_GET_SRC_AS_FLOAT_THINGS(var, socket, maxlen)\
+    {if(socket->Source->DataType&LA_PROP_FLOAT){ real*adr=socket->Source->Data; maxlen=TNS_MIN2(TNS_MAX2(1,socket->Source->ArrLen),maxlen); for(int i=0;i<maxlen;i++){ var[i]=adr[i]; } }\
+    if(socket->Source->DataType&(LA_PROP_INT|LA_PROP_ENUM)){ int*adr=socket->Source->Data; maxlen=TNS_MIN2(TNS_MAX2(1,socket->Source->ArrLen),maxlen); for(int i=0;i<maxlen;i++){ var[i]=adr[i]; } }\
+    }
+int IDN_VectorMathEval(laVectorMathNode* n){
+    real vl[4]={0,0,0,1};real vr[4]={0,0,0,1}; int maxlen1=4,maxlen2=4,maxlen;
+    int hasl=LA_SRC_AND_PARENT(n->InL),hasr=LA_SRC_AND_PARENT(n->InR);
+    if(hasl){ LA_GET_SRC_AS_FLOAT_THINGS(vl,n->InL,maxlen1) } if(hasr){ LA_GET_SRC_AS_FLOAT_THINGS(vr,n->InR,maxlen2) }
+    if(maxlen1>1 && maxlen2<maxlen1){ for(int i=maxlen2;i<maxlen1;i++){ vr[i]=vr[maxlen2-1]; } maxlen=maxlen1; }
+    else{ maxlen=TNS_MIN2(maxlen1,maxlen2); }
+    switch(n->Operation){
+    case LA_VECTOR_MATH_OP_ADD: default:n->Out->ArrLen=maxlen;  for(int i=0;i<maxlen;i++)n->rOut[i]=vl[i]+vr[i]; break;
+    case LA_VECTOR_MATH_OP_SUB:n->Out->ArrLen=maxlen; for(int i=0;i<maxlen;i++)n->rOut[i]=vl[i]-vr[i];  break;
+    case LA_VECTOR_MATH_OP_MUL:n->Out->ArrLen=maxlen; for(int i=0;i<maxlen;i++)n->rOut[i]=vl[i]*vr[i]; break;
+    case LA_VECTOR_MATH_OP_DIV:n->Out->ArrLen=maxlen; for(int i=0;i<maxlen;i++)n->rOut[i]=vl[i]/vr[i]; break;
+    case LA_VECTOR_MATH_OP_POW:n->Out->ArrLen=maxlen; for(int i=0;i<maxlen;i++)n->rOut[i]=pow(vl[i],vr[i]); break;
+    case LA_VECTOR_MATH_OP_LOG:n->Out->ArrLen=maxlen; for(int i=0;i<maxlen;i++)n->rOut[i]=log2(vl[i])/log2(vr[i]); break;
+    case LA_VECTOR_MATH_OP_CROSS: if(maxlen<3) return 0; n->Out->ArrLen=3; tnsVectorCross3d(n->rOut,vl,vr); break;
+    case LA_VECTOR_MATH_OP_DOT: if(maxlen<2) return 0; n->Out->ArrLen=maxlen; if(maxlen==2) n->rOut[0]=tnsDot2d(vl,vr,0); else n->rOut[0]=tnsDot3d(vl,vr,0); break;
+    case LA_VECTOR_MATH_OP_NORMALIZE: if(maxlen<2) return 0; n->Out->ArrLen=maxlen; if(maxlen==2) tnsNormalize2d(n->rOut, vl); else tnsNormalize3d(n->rOut, vl); break;
+    }
+    return 1;
+}
+void laui_VectorMathNode(laUiList *uil, laPropPack *This, laPropPack *Extra, laColumn *UNUSED, int context){
+    laColumn* c=laFirstColumn(uil); laVectorMathNode*n=This->EndInstance;
+    laColumn* cl,*cr; laSplitColumn(uil,c,0.4); cl=laLeftColumn(c,3); cr=laRightColumn(c,0);
+    laUiItem*b,*b2;
+    LA_BASE_NODE_HEADER(uil,c,This);
+
+    b=laBeginRow(uil,c,0,0);
+    laShowNodeSocket(uil,c,This,"in_l",0); laShowNodeSocket(uil,c,This,"in_r",0);
+    laShowSeparator(uil,c)->Expand=1;
+    laShowItem(uil,c,This,"operation");
+    laShowNodeSocket(uil,c,This,"out",0)->Flags|=LA_UI_SOCKET_LABEL_W;
+    laEndRow(uil,b);
+}
+
+
 
 int OPINV_AddInputMapperPage(laOperator* a, laEvent *e){
     laRackPage* dp=memAcquireHyper(sizeof(laRackPage));
@@ -908,6 +992,29 @@ void la_RegisterInputMapperOperators(){
     laAddEnumItemAs(p,"NONE", "None", "Don't clamp output", 0, 0);
     laAddEnumItemAs(p,"CLAMP", "Clamp", "Clamp output to specified range", 1, 0);
 
+    pc=laAddPropertyContainer("la_random_node", "Random", "Random node",0,laui_RandomNode,sizeof(laRandomNode),0,0,1);
+    LA_PC_IDN_RANDOM=pc; laPropContainerExtraFunctions(pc,0,0,0,0,laui_DefaultNodeOperationsPropUiDefine);
+    laAddSubGroup(pc,"base","Base","Base node","la_base_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(laRandomNode, Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    laAddFloatProperty(pc, "range", "Range", "Range of the random values", 0,0,0,0,0,0,0,0,offsetof(laRandomNode, Min),0,0,2,0,0,0,0,0,0,0,0);
+
+    pc=laAddPropertyContainer("la_vector_math_node", "Vector Math", "Math node",0,laui_VectorMathNode,sizeof(laVectorMathNode),0,0,1);
+    LA_PC_IDN_VECTOR_MATH=pc; laPropContainerExtraFunctions(pc,0,0,0,0,laui_DefaultNodeOperationsPropUiDefine);
+    laAddSubGroup(pc,"base","Base","Base node","la_base_node",0,0,0,0,0,0,0,0,0,0,0,LA_UDF_LOCAL);
+    laAddSubGroup(pc,"in_l", "L","Left input","la_in_socket",0,0,0,offsetof(laVectorMathNode, InL),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    laAddSubGroup(pc,"in_r", "R","Right input","la_in_socket",0,0,0,offsetof(laVectorMathNode, InR),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    laAddSubGroup(pc,"out", "Out","Output value","la_out_socket",0,0,0,offsetof(laVectorMathNode, Out),0,0,0,0,0,0,0,LA_UDF_SINGLE);
+    p=laAddEnumProperty(pc,"operation", "Operation", "Operation", 0,0,0,0,0,offsetof(laVectorMathNode, Operation),0,0,0,0,0,0,0,0,0,0);
+    laAddEnumItemAs(p,"ADD", "Add", "L + R", LA_VECTOR_MATH_OP_ADD, 0);
+    laAddEnumItemAs(p,"SUB", "Subtract", "L - R", LA_VECTOR_MATH_OP_SUB, 0);
+    laAddEnumItemAs(p,"MUL", "Multiply (component)", "L x R (component)", LA_VECTOR_MATH_OP_MUL, 0);
+    laAddEnumItemAs(p,"DIV", "Divide (component)", "L / R (component)", LA_VECTOR_MATH_OP_DIV, 0);
+    laAddEnumItemAs(p,"CROSS", "Cross", "L x R", LA_VECTOR_MATH_OP_CROSS, 0);
+    laAddEnumItemAs(p,"DOT", "Dot", "L . R", LA_VECTOR_MATH_OP_DOT, 0);
+    laAddEnumItemAs(p,"POW", "Power", "pow(L,R)", LA_VECTOR_MATH_OP_POW, 0);
+    laAddEnumItemAs(p,"LOG", "Log", "log(L)base(R)", LA_VECTOR_MATH_OP_LOG, 0);
+    laAddEnumItemAs(p,"NORM", "Normalize", "Normalize(L)", LA_VECTOR_MATH_OP_NORMALIZE, 0);
+    
     LA_IDN_REGISTER("Controller",L'🕹',LA_IDN_CONTROLLER,LA_PC_IDN_CONTROLLER, IDN_ControllerInit, IDN_ControllerDestroy, IDN_ControllerVisit, IDN_ControllerEval, laInputControllerNode);
     LA_IDN_REGISTER("Visualizer",L'🔍',LA_IDN_VISUALIZER,LA_PC_IDN_VISUALIZER, IDN_InputVisualizeInit, IDN_InputVisualizeDestroy, IDN_InputVisualizeVisit, IDN_InputVisualizerEval, laInputVisualizerNode);
     LA_IDN_REGISTER("Split",L'⚟',LA_IDN_SPLIT,LA_PC_IDN_SPLIT, IDN_SplitInit, IDN_SplitDestroy, IDN_SplitVisit, IDN_SplitEval, laSplitNode);
@@ -917,14 +1024,19 @@ void la_RegisterInputMapperOperators(){
     LA_IDN_REGISTER("Matrix",0,LA_IDN_MATRIX,LA_PC_IDN_MATRIX, IDN_MatrixInit, IDN_MatrixDestroy, IDN_MatrixVisit, IDN_MatrixEval, laMatrixNode);
     LA_IDN_REGISTER("Math",0,LA_IDN_MATH,LA_PC_IDN_MATH, IDN_MathInit, IDN_MathDestroy, IDN_MathVisit, IDN_MathEval, laMathNode);
     LA_IDN_REGISTER("Mapper",0,LA_IDN_MAPPER,LA_PC_IDN_MAPPER, IDN_MapperInit, IDN_MapperDestroy, IDN_MapperVisit, IDN_MapperEval, laMapperNode);
-
+    LA_IDN_REGISTER("Random",0,LA_IDN_RANDOM,LA_PC_IDN_RANDOM, IDN_RandomInit, IDN_RandomDestroy, IDN_RandomVisit, IDN_RandomEval, laRandomNode);
+    LA_IDN_REGISTER("Math",0,LA_IDN_VECTOR_MATH,LA_PC_IDN_VECTOR_MATH, IDN_VectorMathInit, IDN_VectorMathDestroy, IDN_VectorMathVisit, IDN_VectorMathEval, laVectorMathNode);
+    
     LA_NODE_CATEGORY_INPUT=laAddNodeCategory("Input",0,LA_RACK_TYPE_INPUT);
     LA_NODE_CATEGORY_MATH=laAddNodeCategory("Math",0,LA_RACK_TYPE_ALL);
     LA_NODE_CATEGORY_ROUTE=laAddNodeCategory("Route",0,LA_RACK_TYPE_ALL);
 
     laNodeCategoryAddNodeTypes(LA_NODE_CATEGORY_INPUT, &LA_IDN_CONTROLLER,0);
-    laNodeCategoryAddNodeTypes(LA_NODE_CATEGORY_MATH, &LA_IDN_MATRIX,&LA_IDN_MATH,&LA_IDN_MAPPER,0);
+    laNodeCategoryAddNodeTypes(LA_NODE_CATEGORY_MATH, &LA_IDN_MATH,&LA_IDN_VECTOR_MATH,&LA_IDN_MAPPER,&LA_IDN_RANDOM,&LA_IDN_MATRIX,0);
     laNodeCategoryAddNodeTypes(LA_NODE_CATEGORY_ROUTE, &LA_IDN_SPLIT, &LA_IDN_SWITCH, &LA_IDN_COMBINE, &LA_IDN_VALUES, &LA_IDN_VISUALIZER,0);
+
+    MAIN.tNodeIn=laCreateInSocket("TIN",0);
+    MAIN.tNodeOut=laCreateOutSocket(0,"TOUT",0);
 }
 
 

resources/la_widgets.c

@@ -2692,19 +2692,19 @@ int OPMOD_NodeSocket(laOperator *a, laEvent *e){
             laNodeInSocket* s=ui->PP.EndInstance;
             uit->Ptr2 = s->Source;
             if(!s->Source){
-                s->ColorId=MAIN.NextWireColor; s->Source=&MAIN.tNodeOut; latouched_NodeInSocket(0,0);
-                MAIN.tNodeOut.RuntimeX=MAIN.tNodeOut.RuntimeY=MAIN.tNodeOut.RuntimePX=MAIN.tNodeOut.RuntimePY=0;
+                s->ColorId=MAIN.NextWireColor; s->Source=MAIN.tNodeOut; latouched_NodeInSocket(0,0);
+                MAIN.tNodeOut->RuntimeX=MAIN.tNodeOut->RuntimeY=MAIN.tNodeOut->RuntimePX=MAIN.tNodeOut->RuntimePY=0;
             }else{
-                MAIN.tNodeIn.Source = s->Source;
-                MAIN.tNodeIn.RuntimeX=MAIN.tNodeIn.RuntimeY=MAIN.tNodeIn.RuntimePX=MAIN.tNodeIn.RuntimePY=0;
-                MAIN.tNodeIn.RuntimePX=-(s->Source->RuntimeX+s->Source->RuntimePX)+(s->RuntimeX+s->RuntimePX);
-                MAIN.tNodeIn.RuntimePY=-(s->Source->RuntimeY+s->Source->RuntimePY)+(s->RuntimeY+s->RuntimePY);
-                s->Source=0; MAIN.tNodeIn.ColorId=s->ColorId; latouched_NodeInSocket(0,0);
+                MAIN.tNodeIn->Source = s->Source;
+                MAIN.tNodeIn->RuntimeX=MAIN.tNodeIn->RuntimeY=MAIN.tNodeIn->RuntimePX=MAIN.tNodeIn->RuntimePY=0;
+                MAIN.tNodeIn->RuntimePX=-(s->Source->RuntimeX+s->Source->RuntimePX)+(s->RuntimeX+s->RuntimePX);
+                MAIN.tNodeIn->RuntimePY=-(s->Source->RuntimeY+s->Source->RuntimePY)+(s->RuntimeY+s->RuntimePY);
+                s->Source=0; MAIN.tNodeIn->ColorId=s->ColorId; latouched_NodeInSocket(0,0);
             }
         }
-        elif(pc==LA_PC_SOCKET_OUT){ MAIN.tNodeIn.Source=ui->PP.EndInstance; latouched_NodeInSocket(0,0);
-            MAIN.tNodeIn.RuntimeX=MAIN.tNodeIn.RuntimeY=MAIN.tNodeIn.RuntimePX=MAIN.tNodeIn.RuntimePY=0;
-            MAIN.tNodeIn.ColorId=MAIN.NextWireColor;  }
+        elif(pc==LA_PC_SOCKET_OUT){ MAIN.tNodeIn->Source=ui->PP.EndInstance; latouched_NodeInSocket(0,0);
+            MAIN.tNodeIn->RuntimeX=MAIN.tNodeIn->RuntimeY=MAIN.tNodeIn->RuntimePX=MAIN.tNodeIn->RuntimePY=0;
+            MAIN.tNodeIn->ColorId=MAIN.NextWireColor;  }
         uit->LastX = e->x; uit->LastY = e->y;
         laRedrawCurrentPanel();
         return LA_RUNNING;
@@ -2714,14 +2714,14 @@ int OPMOD_NodeSocket(laOperator *a, laEvent *e){
         laLocalToPanel(a, &lx, &ly);
         laUiItem* tui=la_DetectSocketRecursive(&p->UI,lx,ly,100000,uit->Ptr2?LA_PC_SOCKET_IN:PCFind); uit->Ptr1=tui;
         if(pc==LA_PC_SOCKET_IN){
-            if(!uit->Ptr2){MAIN.tNodeOut.RuntimeX=e->x-uit->LastX;MAIN.tNodeOut.RuntimeY=e->y-uit->LastY;}
-            else { MAIN.tNodeIn.RuntimeX=e->x-uit->LastX;MAIN.tNodeIn.RuntimeY=e->y-uit->LastY; } }
-        elif(pc==LA_PC_SOCKET_OUT){ MAIN.tNodeIn.RuntimeX=e->x-uit->LastX; MAIN.tNodeIn.RuntimeY=e->y-uit->LastY; }
+            if(!uit->Ptr2){MAIN.tNodeOut->RuntimeX=e->x-uit->LastX;MAIN.tNodeOut->RuntimeY=e->y-uit->LastY;}
+            else { MAIN.tNodeIn->RuntimeX=e->x-uit->LastX;MAIN.tNodeIn->RuntimeY=e->y-uit->LastY; } }
+        elif(pc==LA_PC_SOCKET_OUT){ MAIN.tNodeIn->RuntimeX=e->x-uit->LastX; MAIN.tNodeIn->RuntimeY=e->y-uit->LastY; }
         laRedrawCurrentPanel();
         return LA_RUNNING;
     }
     if (uit->Dragging && (e->Type == LA_L_MOUSE_UP || e->Type == LA_R_MOUSE_DOWN || e->key == LA_KEY_ESCAPE)){
-        uit->Dragging=0; MAIN.tNodeIn.Source=0;
+        uit->Dragging=0; MAIN.tNodeIn->Source=0;
         laRecalcCurrentPanel();
         laUiItem* tui=uit->Ptr1; void* soc=tui?tui->PP.EndInstance:0;
         if(pc == LA_PC_SOCKET_IN){