Adding a Texture to a premade Shader

Hey Guys,

I am currently trying to modify the Toon Shader found here. It is a pretty solid shader, but I would like to change the _Color and _UnlitColor to textures so that I can put my own created shaders onto the models, instead of solid colors, while still using all of the other functions of the shader.

I obviously don't know enough about shaders to be doing too much messing with the code, but if this is something obvious like it can't be done then definitely tell me.

 Shader "Cg shader for toon shading" {
    Properties {
       _Color ("Diffuse Color", Color) = (1,1,1,1) 
       _UnlitColor ("Unlit Diffuse Color", Color) = (0.5,0.5,0.5,1) 
       _DiffuseThreshold ("Threshold for Diffuse Colors", Range(0,1)) 
          = 0.1 
       _OutlineColor ("Outline Color", Color) = (0,0,0,1)
       _LitOutlineThickness ("Lit Outline Thickness", Range(0,1)) = 0.1
       _UnlitOutlineThickness ("Unlit Outline Thickness", Range(0,1)) 
          = 0.4
       _SpecColor ("Specular Color", Color) = (1,1,1,1) 
       _Shininess ("Shininess", Float) = 10
    }
    SubShader {
       Pass {      
          Tags { "LightMode" = "ForwardBase" } 
             // pass for ambient light and first light source
  
          CGPROGRAM
  
          #pragma vertex vert  
          #pragma fragment frag 
  
          #include "UnityCG.cginc"
          uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _OutlineColor;
          uniform float _LitOutlineThickness;
          uniform float _UnlitOutlineThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(float3(
                mul(float4(input.normal, 0.0), modelMatrixInverse)));
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
  
          float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - float3(input.posWorld));
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = 
                   normalize(float3(_WorldSpaceLightPos0));
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   float3(_WorldSpaceLightPos0 - input.posWorld);
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             // default: unlit 
             float3 fragmentColor = float3(_UnlitColor); 
  
             // low priority: diffuse illumination
             if (attenuation 
                * max(0.0, dot(normalDirection, lightDirection)) 
                >= _DiffuseThreshold)
             {
                fragmentColor = float3(_LightColor0) * float3(_Color); 
             }
  
             // higher priority: outline
             if (dot(viewDirection, normalDirection) 
                < lerp(_UnlitOutlineThickness, _LitOutlineThickness, 
                max(0.0, dot(normalDirection, lightDirection))))
             {
                fragmentColor = 
                   float3(_LightColor0) * float3(_OutlineColor); 
             }
  
             // highest priority: highlights
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = _SpecColor.a 
                   * float3(_LightColor0) * float3(_SpecColor)
                   + (1.0 - _SpecColor.a) * fragmentColor;
             }
  
             return float4(fragmentColor, 1.0);
          }
  
          ENDCG
       }
  
       Pass {      
          Tags { "LightMode" = "ForwardAdd" } 
             // pass for additional light sources
          Blend SrcAlpha OneMinusSrcAlpha 
             // blend specular highlights over framebuffer
  
          CGPROGRAM
  
          #pragma vertex vert  
          #pragma fragment frag 
  
          #include "UnityCG.cginc"
          uniform float4 _LightColor0; 
             // color of light source (from "Lighting.cginc")
  
          // User-specified properties
          uniform float4 _Color; 
          uniform float4 _UnlitColor;
          uniform float _DiffuseThreshold;
          uniform float4 _OutlineColor;
          uniform float _LitOutlineThickness;
          uniform float _UnlitOutlineThickness;
          uniform float4 _SpecColor; 
          uniform float _Shininess;
  
          struct vertexInput {
             float4 vertex : POSITION;
             float3 normal : NORMAL;
          };
          struct vertexOutput {
             float4 pos : SV_POSITION;
             float4 posWorld : TEXCOORD0;
             float3 normalDir : TEXCOORD1;
          };
  
          vertexOutput vert(vertexInput input) 
          {
             vertexOutput output;
  
             float4x4 modelMatrix = _Object2World;
             float4x4 modelMatrixInverse = _World2Object; 
                // multiplication with unity_Scale.w is unnecessary 
                // because we normalize transformed vectors
  
             output.posWorld = mul(modelMatrix, input.vertex);
             output.normalDir = normalize(float3(
                mul(float4(input.normal, 0.0), modelMatrixInverse)));
             output.pos = mul(UNITY_MATRIX_MVP, input.vertex);
             return output;
          }
  
          float4 frag(vertexOutput input) : COLOR
          {
             float3 normalDirection = normalize(input.normalDir);
  
             float3 viewDirection = normalize(
                _WorldSpaceCameraPos - float3(input.posWorld));
             float3 lightDirection;
             float attenuation;
  
             if (0.0 == _WorldSpaceLightPos0.w) // directional light?
             {
                attenuation = 1.0; // no attenuation
                lightDirection = 
                   normalize(float3(_WorldSpaceLightPos0));
             } 
             else // point or spot light
             {
                float3 vertexToLightSource = 
                   float3(_WorldSpaceLightPos0 - input.posWorld);
                float distance = length(vertexToLightSource);
                attenuation = 1.0 / distance; // linear attenuation 
                lightDirection = normalize(vertexToLightSource);
             }
  
             float4 fragmentColor = float4(0.0, 0.0, 0.0, 0.0);
             if (dot(normalDirection, lightDirection) > 0.0 
                // light source on the right side?
                && attenuation *  pow(max(0.0, dot(
                reflect(-lightDirection, normalDirection), 
                viewDirection)), _Shininess) > 0.5) 
                // more than half highlight intensity? 
             {
                fragmentColor = 
                   float4(_LightColor0.rgb, 1.0) * _SpecColor;
             }
  
             return fragmentColor;
          }
  
          ENDCG
       }
    } 
    // The definition of a fallback shader should be commented out 
    // during development:
    // Fallback "Specular"
 }