casting works

src-tauri/src/runtime/nodes/conditional/iffalse.rs

···
   }
 
   fn update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
-    if let ParameterType::Boolean(boolean) = arg{
-      if boolean{
-        self.runtime_active = true;
-        true
-      } else{
-        self.runtime_active = false;
-        false
-      }
+    if arg.as_bool().unwrap(){
+      self.runtime_active = true;
+      true
     } else{
       self.runtime_active = false;
       false

src-tauri/src/runtime/nodes/conditional/iftrue.rs

···
   }
 
   fn update_arg( &mut self, _: usize, arg: ParameterType ) -> bool {
-    if let ParameterType::Boolean(boolean) = arg{
-      if boolean{
-        self.runtime_active = true;
-        true
-      } else{
-        self.runtime_active = false;
-        false
-      }
+    if arg.as_bool().unwrap(){
+      self.runtime_active = true;
+      true
     } else{
       self.runtime_active = false;
       false

src-tauri/src/structs/parameter_types.rs

···
+use anyhow::{Result, bail};
 use serde::Serialize;
 
 #[derive(Serialize, Clone, Debug, PartialEq)]
···
 
   None
 }
+
+impl ParameterType{
+  pub fn as_bool( &self ) -> Result<bool>{
+    match self{
+      ParameterType::Boolean( val ) => Ok(val.clone()),
+      ParameterType::Int( val ) => if *val == 0{ Ok(false) } else { Ok(true) },
+      _ => bail!("Cannot cast to bool.")
+    }
+  }
+
+  pub fn as_int( &self ) -> Result<i32>{
+    match self{
+      ParameterType::Boolean( val ) => if *val{ Ok(1) } else { Ok(0) },
+      ParameterType::Int( val ) => Ok(val.clone()),
+      ParameterType::Float( val ) => Ok(val.round().clone() as i32),
+      ParameterType::String( val ) => Ok(val.clone().parse()?),
+      _ => bail!("Cannot cast to int.")
+    }
+  }
+
+  pub fn as_float( &self ) -> Result<f32>{
+    match self{
+      ParameterType::Int( val ) => Ok(val.clone() as f32),
+      ParameterType::Float( val ) => Ok(val.clone()),
+      ParameterType::String( val ) => Ok(val.clone().parse()?),
+      _ => bail!("Cannot cast to float.")
+    }
+  }
+
+  pub fn as_string( &self ) -> Result<String>{
+    match self{
+      ParameterType::Boolean( val ) => Ok(val.clone().to_string()),
+      ParameterType::Int( val ) => Ok(val.clone().to_string()),
+      ParameterType::Float( val ) => Ok(val.clone().to_string()),
+      ParameterType::String( val ) => Ok(val.clone()),
+      _ => bail!("Cannot cast to string.")
+    }
+  }
+}

src/renderer.ts

···
 
     node.outputs.map(( output, i ) => {
       output.connections.map(partner => {
-        ctx.strokeStyle = NodeIOLinkColours(output);
+        let x0 = (nodeX + (node.w - 10) + 10 + startX + position.x) * position.scale;
+        let y0 = (nodeY + 50 + (30 * i) + 10 + startY + position.y) * position.scale;
+        let x1 = ((Math.round(partner.parent.x / 10) * 10) + startX + position.x) * position.scale;
+        let y1 = ((Math.round(partner.parent.y / 10) * 10) + 60 + (30 * partner.index) + startY + position.y) * position.scale;
+
+        let colours = NodeIOLinkColours(output, partner);
+        let grad = ctx.createLinearGradient(x0, y0, x1, y1);
+
+        grad.addColorStop(0, colours[0]);
+        grad.addColorStop(1, colours[1]);
+
+        ctx.strokeStyle = grad;
         ctx.lineWidth = 3 * position.scale;
 
-        drawCurve(ctx,
-          (nodeX + (node.w - 10) + 10 + startX + position.x) * position.scale,
-          (nodeY + 50 + (30 * i) + 10 + startY + position.y) * position.scale,
-          ((Math.round(partner.parent.x / 10) * 10) + startX + position.x) * position.scale,
-          ((Math.round(partner.parent.y / 10) * 10) + 60 + (30 * partner.index) + startY + position.y) * position.scale,
-        );
+        drawCurve(ctx, x0, y0, x1, y1);
         ctx.stroke();
       })
     })

src/structs/node.ts

···
   ParameterList = 10
 }
 
+let NodeIOCastTable: any = {
+  1: { 2: true, 3: true, 4: true }, // Strings -> Floats, Ints, Bools
+  2: { 1: true, 3: true },          // Floats -> Strings, Ints
+  3: { 1: true, 2: true, 4: true }, // Ints -> Strings, Floats, Bools
+  4: { 1: true, 2: true, 3: true }  // Bools -> Strings, Ints, Floats
+};
+
 export let NodeIOCanCast = ( input: NodeType | null, output: NodeType | null ): boolean => {
   if(input === output)return true;
   if(!input || !output)return false;
 
-  return false;
+  let CastFrom = NodeIOCastTable[input];
+  if(!CastFrom)return false;
+
+  let CastTo = CastFrom[output];
+  if(!CastTo)return false;
+
+  return true;
 }
 
 export let NodeIOResolveAnyTypes = ( nodeio: NodeIO ): NodeType | null => {
···
   return null;
 }
 
-export let NodeIOLinkColours = ( nodeio: NodeIO ) => {
+export let NodeIOLinkColours = ( nodeio: NodeIO, output?: NodeIO ) => {
   let cols: any = {
     1: '#ffff9f',
     2: '#cda0cb',
···
   }
 
   let type = NodeIOResolveAnyTypes(nodeio);
+  if(output){
+    let outputType = NodeIOResolveAnyTypes(output);
+    let startType = type ? cols[type] : '#fff5';
+
+    if(type !== outputType){
+      let endType = outputType ? cols[outputType] : '#fff5';
+
+      return [ startType, endType ];
+    } else{
+      return [ startType, startType ];
+    }
+  }
+
   return type ? cols[type] : '#fff5';
 }