Coding unity shaders with unity visual studio

Question

Recently I've been coding shaders for unity in visual studio and I've noticed that since unity shaders are written in a combination of unity's shader lab language and CG, visual studio 2015 doesn't seem to recognize the languages. Because of this, visual studio is not reconizing keywords, has no intellesense, and worse of all tabbing incorrectly whenever I press enter to go to a new line. I've tried this visual studio extension https://visualstudiogallery.msdn.microsoft.com/ed812631-a7d3-4ca3-9f84-7efb240c7bb5 and it doesn't seem to fully work. I was wondering if anyone on here has had experience working with shaders and has an extension they know about to fix this problem.

Answer 1

That plugin should resolve your problem:

ShaderlabVS

It's supports Visual Studio 2013 and 2015. 2017 is on testing stage.

Answer 2

i bassicly used this for shaders:

http://wiki.unity3d.com/index.php/Silhouette-Outlined_Diffuse

the part that says "Outline only"

with the description: "The thing that does the trick here is "Blend Zero One" which is to completely forego rendering our object and use only the destination color (i.e. whatever is behind the object). In effect, the object itself is invisible, but we still let the outline render itself. So that's what we're left with: only the outline."

You first need to make a shader script and place it somewhere it suits you i always place this into the folder shaders.

the code is bassicly on the site but to make it easier for you i will paste it in here. be sure to read the code because you can edit this pretty easily from the code or inspector of Unity. hereby the code for the created shaderscript:

Shader "Outlined/Silhouette Only" {
    Properties {
        _OutlineColor ("Outline Color", Color) = (0,0,0,1)
        _Outline ("Outline width", Range (0.0, 0.03)) = .005
    }

CGINCLUDE
#include "UnityCG.cginc"

struct appdata {
    float4 vertex : POSITION;
    float3 normal : NORMAL;
};

struct v2f {
    float4 pos : POSITION;
    float4 color : COLOR;
};

uniform float _Outline;
uniform float4 _OutlineColor;

v2f vert(appdata v) {
    // just make a copy of incoming vertex data but scaled according to normal direction
    v2f o;
    o.pos = mul(UNITY_MATRIX_MVP, v.vertex);

    float3 norm   = mul ((float3x3)UNITY_MATRIX_IT_MV, v.normal);
    float2 offset = TransformViewToProjection(norm.xy);

    o.pos.xy += offset * o.pos.z * _Outline;
    o.color = _OutlineColor;
    return o;
}
ENDCG

    SubShader {
        Tags { "Queue" = "Transparent" }

        Pass {
            Name "BASE"
            Cull Back
            Blend Zero One

            // uncomment this to hide inner details:
            //Offset -8, -8

            SetTexture [_OutlineColor] {
                ConstantColor (0,0,0,0)
                Combine constant
            }
        }

        // note that a vertex shader is specified here but its using the one above
        Pass {
            Name "OUTLINE"
            Tags { "LightMode" = "Always" }
            Cull Front

            // you can choose what kind of blending mode you want for the outline
            //Blend SrcAlpha OneMinusSrcAlpha // Normal
            //Blend One One // Additive
            Blend One OneMinusDstColor // Soft Additive
            //Blend DstColor Zero // Multiplicative
            //Blend DstColor SrcColor // 2x Multiplicative

CGPROGRAM
#pragma vertex vert
#pragma fragment frag

half4 frag(v2f i) :COLOR {
    return i.color;
}
ENDCG
        }


    }

    Fallback "Diffuse"
}

P.S. can you tell me what kind of shaders you're aiming to make?