Part Tools Import
Part Tools Import

--- /dev/null
+++ b/Assets/PartTools/Editor/InternalSpaceEditor.cs
@@ -1,1 +1,37 @@
+using UnityEngine;
+using UnityEditor;
 
+[CustomEditor(typeof(KSPPartTools.InternalSpace))]
+public class InternalSpaceEditor : Editor
+{
+    KSPPartTools.InternalSpaceInspector owner;
+
+    public InternalSpaceEditor()
+    {
+        owner = new KSPPartTools.InternalSpaceInspector(this);
+    }
+
+    #region EditorInspector Methods
+
+    public override void OnInspectorGUI()
+    {
+        owner.OnInspectorGUI();
+    }
+
+    public override bool HasPreviewGUI()
+    {
+        return owner.HasPreviewGUI();
+    }
+
+    public override void OnPreviewGUI(Rect r, GUIStyle background)
+    {
+        owner.OnPreviewGUI(r, background);
+    }
+
+    public override void OnPreviewSettings()
+    {
+        owner.OnPreviewSettings();
+    }
+
+    #endregion
+}

--- /dev/null
+++ b/Assets/PartTools/Editor/KSPParticleEmitterEditor.cs
@@ -1,1 +1,42 @@
+using UnityEngine;
+using UnityEditor;
 
+[CustomEditor(typeof(KSPPartTools.KSPParticleEmitter))]
+public class KSPParticleEmitterEditor : Editor
+{
+    KSPPartTools.KSPParticleEmitterInspector  owner;
+
+    public KSPParticleEmitterEditor()
+    {
+        owner = new KSPPartTools.KSPParticleEmitterInspector(this);
+    }
+
+    #region EditorInspector Methods
+
+    public override void OnInspectorGUI()
+    {
+        owner.OnInspectorGUI();
+    }
+
+    public override bool HasPreviewGUI()
+    {
+        return owner.HasPreviewGUI();
+    }
+
+    public override void OnPreviewGUI(Rect r, GUIStyle background)
+    {
+        owner.OnPreviewGUI(r, background);
+    }
+
+    public override void OnPreviewSettings()
+    {
+        owner.OnPreviewSettings();
+    }
+
+    public void OnSceneGUI()
+    {
+        owner.OnSceneGUI();
+    }
+
+    #endregion
+}

--- /dev/null
+++ b/Assets/PartTools/Editor/PartToolsEditor.cs
@@ -1,1 +1,37 @@
+using UnityEngine;
+using UnityEditor;
 
+[CustomEditor(typeof(KSPPartTools.PartTools))]
+public class PartToolsEditor : Editor
+{
+    KSPPartTools.PartToolsInspector owner;
+
+    public PartToolsEditor()
+    {
+        owner = new KSPPartTools.PartToolsInspector(this);
+    }
+
+    #region EditorInspector Methods
+
+    public override void OnInspectorGUI()
+    {
+        owner.OnInspectorGUI();
+    }
+
+    public override bool HasPreviewGUI()
+    {
+        return owner.HasPreviewGUI();
+    }
+
+    public override void OnPreviewGUI(Rect r, GUIStyle background)
+    {
+        owner.OnPreviewGUI(r, background);
+    }
+
+    public override void OnPreviewSettings()
+    {
+        owner.OnPreviewSettings();
+    }
+
+    #endregion
+}

--- /dev/null
+++ b/Assets/PartTools/Editor/PartToolsWindows.cs
@@ -1,1 +1,11 @@
+using UnityEngine;
+using UnityEditor;
 
+public class PartToolsWindows
+{
+    [MenuItem("Tools/KSP Part Tools")]
+    public static void ShowPartToolsWindow()
+    {
+        KSPPartTools.PartToolsWindow.ShowWindow();
+    }
+}

--- /dev/null
+++ b/Assets/PartTools/Editor/PropEditor.cs
@@ -1,1 +1,37 @@
+using UnityEngine;
+using UnityEditor;
 
+[CustomEditor(typeof(KSPPartTools.Prop))]
+public class PropEditor : Editor
+{
+    KSPPartTools.PropInspector owner;
+
+    public PropEditor()
+    {
+        owner = new KSPPartTools.PropInspector(this);
+    }
+
+    #region EditorInspector Methods
+
+    public override void OnInspectorGUI()
+    {
+        owner.OnInspectorGUI();
+    }
+
+    public override bool HasPreviewGUI()
+    {
+        return owner.HasPreviewGUI();
+    }
+
+    public override void OnPreviewGUI(Rect r, GUIStyle background)
+    {
+        owner.OnPreviewGUI(r, background);
+    }
+
+    public override void OnPreviewSettings()
+    {
+        owner.OnPreviewSettings();
+    }
+
+    #endregion
+}

 Binary files /dev/null and b/Assets/PartTools/Lib/PartTools.dll differ
 Binary files /dev/null and b/Assets/PartTools/Lib/PartToolsEditor.dll differ
--- /dev/null
+++ b/Assets/PartTools/Shaders/Alpha.shader
@@ -1,1 +1,80 @@
+Shader "KSP/Alpha/Translucent"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGBA)", 2D) = "white" {}
+		_Color("TintColor", Color) = (1,1,1,1)
+		_Opacity("_Opacity", Range(0,1)) = 1
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		[MaterialToggle] _FresnelInvert("Invert Fresnel", Float) = 0
 
+		_RimFalloff("Rim Falloff", Range(0.01,5) ) = 0.1
+		_RimColor("Rim Color", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "Queue" = "Transparent" }
+
+		Pass
+		{
+			ZWrite On
+			ColorMask 0
+		}
+
+		//ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+        #include "LightingKSP.cginc"
+		#pragma surface surf BlinnPhongSmooth alpha:fade
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float _Fresnel;
+		float _FresnelInvert;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor * _Color;
+
+			float3 normal = float3(0,0,1);
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 fresnel = (_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel)));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+            o.Gloss = 0;
+            o.Specular = 0;
+			o.Normal = normal;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity * color.a * fresnel;
+		}
+
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/AlphaAdditive.shader
@@ -1,1 +1,63 @@
+Shader "KSP/Alpha/Translucent Additive"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGBA)", 2D) = "white" {}
+		_TintColor("TintColor", Color) = (1,1,1,1)
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		//_FresnelInvert("Inverse Fresnel", Range(0,10)) = 0
+	}
 
+
+
+	SubShader
+	{
+		Tags{ "Queue" = "Transparent" }
+
+		ZWrite Off
+			ZTest LEqual
+			Blend SrcAlpha One
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf NoLighting noshadow noambient novertexlights nolightmap
+		#pragma target 3.0
+
+
+		sampler2D _MainTex;
+		float _Fresnel;
+		float _FresnelInvert;
+		float4 _TintColor;
+
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf(Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _TintColor;
+
+			float3 normal = float3(0,0,1);
+			half rim = 1.0 - saturate(dot(normalize(IN.viewDir), normal));
+
+			o.Albedo = 0;
+			//o.Emission = color.rgb*(_FresnelColor+(_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel))));
+			//o.Emission = color.rgb*(pow(1 - rim, _Fresnel))*((pow(rim, _FresnelInvert)));
+			o.Emission = color.rgb * (pow(1 - rim, _Fresnel));
+
+			o.Normal = normal;
+
+
+		}
+
+		ENDCG
+	}
+	Fallback "KSP/Particles/Additive"
+		
+}
+

--- /dev/null
+++ b/Assets/PartTools/Shaders/AlphaSpecular.shader
@@ -1,1 +1,89 @@
+Shader "KSP/Alpha/Translucent Specular"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGBA)", 2D) = "white" {}
+		
+		//_Gloss ("Gloss", Range (0.01, 1)) = 0.5
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
 
+
+		_Opacity("_Opacity", Range(0,1)) = 1
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		[MaterialToggle] _FresnelInvert("Invert Fresnel", Float) = 0
+		_RimFalloff("Rim Falloff", Range(0.01,5) ) = 0.1
+		_RimColor("Rim Color", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "Queue" = "Transparent" }
+
+		Pass
+		{
+			ZWrite On
+			ColorMask 0
+		}
+
+		//ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf BlinnPhongSmooth alpha:fade
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		//float _Gloss;
+
+		float _Opacity;
+		float _Fresnel;
+		float _FresnelInvert;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+
+			float3 normal = float3(0,0,1);
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 fresnel = (_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel)));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+            o.Gloss = color.a;
+            o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity * color.a * fresnel;
+		}
+
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Bumped.shader
@@ -1,1 +1,71 @@
+Shader "KSP/Bumped"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "gray" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Normal = normal;
+            o.Gloss = 0;
+            o.Specular = 0;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/BumpedSpecular.shader
@@ -1,1 +1,74 @@
+Shader "KSP/Bumped Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "gray" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.4
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+		    o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Cutoff.shader
@@ -1,1 +1,51 @@
+Shader "KSP/Alpha/Cutoff"
+{
+    Properties{
+        _Color("Main Color", Color) = (1,1,1,1)
+        _MainTex("Base (RGB) Trans (A)", 2D) = "white" {}
+        _Cutoff("Alpha cutoff", Range(0,1)) = 0.5
+        _RimFalloff("_RimFalloff", Range(0.01,5)) = 0.1
+        _RimColor("_RimColor", Color) = (0,0,0,0)
 
+        _TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+        _BurnColor("Burn Color", Color) = (1,1,1,1)
+    }
+
+        SubShader{
+        Tags{ "Queue" = "AlphaTest" "IgnoreProjector" = "True" "RenderType" = "TransparentCutout" }
+        LOD 300
+
+        CGPROGRAM
+        #pragma surface surf Lambert alphatest:_Cutoff
+
+        sampler2D _MainTex;
+        sampler2D _BumpMap;
+        fixed4 _Color;
+        float _RimFalloff;
+        float4 _RimColor;
+        float4 _TemperatureColor;
+        float4 _BurnColor;
+
+        struct Input {
+        float2 uv_MainTex;
+        float2 uv_Emissive;
+        float3 viewDir;
+        };
+
+    void surf(Input IN, inout SurfaceOutput o)
+    {
+        fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color * _BurnColor;
+        float3 normal = float3(0, 0, 1);
+        half rim = 1.0 - saturate(dot(normalize(IN.viewDir), normal));
+        float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+        emission += _TemperatureColor.rgb * _TemperatureColor.a;
+        o.Albedo = c.rgb;
+        o.Emission = emission;
+        o.Alpha = c.a;
+        o.Normal = normal;
+    }
+    ENDCG
+    }
+
+        FallBack "Legacy Shaders/Transparent/Cutout/Diffuse"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/CutoffBumped.shader
@@ -1,1 +1,53 @@
+Shader "KSP/Alpha/Cutoff Bumped"
+{
+    Properties{
+        _Color("Main Color", Color) = (1,1,1,1)
+        _MainTex("Base (RGB) Trans (A)", 2D) = "white" {}
+        _BumpMap("Normalmap", 2D) = "bump" {}
+        _Cutoff("Alpha cutoff", Range(0,1)) = 0.5
+        _RimFalloff("_RimFalloff", Range(0.01,5)) = 0.1
+        _RimColor("_RimColor", Color) = (0,0,0,0)
 
+        _TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+        _BurnColor("Burn Color", Color) = (1,1,1,1)
+    }
+
+        SubShader{
+        Tags{ "Queue" = "AlphaTest" "IgnoreProjector" = "True" "RenderType" = "TransparentCutout" }
+        LOD 300
+
+        CGPROGRAM
+        #pragma surface surf Lambert alphatest:_Cutoff
+
+        sampler2D _MainTex;
+        sampler2D _BumpMap;
+        fixed4 _Color;
+        float _RimFalloff;
+        float4 _RimColor;
+        float4 _TemperatureColor;
+        float4 _BurnColor;
+
+        struct Input {
+        float2 uv_MainTex;
+        float2 uv_BumpMap;
+        float2 uv_Emissive;
+        float3 viewDir;
+    };
+
+    void surf(Input IN, inout SurfaceOutput o) 
+    {
+        fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color * _BurnColor;
+        float3 normal = float3(0, 0, 1);
+        half rim = 1.0 - saturate(dot(normalize(IN.viewDir), normal));
+        float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+        emission += _TemperatureColor.rgb * _TemperatureColor.a;
+        o.Albedo = c.rgb;
+        o.Emission = emission;
+        o.Alpha = c.a;
+        o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+    }
+    ENDCG
+    }
+
+        FallBack "Legacy Shaders/Transparent/Cutout/Diffuse"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/DepthMask.shader
@@ -1,1 +1,11 @@
-
+Shader "DepthMask" {
+    SubShader {
+    	Tags { "Queue" = "Background" }
+        Lighting Off
+        ZTest LEqual
+        ZWrite On
+        Cull Off
+        ColorMask 0
+        Pass {}
+    }
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Diffuse.shader
@@ -1,1 +1,67 @@
+Shader "KSP/Diffuse"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "gray" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
 
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Normal = normal;
+            o.Gloss = 0;
+            o.Specular = 0;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Emissive.shader
@@ -1,1 +1,73 @@
+Shader "KSP/Emissive/Diffuse"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "gray" {}
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (tex2D(_Emissive, IN.uv_Emissive).rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/EmissiveBumpedSpecular.shader
@@ -1,1 +1,82 @@
+Shader "KSP/Emissive/Bumped Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "gray" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.4
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+		
+
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 emissive = tex2D(_Emissive, (IN.uv_Emissive));
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (emissive.rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+			
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/EmissiveSpecular.shader
@@ -1,1 +1,81 @@
+Shader "KSP/Emissive/Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "gray" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.4
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+		
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+        
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 emissive = tex2D(_Emissive,(IN.uv_Emissive));
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (emissive.rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/InternalBumpedSpecular 1.shader
@@ -1,1 +1,69 @@
+Shader "KSP/InternalSpace/Bumped Specular2"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_LightMap ("_LightMap", 2D) = "gray" {}
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+        //_EdgeColor ("Edge Color", Color) = (1,1,1,1)
+        //_EdgeThreshold ("Edge Threshold", Range(0.01, 3)) = 1
+        _LightColor ("Internal Light Color", Color) = (1,1,1,1)
 
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+        #pragma surface surf BlinnPhongSmooth
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+		sampler2D _LightMap;
+
+        //uniform float _EdgeThreshold;
+        //uniform float4 _EdgeColor;
+        //uniform float _EdgeIntensity;
+        uniform float _AOIntensity;
+        uniform float _Shininess;
+        uniform float4 _SpecularColor;
+        uniform float4 _LightColor;
+        //uniform float4 _LightWrapping;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv2_LightMap;
+			float2 uv_Emissive;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex));
+			float4 lightmap = tex2D(_LightMap, IN.uv2_LightMap);
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+			//float3 edge = pow(lightmap.r, _EdgeThreshold);
+			float3 light1 = lightmap.g * UNITY_LIGHTMODEL_AMBIENT*3;
+			float3 light2 = lightmap.b * _LightColor;
+			float3 AO = lightmap.r + light2;
+
+			o.Albedo = color.rgb * AO;
+			o.Emission = (light1 + light2) * color.rgb * AO;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Alpha = 1;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/InternalBumpedSpecular.shader
@@ -1,1 +1,147 @@
+Shader "KSP/InternalSpace/Bumped Specular"
+{
+	Properties 
+	{
+        [Header(Texture Maps)]
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_LightMap ("_LightMap", 2D) = "gray" {}
 
+        [Header(Specular)]
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+        _Shininess ("Shininess", Range (0.03, 1)) = 0.4
+
+        [Header(Lightmaps and Occlusion)]
+        [Toggle(LMTOGGLE)] _LMTOGGLE("Enable Lightmap", Float) = 0
+        [KeywordEnum(Single Colored, Multi Grayscale)] _LM_Mode("Mode", Float) = 0
+        _LightColor1 ("Internal Light Color 1", Color) = (1,1,1,1)
+        _LightColor2 ("Internal Light Color 2", Color) = (1,1,1,1)
+        _LightAmbient("Ambient Boost", Range(0, 3)) = 1
+
+        _Occlusion("Occlusion Tightness", Range(0, 3)) = 1
+        [Space] //Im in Spaaaaaaaace
+
+        [Header(Fog)]
+        [Toggle(FOGTOGGLE)] _FOGTOGGLE("Enable Fog", Float) = 0
+        _FogColor("Color (RGB) Density (A)", Color) = (0.3, 0.4, 0.7, 0.5)
+        _FogStart("Start", Float) = 1
+        _FogEnd("End", Float) = 10
+
+	}
+	
+	SubShader 
+	{
+        Tags{ "RenderType" = "Opaque" }
+        LOD 200
+		//ZWrite On
+		//ZTest LEqual
+		//Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+
+        #pragma surface surf BlinnPhongSmooth vertex:fogVertex finalcolor:fogColor
+        #pragma shader_feature LMTOGGLE
+        #pragma shader_feature FOGTOGGLE
+        #pragma multi_compile _LM_MODE_MULTI_GREYSCALE _LM_MODE_SINGLE_COLORED
+
+		#pragma target 3.0
+
+
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+        #if LMTOGGLE
+		sampler2D _LightMap;
+        #endif
+
+
+
+        uniform float _Shininess;
+        uniform float4 _SpecularColor;
+
+        #if LMTOGGLE
+        uniform float4 _LightColor1;
+        uniform float4 _LightColor2;
+        uniform float _LightAmbient;
+        uniform float _Occlusion;
+        #endif
+
+        #if FOGTOGGLE
+        uniform float4 _FogColor;
+        uniform float _FogStart;
+        uniform float _FogEnd;
+        #endif
+
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+            float4 color : COLOR;   //vertex color
+
+            #if LMTOGGLE
+			float2 uv2_LightMap;
+            #endif
+
+            #if FOGTOGGLE
+            half fogFactor;
+            #endif
+		};
+
+        void fogVertex(inout appdata_full v, out Input data)
+        {
+            UNITY_INITIALIZE_OUTPUT(Input, data);
+            #if FOGTOGGLE
+            float cameraVertDist = length(mul(UNITY_MATRIX_MV, v.vertex).xyz);
+            data.fogFactor = lerp(saturate((_FogEnd.x - cameraVertDist) / (_FogEnd.x - _FogStart.x)), 1, 1 - _FogColor.a);
+            #endif
+        }
+
+        void fogColor(Input IN, SurfaceOutput o, inout fixed4 c)
+        {
+            #if FOGTOGGLE
+            c.rgb = lerp(_FogColor.rgb, c.rgb, IN.fogFactor);
+            #endif
+        }
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 c = tex2D(_MainTex,(IN.uv_MainTex));
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+            #if LMTOGGLE
+
+            float4 lightmap = tex2D(_LightMap, IN.uv2_LightMap);
+
+            #if _LM_MODE_SINGLE_COLORED
+            float3 light = lightmap.rgb * _LightColor1 + UNITY_LIGHTMODEL_AMBIENT * _LightAmbient * lightmap.rgb;
+            float3 AO = pow(lightmap.a, _Occlusion);
+            float3 finalLight = light * c.rgb * AO;
+            #endif
+
+            #if _LM_MODE_MULTI_GREYSCALE
+            float3 light1 = lightmap.r * _LightColor1;
+            float3 light2 = lightmap.g * _LightColor2;
+			float3 light3 = lightmap.b * UNITY_LIGHTMODEL_AMBIENT * _LightAmbient;
+			float3 AO = lerp(pow(lightmap.a, _Occlusion), 1, light1 + light2);
+            float3 finalLight = (light1 + light2 + light3) * c.rgb * AO;
+            #endif
+
+            #endif
+
+			o.Albedo = c.rgb * step(0.5,IN.color.rgb);
+			o.Gloss = c.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Alpha = 1;
+
+            #if LMTOGGLE
+            o.Albedo *= AO;
+            o.Emission = finalLight;
+            #endif
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/KSPParticle AddSmooth.shader
@@ -1,1 +1,77 @@
+Shader "KSP/Particles/Additive (Soft)" {
+Properties {
+	_MainTex ("Particle Texture", 2D) = "white" {}
+	_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+}
 
+Category {
+	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+	Blend One OneMinusSrcColor
+	ColorMask RGB
+	Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,0) }
+
+	SubShader {
+		Pass {
+		
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_particles
+
+			#include "UnityCG.cginc"
+
+			sampler2D _MainTex;
+			fixed4 _TintColor;
+			
+			struct appdata_t {
+				float4 vertex : POSITION;
+				fixed4 color : COLOR;
+				float2 texcoord : TEXCOORD0;
+			};
+
+			struct v2f {
+				float4 vertex : POSITION;
+				fixed4 color : COLOR;
+				float2 texcoord : TEXCOORD0;
+				#ifdef SOFTPARTICLES_ON
+				float4 projPos : TEXCOORD1;
+				#endif
+			};
+
+			float4 _MainTex_ST;
+			
+			v2f vert (appdata_t v)
+			{
+				v2f o;
+				o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+				#ifdef SOFTPARTICLES_ON
+				o.projPos = ComputeScreenPos (o.vertex);
+				COMPUTE_EYEDEPTH(o.projPos.z);
+				#endif
+				o.color = v.color;
+				o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+				return o;
+			}
+
+			sampler2D _CameraDepthTexture;
+			float _InvFade;
+			
+			fixed4 frag (v2f i) : COLOR
+			{
+				#ifdef SOFTPARTICLES_ON
+				float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+				float partZ = i.projPos.z;
+				float fade = saturate (_InvFade * (sceneZ-partZ));
+				i.color.a *= fade;
+				#endif
+				
+				half4 prev = i.color * tex2D(_MainTex, i.texcoord);
+				prev.rgb *= prev.a;
+				return prev * _TintColor;
+			}
+			ENDCG 
+		}
+	} 
+}
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/LightingKSP.cginc
@@ -1,1 +1,68 @@
+inline fixed4 LightingBlinnPhongSmooth(SurfaceOutput s, fixed3 lightDir, half3 viewDir, fixed atten)
+{
+    s.Normal = normalize(s.Normal);
+    half3 h = normalize(lightDir + viewDir);
 
+    fixed diff = max(0, dot(s.Normal, lightDir));
+
+    float nh = max(0, dot(s.Normal, h));
+    float spec = pow(nh, s.Specular*128.0) * s.Gloss;
+
+    fixed4 c;
+    c.rgb = (s.Albedo * _LightColor0.rgb * diff + _LightColor0.rgb * _SpecColor.rgb * spec) * (atten);
+    c.a = s.Alpha + _LightColor0.a * _SpecColor.a * spec * atten;
+    return c;
+}
+
+
+
+
+inline half4 LightingUnlit(SurfaceOutput s, half3 lightDir, half atten)
+{
+    // half diff = max (0, dot (s.Normal, lightDir));
+
+    half4 c;
+    c.rgb = s.Albedo;
+    c.a = s.Alpha;
+    return c;
+}
+
+
+
+
+inline half4 LightingUnlit_PrePass(SurfaceOutput s, half4 light)
+{
+    half4 c;
+    c.rgb = s.Albedo;
+    c.a = s.Alpha;
+    return c;
+}
+
+
+
+
+fixed4 LightingNoLighting(SurfaceOutput s, fixed3 lightDir, fixed atten) { return fixed4(0, 0, 0, 0); }
+
+
+
+
+
+float4 _Color;
+half _LightBoost;
+half4 LightingLightWrapped(SurfaceOutput s, half3 lightDir, half3 viewDir, half atten) {
+    float3 w = _Color.rgb*0.5;
+    half3 NdotL = dot(s.Normal, lightDir);
+
+    //Specular term
+    half3 h = normalize(lightDir + viewDir);
+    s.Normal = normalize(s.Normal);
+    float NdotH = dot(s.Normal, h);
+    float spec = pow(max(NdotH, 0), s.Specular * 128.0) * s.Gloss;
+    fixed3 specColor = _SpecColor.rgb * _LightColor0.rgb;
+
+    half3 diff = NdotL * (1 - w) + w;
+    half4 c;
+    c.rgb = ((s.Albedo * _LightColor0.rgb * diff) + (specColor * spec)) * (atten * _LightBoost);
+    c.a = s.Alpha + (_LightColor0.a * _SpecColor.a * spec * atten);
+    return c;
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/LightwrapSpecular.shader
@@ -1,1 +1,68 @@
+Shader "KSP/Lightwrapped/Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_Color ("Light Wrapping", Color) = (0,0,0,0)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.4
+		_LightBoost("Light Boost", Range(1, 2)) = 1.0
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
 
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf LightWrapped
+		#pragma target 3.0
+
+
+		
+		
+		half _Shininess;
+
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float3 viewDir;
+		};
+		
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex));
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a * _Shininess;
+			o.Specular = color.a * _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/PBR/KSP_Standard_Bumped.shader
@@ -1,1 +1,171 @@
+Shader "KSP/Standard_Bumped"
+{
+    Properties
+    {
+        [Header(Texture Maps)]
+        _MainTex("Map A (RGB albedo, A smoothness)", 2D) = "white" {}
+        _MapB("Map B (R metalness, G emission1, B emission2, A occlusion)", 2D) = "white" {}
+        _MapC("Map C (RGBA color mask)", 2D) = "black" {}
+        [KeywordEnum(UV1, UV2)] _CUV("_MapC UV set", Float) = 0
+        [Space]
+        _BumpMap("BumpMap", 2D) = "bump" {}
 
+        [Header(ReColor (RGB_Albedo A_Metallic))]
+        _Color1("Mask1", Color) = (1,1,1,0)
+        //[Toggle]_Metallic1("Mask1 Metallic", Float) = 0
+        //[Space]
+        _Color2("Mask2", Color) = (1,1,1,0)
+        //[Toggle]_Metallic2("Mask2 Metallic", Float) = 0
+        //[Space]
+        _Color3("Mask3", Color) = (1,1,1,0)
+        //[Toggle]_Metallic3("Mask3 Metallic", Float) = 0
+        //[Space]
+        _Color4("Mask4", Color) = (1,1,1,0)
+        //[Toggle]_Metallic4("Mask4 Metallic", Float) = 0
+        [Space]
+        _MetallicGloss("_MetallicGloss", Range(0,1)) = 0.25
+
+        [Header(Emissive)]
+        _EmissiveColorLow1("_EmissiveColorLow1", Color) = (0,0,0,1)
+        _EmissiveColorHigh1("_EmissiveColorHigh1", Color) = (0,0,0,1)
+        [Space]
+        _EmissiveColorLow2("_EmissiveColorLow2", Color) = (0,0,0,1)
+        _EmissiveColorHigh2("_EmissiveColorHigh2", Color) = (0,0,0,1)
+       
+        [Header(Other)]
+        //[Toggle(ENABLE_VC)] _VC("Vertex Colors enable", Int) = 0
+        //[Toggle(ENABLE_VCAO)] _VCAO("Vertex Color R = Occlusion", Int) = 0
+        [KeywordEnum(none, RGBA, Occlusion)] _VCOL("Vertex Color", Float) = 0
+
+        _Opacity("Opacity", Range(0,1)) = 1
+
+        [HideInInspector]_RimFalloff("Rim highlight falloff", Range(0.01,5)) = 0.1
+        [HideInInspector]_RimColor("Rim highlight color", Color) = (0,0,0,0)
+        [HideInInspector]_TemperatureColor("Heat color", Color) = (0,0,0,0)
+        [HideInInspector]_BurnColor("Burn color", Color) = (1,1,1,1)
+
+    }
+
+        SubShader
+    {
+        Tags{ "RenderType" = "Opaque" }
+        ZWrite On
+        ZTest LEqual
+        Blend SrcAlpha OneMinusSrcAlpha
+
+        CGPROGRAM
+
+        #pragma surface surf Standard keepalpha
+        #pragma target 3.0
+        #pragma multi_compile _CUV_UV1 _CUV_UV2
+        #pragma multi_compile _VCOL_NONE _VCOL_RGBA _VCOL_OCCLUSION
+
+
+        //#pragma shader_feature ENABLE_VCAO
+        //#pragma shader_feature ENABLE_VC
+
+
+        sampler2D _MainTex;
+        sampler2D _MapB;
+        sampler2D _MapC;
+        sampler2D _BumpMap;
+
+        float4 _EmissiveColorLow1;
+        float4 _EmissiveColorHigh1;
+        float4 _EmissiveColorLow2;
+        float4 _EmissiveColorHigh2;
+
+        float _Opacity;
+        float _RimFalloff;
+        float4 _RimColor;
+        float4 _TemperatureColor;
+        float4 _BurnColor;
+        float4 _Color1;
+        float4 _Color2;
+        float4 _Color3;
+        float4 _Color4;
+        //float _Metallic1;
+        //float _Metallic2;
+        //float _Metallic3;
+        //float _Metallic4;
+        float _MetallicGloss;
+
+        struct Input
+        {
+            float2 uv_MainTex;
+            float2 uv_MapB;
+            #if _CUV_UV1
+            float2 uv_MapC;
+            #endif
+            #if _CUV_UV2
+            float2 uv2_MapC;
+            #endif
+
+            float2 uv_BumpMap;
+            float3 viewDir;
+            #if _VCOL_RGBA
+            float4 color : COLOR;   //vertex color
+            #endif
+            #if _VCOL_OCCLUSION
+            float4 color : COLOR;   //vertex color
+            #endif
+        };
+
+        void surf(Input IN, inout SurfaceOutputStandard o)
+        {
+            float4 mainSample = tex2D(_MainTex, (IN.uv_MainTex));
+            float4 mapBSample = tex2D(_MapB, (IN.uv_MapB));
+            #if _CUV_UV1
+            float4 mapCSample = tex2D(_MapC, (IN.uv_MapC));
+            #endif
+            #if _CUV_UV2
+            float4 mapCSample = tex2D(_MapC, (IN.uv2_MapC));
+            #endif
+            float3 albedo = mainSample.rgb * _BurnColor.rgb * lerp(1, _Color1, mapCSample.r) * lerp(1, _Color2, mapCSample.g) * lerp(1, _Color3, mapCSample.b) * lerp(1, _Color4, mapCSample.a);
+            float metallic = mapCSample.r * _Color1.a + mapCSample.g * _Color2.a + mapCSample.b * _Color3.a + mapCSample.a * _Color4.a;
+            float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+            half rim = 1.0 - saturate(dot(normalize(IN.viewDir), normal));
+
+            float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+            emission += _TemperatureColor.rgb * _TemperatureColor.a;
+            emission += lerp(_EmissiveColorLow1.rgb, _EmissiveColorHigh1.rgb, mapBSample.g)*mapBSample.g + lerp(_EmissiveColorLow2.rgb, _EmissiveColorHigh2.rgb, mapBSample.b)*mapBSample.b;
+
+            o.Albedo = albedo;
+            o.Emission = emission.rgb;
+            o.Smoothness = saturate(mainSample.a + _MetallicGloss * metallic) * _BurnColor.r;
+            o.Metallic = saturate(mapBSample.r + metallic);
+            o.Occlusion = mapBSample.a;
+            o.Normal = normal;
+
+            o.Emission *= _Opacity;
+            o.Alpha = _Opacity;
+
+
+            #if _VCOL_RGBA
+                o.Albedo *= IN.color.rgb;
+                o.Occlusion *= IN.color.a;           
+            #endif
+            #if _VCOL_OCCLUSION
+                o.Smoothness *= IN.color.r;
+                o.Occlusion *= IN.color.r;
+            #endif
+
+//                o.Albedo *= float3(1, 0, 0);
+
+ //           #if ENABLE_VC
+ //               #if !ENABLE_VCAO
+ //               o.Albedo *= IN.color.rgb;
+  //              o.Occlusion *= IN.color.a;
+  //              #endif
+//
+ //               #if ENABLE_VCAO
+ //               o.Smoothness *= IN.color.r;
+ //               o.Occlusion *= IN.color.r;
+ //               #endif
+ //           #endif
+        }
+    ENDCG
+    }
+    Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/ParticleAdd.shader
@@ -1,1 +1,115 @@
+Shader "KSP/Particles/Additive"
+{
+	Properties
+	{
+		_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+		_MainTex ("Particle Texture", 2D) = "white" {}
+		_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	}
 
+	Category
+	{
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		Blend SrcAlpha One
+		AlphaTest Greater .01
+		ColorMask RGB
+		Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,0) }
+		BindChannels {
+			Bind "Color", color
+			Bind "Vertex", vertex
+			Bind "TexCoord", texcoord
+	}
+	
+		// ---- Fragment program cards
+		SubShader
+		{
+			Pass
+			{
+		
+				CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+				#pragma fragmentoption ARB_precision_hint_fastest
+				#pragma multi_compile_particles
+
+				#include "UnityCG.cginc"
+
+				sampler2D _MainTex;
+				fixed4 _TintColor;
+			
+				struct appdata_t
+				{
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+				};
+
+				struct v2f
+				{
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+					#ifdef SOFTPARTICLES_ON
+					float4 projPos : TEXCOORD1;
+					#endif
+				};
+			
+				float4 _MainTex_ST;
+
+				v2f vert (appdata_t v)
+				{
+					v2f o;
+					o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+					#ifdef SOFTPARTICLES_ON
+					o.projPos = ComputeScreenPos (o.vertex);
+					COMPUTE_EYEDEPTH(o.projPos.z);
+					#endif
+					o.color = v.color;
+					o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+					return o;
+				}
+
+				sampler2D _CameraDepthTexture;
+				float _InvFade;
+			
+				fixed4 frag (v2f i) : COLOR
+				{
+					#ifdef SOFTPARTICLES_ON
+					float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+					float partZ = i.projPos.z;
+					float fade = saturate (_InvFade * (sceneZ-partZ));
+					i.color.a *= fade;
+					#endif
+				
+					return 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord);
+				}
+				ENDCG 
+			}
+		} 	
+	
+		// ---- Dual texture cards
+		SubShader {
+			Pass {
+				SetTexture [_MainTex] {
+					constantColor [_TintColor]
+					combine constant * primary
+				}
+				SetTexture [_MainTex] {
+					combine texture * previous DOUBLE
+				}
+			}
+		}
+	
+		// ---- Single texture cards (does not do color tint)
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex] { 
+					combine texture * primary 
+				}
+			}
+		}
+	}
+}
+

--- /dev/null
+++ b/Assets/PartTools/Shaders/ParticleAdditiveFresnel.shader
@@ -1,1 +1,86 @@
+// Shader created with Shader Forge v1.18 
+// Shader Forge (c) Neat Corporation / Joachim Holmer - http://www.acegikmo.com/shaderforge/
+// Note: Manually altering this data may prevent you from opening it in Shader Forge
+/*SF_DATA;ver:1.18;sub:START;pass:START;ps:flbk:,iptp:0,cusa:False,bamd:0,lico:1,lgpr:1,limd:0,spmd:1,trmd:0,grmd:0,uamb:True,mssp:True,bkdf:False,hqlp:False,rprd:False,enco:False,rmgx:True,rpth:0,hqsc:True,nrmq:1,nrsp:0,vomd:0,spxs:False,tesm:0,culm:2,bsrc:0,bdst:0,dpts:2,wrdp:False,dith:0,rfrpo:True,rfrpn:Refraction,coma:15,ufog:True,aust:True,igpj:True,qofs:0,qpre:3,rntp:2,fgom:False,fgoc:True,fgod:False,fgor:False,fgmd:0,fgcr:0,fgcg:0,fgcb:0,fgca:1,fgde:0.01,fgrn:0,fgrf:300,stcl:False,stva:128,stmr:255,stmw:255,stcp:6,stps:0,stfa:0,stfz:0,ofsf:0,ofsu:0,f2p0:False;n:type:ShaderForge.SFN_Final,id:4795,x:32987,y:32660,varname:node_4795,prsc:2|emission-1451-OUT;n:type:ShaderForge.SFN_Tex2d,id:6074,x:32235,y:32601,ptovrint:False,ptlb:MainTex,ptin:_MainTex,varname:_MainTex,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,ntxv:0,isnm:False;n:type:ShaderForge.SFN_Multiply,id:2393,x:32495,y:32793,varname:node_2393,prsc:2|A-6074-RGB,B-2053-RGB,C-797-RGB,D-9248-OUT,E-6554-OUT;n:type:ShaderForge.SFN_VertexColor,id:2053,x:32235,y:32772,varname:node_2053,prsc:2;n:type:ShaderForge.SFN_Color,id:797,x:32235,y:32930,ptovrint:True,ptlb:Color,ptin:_TintColor,varname:_TintColor,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,c1:0.5,c2:0.5,c3:0.5,c4:1;n:type:ShaderForge.SFN_Vector1,id:9248,x:32235,y:33081,varname:node_9248,prsc:2,v1:2;n:type:ShaderForge.SFN_Fresnel,id:3878,x:32179,y:33234,varname:node_3878,prsc:2|EXP-8837-OUT;n:type:ShaderForge.SFN_Slider,id:8837,x:31808,y:33254,ptovrint:False,ptlb:Fresnel Exponent,ptin:_FresnelExponent,varname:node_8837,prsc:2,glob:False,taghide:False,taghdr:False,tagprd:False,tagnsco:False,tagnrm:False,min:1,cur:2.944261,max:4;n:type:ShaderForge.SFN_Subtract,id:6554,x:32506,y:33094,varname:node_6554,prsc:2|A-4911-OUT,B-3878-OUT;n:type:ShaderForge.SFN_Vector1,id:4911,x:32235,y:33139,varname:node_4911,prsc:2,v1:1;n:type:ShaderForge.SFN_Multiply,id:1451,x:32673,y:32885,varname:node_1451,prsc:2|A-2393-OUT,B-797-A;proporder:6074-797-8837;pass:END;sub:END;*/
 
+Shader "Shader Forge/ParticleAdditiveFresnel" {
+    Properties {
+        _MainTex ("MainTex", 2D) = "white" {}
+        _TintColor ("Color", Color) = (0.5,0.5,0.5,1)
+        _FresnelExponent ("Fresnel Exponent", Range(1, 4)) = 2.944261
+    }
+    SubShader {
+        Tags {
+            "IgnoreProjector"="True"
+            "Queue"="Transparent"
+            "RenderType"="Transparent"
+        }
+        Pass {
+            Name "FORWARD"
+            Tags {
+                "LightMode"="ForwardBase"
+            }
+            Blend One One
+            Cull Off
+            ZWrite Off
+            
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #define UNITY_PASS_FORWARDBASE
+            #include "UnityCG.cginc"
+            #pragma multi_compile_fwdbase
+            #pragma multi_compile_fog
+            #pragma exclude_renderers gles3 metal d3d11_9x xbox360 xboxone ps3 ps4 psp2 
+            #pragma target 3.0
+            uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
+            uniform float4 _TintColor;
+            uniform float _FresnelExponent;
+            struct VertexInput {
+                float4 vertex : POSITION;
+                float3 normal : NORMAL;
+                float2 texcoord0 : TEXCOORD0;
+                float4 vertexColor : COLOR;
+            };
+            struct VertexOutput {
+                float4 pos : SV_POSITION;
+                float2 uv0 : TEXCOORD0;
+                float4 posWorld : TEXCOORD1;
+                float3 normalDir : TEXCOORD2;
+                float4 vertexColor : COLOR;
+                UNITY_FOG_COORDS(3)
+            };
+            VertexOutput vert (VertexInput v) {
+                VertexOutput o = (VertexOutput)0;
+                o.uv0 = v.texcoord0;
+                o.vertexColor = v.vertexColor;
+                o.normalDir = UnityObjectToWorldNormal(v.normal);
+                o.posWorld = mul(_Object2World, v.vertex);
+                o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
+                UNITY_TRANSFER_FOG(o,o.pos);
+                return o;
+            }
+            float4 frag(VertexOutput i, float facing : VFACE) : COLOR {
+                float isFrontFace = ( facing >= 0 ? 1 : 0 );
+                float faceSign = ( facing >= 0 ? 1 : -1 );
+                i.normalDir = normalize(i.normalDir);
+                i.normalDir *= faceSign;
+/////// Vectors:
+                float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);
+                float3 normalDirection = i.normalDir;
+////// Lighting:
+////// Emissive:
+                float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));
+                float3 emissive = ((_MainTex_var.rgb*i.vertexColor.rgb*_TintColor.rgb*2.0*(1.0-pow(1.0-max(0,dot(normalDirection, viewDirection)),_FresnelExponent)))*_TintColor.a);
+                float3 finalColor = emissive;
+                fixed4 finalRGBA = fixed4(finalColor,1);
+                UNITY_APPLY_FOG_COLOR(i.fogCoord, finalRGBA, fixed4(0,0,0,1));
+                return finalRGBA;
+            }
+            ENDCG
+        }
+    }
+    FallBack "Diffuse"
+    CustomEditor "ShaderForgeMaterialInspector"
+}
+

--- /dev/null
+++ b/Assets/PartTools/Shaders/ParticleAlpha.shader
@@ -1,1 +1,118 @@
+Shader "KSP/Particles/Alpha Blended"
+{
+	Properties
+	{
+		_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+		_MainTex ("Particle Texture", 2D) = "white" {}
+		_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	}
 
+	Category
+	{
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		Blend SrcAlpha OneMinusSrcAlpha
+		AlphaTest Greater .01
+		ColorMask RGB
+		Cull Off Lighting Off ZWrite Off
+		BindChannels {
+			Bind "Color", color
+			Bind "Vertex", vertex
+			Bind "TexCoord", texcoord
+	}
+	
+		// ---- Fragment program cards
+		SubShader
+		{
+			Pass
+			{
+		
+				CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+				#pragma fragmentoption ARB_precision_hint_fastest
+				#pragma multi_compile_particles
+			
+				#include "UnityCG.cginc"
+
+				sampler2D _MainTex;
+				fixed4 _TintColor;
+			
+				struct appdata_t {
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+				};
+
+				struct v2f {
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+					#ifdef SOFTPARTICLES_ON
+					float4 projPos : TEXCOORD1;
+					#endif
+				};
+			
+				float4 _MainTex_ST;
+
+				v2f vert (appdata_t v)
+				{
+					v2f o;
+					o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+					#ifdef SOFTPARTICLES_ON
+					o.projPos = ComputeScreenPos (o.vertex);
+					COMPUTE_EYEDEPTH(o.projPos.z);
+					#endif
+					o.color = v.color;
+					o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+					return o;
+				}
+
+				sampler2D _CameraDepthTexture;
+				float _InvFade;
+			
+				fixed4 frag (v2f i) : COLOR
+				{
+					#ifdef SOFTPARTICLES_ON
+					float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+					float partZ = i.projPos.z;
+					float fade = saturate (_InvFade * (sceneZ-partZ));
+					i.color.a *= fade;
+					#endif
+				
+					return 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord);
+				}
+				ENDCG 
+			}
+		} 	
+	
+		// ---- Dual texture cards
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex]
+				{
+					constantColor [_TintColor]
+					combine constant * primary
+				}
+				SetTexture [_MainTex]
+				{
+					combine texture * previous DOUBLE
+				}
+			}
+		}
+	
+		// ---- Single texture cards (does not do color tint)
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex]
+				{
+					combine texture * primary
+				}
+			}
+		}
+	}
+}
+

--- /dev/null
+++ b/Assets/PartTools/Shaders/ScrollingUnlit.shader
@@ -1,1 +1,109 @@
+Shader "KSP/FX/ScrollingUnlit"
+{
+	Properties 
+	{
+        _MainTex("MainTex (RGB Alpha(A))", 2D) = "white" {}
+		_Color("Color (RGB Alpha(A))", Color) = (1,1,1,1)
+        [Space]
+		_SpeedX("Scroll Speed X", Float) = 0
+        _SpeedY("Scroll Speed Y", Float) = 1
+        [Space]
+        [KeywordEnum(UV, Screen Space)] _TexCoord("Texture Coordinates", Float) = 0
+        _TileX("ScreenSpace Tiling X", Float) = 1
+        _TileY("ScreenSpace Tiling Y", Float) = 1
+        [Space]
+        [KeywordEnum(Off, Outer, Inner)] _Fresnel("Fresnel Fade", Float) = 0
+        _FresnelPow("Fresnel Falloff", Range(0,5)) = 1
+        _FresnelInt("Fresnel Intensity", Range(0,1)) = 1
+	}
+	
+	SubShader 
+	{
+		Tags{ "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
 
+		Pass
+		{
+			ZWrite On
+			ColorMask 0
+		}
+
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf Unlit noforwardadd noshadow noambient novertexlights alpha:fade
+		#pragma target 3.0
+        #pragma multi_compile _TEXCOORD_UV _TEXCOORD_SCREEN_SPACE
+        #pragma multi_compile _FRESNEL_OFF _FRESNEL_OUTER _FRESNEL_INNER
+
+
+		sampler2D _MainTex;
+
+        float _SpeedX;
+        float _SpeedY;
+        float _TileX;
+        float _TileY;
+
+        #if !_FRESNEL_OFF
+        float _FresnelPow;
+        float _FresnelInt;
+        #endif
+
+        struct Input
+		{
+            #if _TEXCOORD_UV
+            float2 uv_MainTex;
+            #endif
+
+            #if _TEXCOORD_SCREEN_SPACE
+            float4 screenPos;
+            #endif
+
+            #if !_FRESNEL_OFF
+            float3 viewDir;
+            #endif
+        };
+
+
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+            #if _TEXCOORD_SCREEN_SPACE
+            float2 screenUV = IN.screenPos.xy / IN.screenPos.w;
+            screenUV.x += _Time * _SpeedX;
+            screenUV.y += _Time * _SpeedY;
+            screenUV.x *= _TileX;
+            screenUV.y *= _TileY;
+            float4 c = tex2D(_MainTex, (screenUV));
+            #endif
+
+
+            #if _TEXCOORD_UV
+            fixed2 scrollUV = IN.uv_MainTex ;            
+            fixed xScrollValue = _SpeedX * _Time.x;
+            fixed yScrollValue = _SpeedY * _Time.x;
+            scrollUV += fixed2(xScrollValue, yScrollValue);
+            half4 c = tex2D(_MainTex, scrollUV);
+            #endif
+		    float3 normal = float3(0,0,1);
+
+			o.Albedo = c.rgb * _Color.rgb;
+			o.Normal = normal;
+			o.Alpha = c.a * _Color.a;
+
+            #if _FRESNEL_INNER
+            half rim = 1.0 - saturate(dot(normalize(IN.viewDir), float3(0, 0, 1)));
+            o.Alpha *= lerp(pow(rim, _FresnelPow), 1, 1- _FresnelInt);
+            #endif
+            #if _FRESNEL_OUTER
+            half rim = 1.0 - saturate(dot(normalize(IN.viewDir), float3(0, 0, 1)));
+            o.Alpha *= lerp(pow(1 - rim, _FresnelPow), 1, 1 - _FresnelInt);
+            #endif
+
+		}
+		ENDCG
+	}
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/SolidColorAlpha.shader
@@ -1,1 +1,49 @@
+Shader "Solid Color (Alpha)" {
+	Properties 
+	{
+		_Color ("Color", Color) = (0.5, 0.5, 0.5, 0.5)
+	}
+	SubShader
+	{
+		
+		ZWrite On
+        GrabPass { }
+		Pass
+		{
+			Fog { Mode Off }
+			Blend SrcAlpha OneMinusSrcAlpha
 
+			CGPROGRAM
+
+			#pragma vertex vert
+			#pragma fragment frag
+	
+			fixed4 _Color;
+			sampler2D _GrabTexture;
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+			};
+			struct v2f
+			{
+				float4 pos : SV_POSITION;
+				float4 uv : TEXCOORD0;
+			};
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
+				o.uv = o.pos;
+				return o;
+			}
+			half4 frag(v2f i) : COLOR
+			{
+				float2 coord = 0.5 + 0.5 * i.uv.xy / i.uv.w;
+				fixed4 tex = tex2D(_GrabTexture, float2(coord.x, 1 - coord.y));
+				return fixed4(lerp(tex.rgb, _Color.rgb, _Color.a), 1);
+			}
+			ENDCG
+		}
+	}
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Specular.shader
@@ -1,1 +1,71 @@
+Shader "KSP/Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "gray" {}
+		_Color ("MainColor", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf BlinnPhongSmooth keepalpha
+		#pragma target 3.0
+
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/SpecularBumpTransparent.shader
@@ -1,1 +1,89 @@
+Shader "KSP/Bumped Specular (Transparent)"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		
+		_MainColor ("Main Color", Color) = (1,1,1,1)
+		
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		[MaterialToggle] _FresnelInvert("Invert Fresnel", Float) = 0
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
+		
+		Pass 
+		{
+			ZWrite On
+			ColorMask 0
+		}
+		
+		//ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf BlinnPhongSmooth alpha:fade
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+		
+		float4 _MainColor;
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		float _Fresnel;
+		float _FresnelInvert;
+		float _Brightness;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _MainColor * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+			
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 fresnel = (_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel)));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+            o.Gloss = color.a;
+            o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity * color.a * fresnel;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/SpecularTransparent.shader
@@ -1,1 +1,82 @@
+Shader "KSP/Specular (Transparent)"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_MainColor ("Main Color", Color) = (1,1,1,1)
+		
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		[MaterialToggle] _FresnelInvert("Invert Fresnel", Float) = 0
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
+		
+		Pass 
+		{
+			ZWrite On
+			ColorMask 0
+		}
+		
+		//ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+		
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf BlinnPhongSmooth alpha:fade
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		
+		float4 _MainColor;
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		float _Fresnel;
+		float _FresnelInvert;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float3 viewDir;
+			float3 worldNormal;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _MainColor * _BurnColor;
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), IN.worldNormal));
+
+			float3 fresnel = (_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel)));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+            o.Gloss = color.a;
+            o.Specular = _Shininess;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity * color.a * fresnel;
+		}
+		ENDCG
+		
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/Unlit.shader
@@ -1,1 +1,67 @@
+Shader "KSP/Unlit"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "white" {}
+		_Color("Color", Color) = (1,1,1,1)
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+        #include "LightingKSP.cginc"
+		#pragma surface surf Unlit noforwardadd noshadow noambient novertexlights keepalpha
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+
+
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = _Color.rgb * color.rgb + emission;
+			//o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/UnlitColor.shader
@@ -1,1 +1,38 @@
+Shader "KSP/UnlitColor"
+{
+	Properties 
+	{
+		_Color("Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+        Tags{ "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
 
+        Pass
+        {
+            ZWrite On
+            ColorMask 0
+        }
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+        #include "LightingKSP.cginc"
+		#pragma surface surf Unlit noforwardadd noshadow noambient novertexlights alpha:fade
+		#pragma target 3.0
+        struct Input
+        {
+            float4 color : COLOR; //vertex color
+        };
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			o.Albedo = _Color.rgb * IN.color.rgb;
+			o.Alpha = _Color.a * IN.color.a;
+		}
+		ENDCG
+	}
+	Fallback "Unlit/Color"
+}

--- /dev/null
+++ b/Assets/PartTools/Shaders/UnlitTransparent.shader
@@ -1,1 +1,77 @@
+Shader "KSP/Alpha/Unlit Transparent"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGB Alpha(A))", 2D) = "white" {}
+		_Color("Color", Color) = (1,1,1,1)
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_Fresnel("Fresnel", Range(0,10)) = 0
+		[MaterialToggle] _FresnelInvert("Invert Fresnel", Float) = 0
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags{ "Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent" }
+
+		Pass
+		{
+			ZWrite On
+			ColorMask 0
+		}
+
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+        #include "LightingKSP.cginc"
+		#pragma surface surf Unlit noforwardadd noshadow noambient novertexlights alpha:fade
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _Fresnel;
+		float _FresnelInvert;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+
+
+        struct Input
+		{
+            float2 uv_MainTex;
+			float3 viewDir;
+        };
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+			float alpha = _Color.a * color.a;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+			float3 fresnel = (_FresnelInvert + (pow(1 - rim, _Fresnel))) * (1 - _FresnelInvert + 1 - (pow(1 - rim, _Fresnel)));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = _Color.rgb * color.rgb + emission;
+			//o.Emission = emission * _Opacity;
+			o.Normal = normal;
+			o.Alpha = _Color.a * color.a * _Opacity * fresnel;
+		}
+		ENDCG
+	}
+	Fallback "Standard"
+}

 Binary files /dev/null and b/Assets/Plugins/KSPAssets/KSPAssetCompiler.dll differ
 Binary files /dev/null and b/Assets/Plugins/KSPAssets/KSPAssets.dll differ
--- /dev/null
+++ b/Assets/Plugins/KSPAssets/ReadMe.txt
@@ -1,1 +1,1 @@
-
+KSPAssets ReadMe v1

 Binary files /dev/null and b/Assets/SquadCore/KSPedia/Backgrounds/BackgroundBlack.png differ
 Binary files /dev/null and b/Assets/SquadCore/KSPedia/Backgrounds/BackgroundBlue.png differ
 Binary files /dev/null and b/Assets/SquadCore/KSPedia/Backgrounds/BackgroundBlueGrid.png differ
 Binary files /dev/null and b/Assets/SquadCore/KSPedia/Backgrounds/BackgroundKSC.png differ
 Binary files /dev/null and b/Assets/SquadCore/KSPedia/Backgrounds/BackgroundWhite.png differ
--- /dev/null
+++ b/Assets/SquadCore/Shaders/Alpha.shader
@@ -1,1 +1,65 @@
+Shader "KSP/Alpha/Translucent"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGBA)", 2D) = "white" {}
 
+		_RimFalloff("Rim Falloff", Range(0.01,5) ) = 0.1
+		_RimColor("Rim Color", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "Queue" = "Transparent" }
+
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf Lambert alpha
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+
+			float3 normal = float3(0,0,1);
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Alpha = color.a;
+		}
+
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/AlphaSpecular.shader
@@ -1,1 +1,73 @@
+Shader "KSP/Alpha/Translucent Specular"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGBA)", 2D) = "white" {}
+		
+		_Gloss ("Gloss", Range (0.01, 1)) = 0.5
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
 
+		_RimFalloff("Rim Falloff", Range(0.01,5) ) = 0.1
+		_RimColor("Rim Color", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "Queue" = "Transparent" }
+
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong alpha
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		float _Gloss;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+
+			float3 normal = float3(0,0,1);
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Alpha = color.a;
+		}
+
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Bumped.shader
@@ -1,1 +1,69 @@
+Shader "KSP/Bumped"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf Lambert
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Bumped Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/BumpedSpecular.shader
@@ -1,1 +1,72 @@
+Shader "KSP/Bumped Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Bumped Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Cutoff.shader
@@ -1,1 +1,67 @@
+Shader "KSP/Alpha/Cutoff"
+{
+	Properties 
+	{		
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_MainTex("_MainTex (RGB Alpha(A))", 2D) = "white" {}
+	    _Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags {"Queue"="AlphaTest" "IgnoreProjector"="True" "RenderType"="TransparentCutout"}
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+		AlphaTest GEqual [_Cutoff]
+				
+		CGPROGRAM
+
+		#pragma surface surf Lambert alphatest:_Cutoff
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Alpha = color.a;
+		}
+		ENDCG
+	}
+	Fallback "Transparent/Cutout/VertexLit"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/CutoffBumped.shader
@@ -1,1 +1,66 @@
+Shader "KSP/Alpha/Cutoff Bumped"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB Alpha(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+	    _Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
 
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+		AlphaTest GEqual [_Cutoff]
+		
+		CGPROGRAM
+
+		#pragma surface surf Lambert
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Alpha = color.a;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Diffuse.shader
@@ -1,1 +1,64 @@
+Shader "KSP/Diffuse"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "white" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf Lambert
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Emissive.shader
@@ -1,1 +1,70 @@
+Shader "KSP/Emissive/Diffuse"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "white" {}
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf Lambert
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (tex2D(_Emissive, IN.uv_Emissive).rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/EmissiveBumpedSpecular.shader
@@ -1,1 +1,79 @@
+Shader "KSP/Emissive/Bumped Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (tex2D(_Emissive, IN.uv_Emissive).rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+			
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Self-Illumin/Bumped Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/EmissiveSpecular.shader
@@ -1,1 +1,76 @@
+Shader "KSP/Emissive/Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
 
+		_EmissiveColor("_EmissiveColor", Color) = (0,0,0,1)
+		_Emissive("_Emissive", 2D) = "white" {}
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
+
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		float4 _EmissiveColor;
+		sampler2D _Emissive;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+			emission += (tex2D(_Emissive, IN.uv_Emissive).rgb * _EmissiveColor.rgb) * _EmissiveColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Self-Illumin/Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/KSPParticle AddSmooth.shader
@@ -1,1 +1,77 @@
+Shader "KSP/Particles/Additive (Soft)" {
+Properties {
+	_MainTex ("Particle Texture", 2D) = "white" {}
+	_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+}
 
+Category {
+	Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+	Blend One OneMinusSrcColor
+	ColorMask RGB
+	Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,0) }
+
+	SubShader {
+		Pass {
+		
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_particles
+
+			#include "UnityCG.cginc"
+
+			sampler2D _MainTex;
+			fixed4 _TintColor;
+			
+			struct appdata_t {
+				float4 vertex : POSITION;
+				fixed4 color : COLOR;
+				float2 texcoord : TEXCOORD0;
+			};
+
+			struct v2f {
+				float4 vertex : POSITION;
+				fixed4 color : COLOR;
+				float2 texcoord : TEXCOORD0;
+				#ifdef SOFTPARTICLES_ON
+				float4 projPos : TEXCOORD1;
+				#endif
+			};
+
+			float4 _MainTex_ST;
+			
+			v2f vert (appdata_t v)
+			{
+				v2f o;
+				o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+				#ifdef SOFTPARTICLES_ON
+				o.projPos = ComputeScreenPos (o.vertex);
+				COMPUTE_EYEDEPTH(o.projPos.z);
+				#endif
+				o.color = v.color;
+				o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+				return o;
+			}
+
+			sampler2D _CameraDepthTexture;
+			float _InvFade;
+			
+			fixed4 frag (v2f i) : COLOR
+			{
+				#ifdef SOFTPARTICLES_ON
+				float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+				float partZ = i.projPos.z;
+				float fade = saturate (_InvFade * (sceneZ-partZ));
+				i.color.a *= fade;
+				#endif
+				
+				half4 prev = i.color * tex2D(_MainTex, i.texcoord);
+				prev.rgb *= prev.a;
+				return prev * _TintColor;
+			}
+			ENDCG 
+		}
+	} 
+}
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/ParticleAdd.shader
@@ -1,1 +1,115 @@
+Shader "KSP/Particles/Additive"
+{
+	Properties
+	{
+		_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+		_MainTex ("Particle Texture", 2D) = "white" {}
+		_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	}
 
+	Category
+	{
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		Blend SrcAlpha One
+		AlphaTest Greater .01
+		ColorMask RGB
+		Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,0) }
+		BindChannels {
+			Bind "Color", color
+			Bind "Vertex", vertex
+			Bind "TexCoord", texcoord
+	}
+	
+		// ---- Fragment program cards
+		SubShader
+		{
+			Pass
+			{
+		
+				CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+				#pragma fragmentoption ARB_precision_hint_fastest
+				#pragma multi_compile_particles
+
+				#include "UnityCG.cginc"
+
+				sampler2D _MainTex;
+				fixed4 _TintColor;
+			
+				struct appdata_t
+				{
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+				};
+
+				struct v2f
+				{
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+					#ifdef SOFTPARTICLES_ON
+					float4 projPos : TEXCOORD1;
+					#endif
+				};
+			
+				float4 _MainTex_ST;
+
+				v2f vert (appdata_t v)
+				{
+					v2f o;
+					o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+					#ifdef SOFTPARTICLES_ON
+					o.projPos = ComputeScreenPos (o.vertex);
+					COMPUTE_EYEDEPTH(o.projPos.z);
+					#endif
+					o.color = v.color;
+					o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+					return o;
+				}
+
+				sampler2D _CameraDepthTexture;
+				float _InvFade;
+			
+				fixed4 frag (v2f i) : COLOR
+				{
+					#ifdef SOFTPARTICLES_ON
+					float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+					float partZ = i.projPos.z;
+					float fade = saturate (_InvFade * (sceneZ-partZ));
+					i.color.a *= fade;
+					#endif
+				
+					return 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord);
+				}
+				ENDCG 
+			}
+		} 	
+	
+		// ---- Dual texture cards
+		SubShader {
+			Pass {
+				SetTexture [_MainTex] {
+					constantColor [_TintColor]
+					combine constant * primary
+				}
+				SetTexture [_MainTex] {
+					combine texture * previous DOUBLE
+				}
+			}
+		}
+	
+		// ---- Single texture cards (does not do color tint)
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex] { 
+					combine texture * primary 
+				}
+			}
+		}
+	}
+}
+

--- /dev/null
+++ b/Assets/SquadCore/Shaders/ParticleAlpha.shader
@@ -1,1 +1,118 @@
+Shader "KSP/Particles/Alpha Blended"
+{
+	Properties
+	{
+		_TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
+		_MainTex ("Particle Texture", 2D) = "white" {}
+		_InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0
+	}
 
+	Category
+	{
+		Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
+		Blend SrcAlpha OneMinusSrcAlpha
+		AlphaTest Greater .01
+		ColorMask RGB
+		Cull Off Lighting Off ZWrite Off
+		BindChannels {
+			Bind "Color", color
+			Bind "Vertex", vertex
+			Bind "TexCoord", texcoord
+	}
+	
+		// ---- Fragment program cards
+		SubShader
+		{
+			Pass
+			{
+		
+				CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+				#pragma fragmentoption ARB_precision_hint_fastest
+				#pragma multi_compile_particles
+			
+				#include "UnityCG.cginc"
+
+				sampler2D _MainTex;
+				fixed4 _TintColor;
+			
+				struct appdata_t {
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+				};
+
+				struct v2f {
+					float4 vertex : POSITION;
+					fixed4 color : COLOR;
+					float2 texcoord : TEXCOORD0;
+					#ifdef SOFTPARTICLES_ON
+					float4 projPos : TEXCOORD1;
+					#endif
+				};
+			
+				float4 _MainTex_ST;
+
+				v2f vert (appdata_t v)
+				{
+					v2f o;
+					o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
+					#ifdef SOFTPARTICLES_ON
+					o.projPos = ComputeScreenPos (o.vertex);
+					COMPUTE_EYEDEPTH(o.projPos.z);
+					#endif
+					o.color = v.color;
+					o.texcoord = TRANSFORM_TEX(v.texcoord,_MainTex);
+					return o;
+				}
+
+				sampler2D _CameraDepthTexture;
+				float _InvFade;
+			
+				fixed4 frag (v2f i) : COLOR
+				{
+					#ifdef SOFTPARTICLES_ON
+					float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
+					float partZ = i.projPos.z;
+					float fade = saturate (_InvFade * (sceneZ-partZ));
+					i.color.a *= fade;
+					#endif
+				
+					return 2.0f * i.color * _TintColor * tex2D(_MainTex, i.texcoord);
+				}
+				ENDCG 
+			}
+		} 	
+	
+		// ---- Dual texture cards
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex]
+				{
+					constantColor [_TintColor]
+					combine constant * primary
+				}
+				SetTexture [_MainTex]
+				{
+					combine texture * previous DOUBLE
+				}
+			}
+		}
+	
+		// ---- Single texture cards (does not do color tint)
+		SubShader
+		{
+			Pass
+			{
+				SetTexture [_MainTex]
+				{
+					combine texture * primary
+				}
+			}
+		}
+	}
+}
+

--- /dev/null
+++ b/Assets/SquadCore/Shaders/SolidColorAlpha.shader
@@ -1,1 +1,49 @@
+Shader "Solid Color (Alpha)" {
+	Properties 
+	{
+		_Color ("Color", Color) = (0.5, 0.5, 0.5, 0.5)
+	}
+	SubShader
+	{
+		
+		ZWrite On
+        GrabPass { }
+		Pass
+		{
+			Fog { Mode Off }
+			Blend SrcAlpha OneMinusSrcAlpha
 
+			CGPROGRAM
+
+			#pragma vertex vert
+			#pragma fragment frag
+	
+			fixed4 _Color;
+			sampler2D _GrabTexture;
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+			};
+			struct v2f
+			{
+				float4 pos : SV_POSITION;
+				float4 uv : TEXCOORD0;
+			};
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.pos = mul(UNITY_MATRIX_MVP, v.vertex);
+				o.uv = o.pos;
+				return o;
+			}
+			half4 frag(v2f i) : COLOR
+			{
+				float2 coord = 0.5 + 0.5 * i.uv.xy / i.uv.w;
+				fixed4 tex = tex2D(_GrabTexture, float2(coord.x, 1 - coord.y));
+				return fixed4(lerp(tex.rgb, _Color.rgb, _Color.a), 1);
+			}
+			ENDCG
+		}
+	}
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Specular.shader
@@ -1,1 +1,68 @@
+Shader "KSP/Specular"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_Color ("Main Color", Color) = (1,1,1,1)
+		_SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1)
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 3.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/SpecularBumpTransparent.shader
@@ -1,1 +1,80 @@
+Shader "KSP/Bumped Specular (Transparent)"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_BumpMap("_BumpMap", 2D) = "bump" {}
+		
+		_MainColor ("Main Color", Color) = (1,1,1,1)
+		
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
+		
+		Pass 
+		{
+			ZWrite On
+			ColorMask 0
+		}
+		
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 2.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		sampler2D _BumpMap;
+		
+		float4 _MainColor;
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_BumpMap;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _MainColor * _BurnColor;
+			float3 normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
+			
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+			o.Normal = normal;
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Bumped Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/SpecularTransparent.shader
@@ -1,1 +1,76 @@
+Shader "KSP/Specular (Transparent)"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB spec(A))", 2D) = "white" {}
+		_MainColor ("Main Color", Color) = (1,1,1,1)
+		
+		_Shininess ("Shininess", Range (0.03, 1)) = 0.078125
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
+		
+		Pass 
+		{
+			ZWrite On
+			ColorMask 0
+		}
+		
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+		
+		CGPROGRAM
+
+		#pragma surface surf BlinnPhong
+		#pragma target 2.0
+		
+		half _Shininess;
+
+		sampler2D _MainTex;
+		
+		float4 _MainColor;
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		struct Input
+		{
+			float2 uv_MainTex;
+			float3 viewDir;
+			float3 worldNormal;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _MainColor * _BurnColor;
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), IN.worldNormal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = color.rgb;
+			o.Emission = emission;
+			o.Gloss = color.a;
+			o.Specular = _Shininess;
+
+			o.Emission *= _Opacity * rim;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+		
+	}
+	Fallback "Specular"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/Unlit.shader
@@ -1,1 +1,84 @@
+Shader "KSP/Unlit"
+{
+	Properties 
+	{
+		_MainTex("_MainTex (RGB)", 2D) = "white" {}
+		_Color("Color", Color) = (1,1,1,1)
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		Tags { "RenderType"="Opaque" }
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+
+		CGPROGRAM
+
+		#pragma surface surf Unlit
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+		float4 _Color;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		inline half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten)
+		{
+            half diff = max (0, dot (s.Normal, lightDir));
+
+            half4 c;
+            c.rgb = s.Albedo;
+            c.a = s.Alpha;
+            return c;
+        }
+
+        inline half4 LightingUnlit_PrePass (SurfaceOutput s, half4 light)
+		{
+            half4 c;
+            c.rgb = s.Albedo;
+            c.a = s.Alpha;
+            return c;
+        }
+
+		struct Input
+		{
+			float2 uv_MainTex;
+			float2 uv_Emissive;
+			float3 viewDir;
+		};
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex,(IN.uv_MainTex)) * _BurnColor;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = _Color.rgb * color.rgb;
+			o.Emission = emission;
+			o.Gloss = 0;
+			o.Specular = 0;
+			o.Normal = normal;
+
+			o.Emission *= _Opacity;
+			o.Alpha = _Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Unlit/Texture"
+}

--- /dev/null
+++ b/Assets/SquadCore/Shaders/UnlitTransparent.shader
@@ -1,1 +1,79 @@
+Shader "KSP/Alpha/Unlit Transparent"
+{
+	Properties 
+	{
+		_MainTex("MainTex (RGB Alpha(A))", 2D) = "white" {}
+		_Color("Color", Color) = (1,1,1,1)
+		
+		_Opacity("_Opacity", Range(0,1) ) = 1
+		_RimFalloff("_RimFalloff", Range(0.01,5) ) = 0.1
+		_RimColor("_RimColor", Color) = (0,0,0,0)
 
+		_TemperatureColor("_TemperatureColor", Color) = (0,0,0,0)
+		_BurnColor ("Burn Color", Color) = (1,1,1,1)
+	}
+	
+	SubShader 
+	{
+		ZWrite On
+		ZTest LEqual
+		Blend SrcAlpha OneMinusSrcAlpha 
+		Cull Off 
+
+		CGPROGRAM
+
+		#pragma surface surf Unlit alpha
+		#pragma target 3.0
+
+		sampler2D _MainTex;
+		float4 _Color;
+
+		float _Opacity;
+		float _RimFalloff;
+		float4 _RimColor;
+		float4 _TemperatureColor;
+		float4 _BurnColor;
+		
+		inline half4 LightingUnlit (SurfaceOutput s, half3 lightDir, half atten)
+		{
+            half diff = max (0, dot (s.Normal, lightDir));
+
+            half4 c;
+            c.rgb = s.Albedo;
+            c.a = s.Alpha;
+            return c;
+        }
+
+        inline half4 LightingUnlit_PrePass (SurfaceOutput s, half4 light)
+		{
+            half4 c;
+            c.rgb = s.Albedo;
+            c.a = s.Alpha;
+            return c;
+        }
+
+        struct Input
+		{
+            float2 uv_MainTex;
+			float3 viewDir;
+        };
+
+		void surf (Input IN, inout SurfaceOutput o)
+		{
+			float4 color = tex2D(_MainTex, (IN.uv_MainTex)) * _BurnColor;
+			float alpha = _Color.a * color.a;
+			float3 normal = float3(0,0,1);
+
+			half rim = 1.0 - saturate(dot (normalize(IN.viewDir), normal));
+
+			float3 emission = (_RimColor.rgb * pow(rim, _RimFalloff)) * _RimColor.a;
+			emission += _TemperatureColor.rgb * _TemperatureColor.a;
+
+			o.Albedo = _Color.rgb * color.rgb;
+			o.Emission = emission * _Opacity;
+			o.Alpha = _Color.a * color.a*_Opacity;
+		}
+		ENDCG
+	}
+	Fallback "Diffuse"
+}

--- a/KerbalEngineer.CSharp.Editor.csproj
+++ b/KerbalEngineer.CSharp.Editor.csproj
@@ -121,9 +121,77 @@
     <Reference Include="KerbalEngineer.Unity">
       <HintPath>Assets\Plugins\KerbalEngineer.Unity.dll</HintPath>
     </Reference>
+    <Reference Include="KSPAssetCompiler">
+      <HintPath>Assets\Plugins\KSPAssets\KSPAssetCompiler.dll</HintPath>
+    </Reference>
+    <Reference Include="KSPAssets">
+      <HintPath>Assets\Plugins\KSPAssets\KSPAssets.dll</HintPath>
+    </Reference>
+    <Reference Include="PartTools">
+      <HintPath>Assets\PartTools\Lib\PartTools.dll</HintPath>
+    </Reference>
+    <Reference Include="PartToolsEditor">
+      <HintPath>Assets\PartTools\Lib\PartToolsEditor.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Assets\PartTools\Editor\InternalSpaceEditor.cs" />
+    <Compile Include="Assets\PartTools\Editor\KSPParticleEmitterEditor.cs" />
+    <Compile Include="Assets\PartTools\Editor\PartToolsEditor.cs" />
+    <Compile Include="Assets\PartTools\Editor\PartToolsWindows.cs" />
+    <Compile Include="Assets\PartTools\Editor\PropEditor.cs" />
     <Compile Include="Assets\Scripts\Editor\BuildAssetBundles.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Assets\PartTools\Shaders\Alpha.shader" />
+    <None Include="Assets\PartTools\Shaders\AlphaAdditive.shader" />
+    <None Include="Assets\PartTools\Shaders\AlphaSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\Bumped.shader" />
+    <None Include="Assets\PartTools\Shaders\BumpedSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\Cutoff.shader" />
+    <None Include="Assets\PartTools\Shaders\CutoffBumped.shader" />
+    <None Include="Assets\PartTools\Shaders\DepthMask.shader" />
+    <None Include="Assets\PartTools\Shaders\Diffuse.shader" />
+    <None Include="Assets\PartTools\Shaders\Emissive.shader" />
+    <None Include="Assets\PartTools\Shaders\EmissiveBumpedSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\EmissiveSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\InternalBumpedSpecular 1.shader" />
+    <None Include="Assets\PartTools\Shaders\InternalBumpedSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\KSPParticle AddSmooth.shader" />
+    <None Include="Assets\PartTools\Shaders\LightingKSP.cginc" />
+    <None Include="Assets\PartTools\Shaders\LightwrapSpecular.shader" />
+    <None Include="Assets\PartTools\Shaders\PBR\KSP_Standard_Bumped.shader" />
+    <None Include="Assets\PartTools\Shaders\ParticleAdd.shader" />
+    <None Include="Assets\PartTools\Shaders\ParticleAdditiveFresnel.shader" />
+    <None Include="Assets\PartTools\Shaders\ParticleAlpha.shader" />
+    <None Include="Assets\PartTools\Shaders\ScrollingUnlit.shader" />
+    <None Include="Assets\PartTools\Shaders\SolidColorAlpha.shader" />
+    <None Include="Assets\PartTools\Shaders\Specular.shader" />
+    <None Include="Assets\PartTools\Shaders\SpecularBumpTransparent.shader" />
+    <None Include="Assets\PartTools\Shaders\SpecularTransparent.shader" />
+    <None Include="Assets\PartTools\Shaders\Unlit.shader" />
+    <None Include="Assets\PartTools\Shaders\UnlitColor.shader" />
+    <None Include="Assets\PartTools\Shaders\UnlitTransparent.shader" />
+    <None Include="Assets\Plugins\KSPAssets\ReadMe.txt" />
+    <None Include="Assets\SquadCore\Shaders\Alpha.shader" />
+    <None Include="Assets\SquadCore\Shaders\AlphaSpecular.shader" />
+    <None Include="Assets\SquadCore\Shaders\Bumped.shader" />
+    <None Include="Assets\SquadCore\Shaders\BumpedSpecular.shader" />
+    <None Include="Assets\SquadCore\Shaders\Cutoff.shader" />
+    <None Include="Assets\SquadCore\Shaders\CutoffBumped.shader" />
+    <None Include="Assets\SquadCore\Shaders\Diffuse.shader" />
+    <None Include="Assets\SquadCore\Shaders\Emissive.shader" />
+    <None Include="Assets\SquadCore\Shaders\EmissiveBumpedSpecular.shader" />
+    <None Include="Assets\SquadCore\Shaders\EmissiveSpecular.shader" />
+    <None Include="Assets\SquadCore\Shaders\KSPParticle AddSmooth.shader" />
+    <None Include="Assets\SquadCore\Shaders\ParticleAdd.shader" />
+    <None Include="Assets\SquadCore\Shaders\ParticleAlpha.shader" />
+    <None Include="Assets\SquadCore\Shaders\SolidColorAlpha.shader" />
+    <None Include="Assets\SquadCore\Shaders\Specular.shader" />
+    <None Include="Assets\SquadCore\Shaders\SpecularBumpTransparent.shader" />
+    <None Include="Assets\SquadCore\Shaders\SpecularTransparent.shader" />
+    <None Include="Assets\SquadCore\Shaders\Unlit.shader" />
+    <None Include="Assets\SquadCore\Shaders\UnlitTransparent.shader" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\SyntaxTree\UnityVS\2015\UnityVS.CSharp.targets" />
 </Project>

file:b/PartTools.cfg (new)
--- /dev/null
+++ b/PartTools.cfg
@@ -1,1 +1,2 @@
+GameData =