Can't get any shader to work

[corbinyo]

Shaders will not compile - using unity 2018.3.0b10

[smkplus]

Shaders will not compile - using unity 2018.3.0b10

try using web version because It's new version of shader man
https://smkplus.github.io/ShaderMan.io/
which shader do you want to convert

[corbinyo]

Hi! Thank you for answering. I am still having the same issues using https://smkplus.github.io/ShaderMan.io/ when I try and convert https://www.shadertoy.com/view/4ddXW4

[smkplus]

Hi! Thank you for answering. I am still having the same issues using https://smkplus.github.io/ShaderMan.io/ when I try and convert https://www.shadertoy.com/view/4ddXW4

Shader "Hidden/Shader"
{

	SubShader
	{
		// No culling or depth
		Cull Off ZWrite Off ZTest Always

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			
			#include "UnityCG.cginc"

			struct appdata
			{
				float4 vertex : POSITION;
				float2 uv : TEXCOORD0;
			};

			struct v2f
			{
				float2 uv : TEXCOORD0;
				float4 vertex : SV_POSITION;
			};

			v2f vert (appdata v)
			{
				v2f o;
				o.vertex = UnityObjectToClipPos(v.vertex);
				o.uv = v.uv;
				return o;
			}
			
/**
 * Created by Kamil Kolaczynski (revers) - 2016
 *
 * Licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
 *
 * This shader, as always, uses a lot of code (raymarching, noise and lighting) credited to iq 
 * [ https://www.shadertoy.com/view/Xds3zN ]. 
 * Camera path is based on Shane's "Subterranean Fly-Through" [ https://www.shadertoy.com/view/XlXXWj ].
 * Additional specular lighting trick is based on "Wet stone" by TDM [ https://www.shadertoy.com/view/ldSSzV ].
 * Thanks for sharing great code guys!
 * 
 * The shader was created and exported from Synthclipse [ http://synthclipse.sourceforge.net/ ].
 */
 #define FOV 0.4
 #define MarchDumping 0.7579
 #define Far 38.925
 #define MaxSteps 128
 #define CameraSpeed 4.5099998
 #define TunnelSmoothFactor  2.0
 #define TunnelRadius  0.85660005
 #define TunnelFreqA  0.18003
 #define TunnelFreqB  0.25
 #define TunnelAmpA  3.6230998
 #define TunnelAmpB  2.4324
 #define NoiseIsoline  0.319
 #define NoiseScale  2.9980001
 #define Color  float3(0.085, 0.658, 1.0)

#define M_NONE -1.0
#define M_NOISE 1.0

float hash(float h) {
	return frac(sin(h) * 43758.5453123);
}

float noise(float3 x) {
	float3 p = floor(x);
	float3 f = frac(x);
	f = f * f * (3.0 - 2.0 * f);

	float n = p.x + p.y * 157.0 + 113.0 * p.z;
	return lerp(
			lerp(lerp(hash(n + 0.0), hash(n + 1.0), f.x),
					lerp(hash(n + 157.0), hash(n + 158.0), f.x), f.y),
			lerp(lerp(hash(n + 113.0), hash(n + 114.0), f.x),
					lerp(hash(n + 270.0), hash(n + 271.0), f.x), f.y), f.z);
}

float fbm(float3 p) {
	float f = 0.0;
	f = 0.5000 * noise(p);
	p *= 2.01;
	f += 0.2500 * noise(p);
	p *= 2.02;
	f += 0.1250 * noise(p);

	return f;
}

// by iq. http://iquilezles.org/www/articles/smin/smin.htm
float smax(float a, float b, float k) {
	float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
	return lerp(a, b, h) + k * h * (1.0 - h);
}

// From "Subterranean Fly-Through" by Shane https://www.shadertoy.com/view/XlXXWj
float2 path(float z) {
	return float2(TunnelAmpA * sin(z * TunnelFreqA), TunnelAmpB * cos(z * TunnelFreqB));
}

float noiseDist(float3 p) {
	p = p / NoiseScale;
	return (fbm(p) - NoiseIsoline) * NoiseScale;
}

float2 map(float3 p) {
	float d = noiseDist(p);
	float d2 = length(p.xy - path(p.z)) - TunnelRadius;
	d = smax(d, -d2, TunnelSmoothFactor);

	float2 res = float2(d, M_NOISE);
	return res;
}

float2 castRay(float3 ro, float3 rd) {
	float tmin = 0.0;
	float tmax = Far;

	float precis = 0.002;
	float t = tmin;
	float m = M_NONE;

	for (int i = 0; i < MaxSteps; i++) {
		float2 res = map(ro + rd * t);
		if (res.x < precis || t > tmax) {
			break;
		}
		t += res.x * MarchDumping;
		m = res.y;
	}
	if (t > tmax) {
		m = M_NONE;
	}
	return float2(t, m);
}

float softshadow(float3 ro, float3 rd, float mint, float tmax) {
	float res = 1.0;
	float t = mint;

	for (int i = 0; i < 16; i++) {
		float h = map(ro + rd * t).x;

		res = min(res, 8.0 * h / t);
		t += clamp(h, 0.02, 0.10);

		if (h < 0.001 || t > tmax) {
			break;
		}
	}
	return clamp(res, 0.0, 1.0);
}

float3 calcNormal(float3 pos) {
	float2 eps = float2(0.001, 0.0);

	float3 nor = float3(map(pos + eps.xyy).x - map(pos - eps.xyy).x,
			map(pos + eps.yxy).x - map(pos - eps.yxy).x,
			map(pos + eps.yyx).x - map(pos - eps.yyx).x);
	return normalize(nor);
}

float calcAO(float3 pos, float3 nor) {
	float occ = 0.0;
	float sca = 1.0;

	for (int i = 0; i < 5; i++) {
		float hr = 0.01 + 0.12 * float(i) / 4.0;
		float3 aopos = nor * hr + pos;
		float dd = map(aopos).x;

		occ += -(dd - hr) * sca;
		sca *= 0.95;
	}
	return clamp(1.0 - 3.0 * occ, 0.0, 1.0);
}

float3 render(float3 ro, float3 rd) {
	float3 col = float3(0,0,0);
	float2 res = castRay(ro, rd);
	float t = res.x;
	float m = res.y;

	if (m > -0.5) {
		float3 pos = ro + t * rd;
		float3 nor = calcNormal(pos);

		// material
		col = Color + sin(t * 0.8) * 0.3;
		col += 0.3 * sin(float3(0.15, 0.02, 0.10) * _Time.y * 6.0);

		// lighitng
		float occ = calcAO(pos, nor);
		float3 lig = -rd;
		float amb = clamp(0.5 + 0.5 * nor.y, 0.0, 1.0);
		float dif = clamp(dot(nor, lig), 0.0, 1.0);

		float fre = pow(clamp(1.0 + dot(nor, rd), 0.0, 1.0), 2.0);

		float3 ref = reflect(rd, nor);
		float spe = pow(clamp(dot(ref, lig), 0.0, 1.0), 100.0);

		dif *= softshadow(pos, lig, 0.02, 2.5);

		float3 brdf = float3(0,0,0);
		brdf += 1.20 * dif * float3(1.00, 0.90, 0.60);
		brdf += 1.20 * spe * float3(1.00, 0.90, 0.60) * dif;

		// Additional specular lighting trick,
		// taken from "Wet stone" by TDM
		// https://www.shadertoy.com/view/ldSSzV
		nor = normalize(nor - normalize(pos) * 0.2);
		ref = reflect(rd, nor);
		spe = pow(clamp(dot(ref, lig), 0.0, 1.0), 100.0);
		brdf += 2.20 * spe * float3(1.00, 0.90, 0.60) * dif;

		brdf += 0.40 * amb * float3(0.50, 0.70, 1.00) * occ;
		brdf += 0.40 * fre * float3(1.00, 1.00, 1.00) * occ;

		col = col * brdf;

		col = lerp(col, float3(0,0,0), 1.0 - exp(-0.005 * t * t));
	}
	return float3(clamp(col, 0.0, 1.0));
}

float3x3 rotationZ(float a) {
	float sa = sin(a);
	float ca = cos(a);

	return float3x3(ca, sa, 0.0, -sa, ca, 0.0, 0.0, 0.0, 1.0);
}


	fixed4 frag (v2f i) : SV_Target
	{
	float2 q = i.uv;
	float2 coord = 2.0 * q - 1.0;
	coord *= FOV;

    float t = _Time.y * CameraSpeed + 4.0 * 60.0;
    float3 ro = float3(path(t), t);

    t += 0.5;
    float3 target = float3(path(t), t);
    float3 dir = normalize(target - ro);
    float3 up = mul(float3(-0.9309864, -0.33987653, 0.1332234) , rotationZ(_Time.y * 0.05));
    float3 upOrtho = normalize(up - dot(dir, up) * dir);
    float3 right = normalize(cross(dir, upOrtho));

    float3 rd = normalize(dir + coord.x * right + coord.y * upOrtho);

    float3 col = render(ro, rd);

    col = pow(col, float3(0.4545,0.4545,0.4545));

   return float4(col, 1.0);
			}
			ENDCG
		}
	}
}

[LauraLaureus]

@smkplus I cannot make a shader to work with unity It throws:

I tried the same in the web version but I get the following error:

I'm trying to convert the following shader if it help you with the test:
https://www.shadertoy.com/view/Xts3WH

[smkplus]

   
    Shader "ShaderMan/MyShader"
	{
	Properties{
	
	}
	SubShader
	{
	Tags { "RenderType" = "Transparent" "Queue" = "Transparent" }
	Pass
	{
	ZWrite Off
	Blend SrcAlpha OneMinusSrcAlpha
	CGPROGRAM
	#pragma vertex vert
	#pragma fragment frag
	#include "UnityCG.cginc"
			
    

    float4 vec4(float x,float y,float z,float w){return float4(x,y,z,w);}
    float4 vec4(float x){return float4(x,x,x,x);}
    float4 vec4(float2 x,float2 y){return float4(float2(x.x,x.y),float2(y.x,y.y));}
    float4 vec4(float3 x,float y){return float4(float3(x.x,x.y,x.z),y);}


    float3 vec3(float x,float y,float z){return float3(x,y,z);}
    float3 vec3(float x){return float3(x,x,x);}
    float3 vec3(float2 x,float y){return float3(float2(x.x,x.y),y);}

    float2 vec2(float x,float y){return float2(x,y);}
    float2 vec2(float x){return float2(x,x);}

    float vec(float x){return float(x);}
    
    

	struct VertexInput {
    float4 vertex : POSITION;
	float2 uv:TEXCOORD0;
    float4 tangent : TANGENT;
    float3 normal : NORMAL;
	//VertexInput
	};
	struct VertexOutput {
	float4 pos : SV_POSITION;
	float2 uv:TEXCOORD0;
	//VertexOutput
	};
	
	
	VertexOutput vert (VertexInput v)
	{
	VertexOutput o;
	o.pos = UnityObjectToClipPos (v.vertex);
	o.uv = v.uv;
	//VertexFactory
	return o;
	}
    
    
    
    
	fixed4 frag(VertexOutput vertex_output) : SV_Target
	{
	
	float2 p = vertex_output.uv/1, a = p*5.; a.y -= _Time.y;
	float2 f = frac(a); a -= f; f = f*f*(3.-2.*f);
    float4 r = frac(sin(vec4(a.x + a.y*1e3) + vec4(0, 1, 1e3, 1001)) * 1e5)*30./p.y;
	float3 rgb = p.y + vec3(1,.5,.2) * clamp(lerp(lerp(r.x, r.y, f.x), lerp(r.z, r.w, f.x), f.y)-30., -.2, 1.);
    return float4(rgb,1);
	}
	ENDCG
	}
  }
  }