ohzi-core 6.1.2 → 6.2.1

package/src/shaders/deferred/deferred_compose.frag

@@ -1,59 +1,59 @@
-uniform sampler2D _MainTex; //albedo
-uniform sampler2D _NormalDepthRT;
-uniform mat4 _InverseProjMatrix;
-uniform vec2 _Resolution;
-varying vec2 vUv;
-varying vec4 vRay;
-
-
-vec3 decode_normal (vec4 enc)
-{
-    float scale = 1.7777;
-    vec3 nn =
-        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
-        vec3(-scale,-scale,1.0);
-    float g = 2.0 / dot(nn.xyz,nn.xyz);
-    vec3 n;
-    n.xy = g*nn.xy;
-    n.z = g-1.0;
-    return n;
-}
-
-float DecodeFloatRG( vec2 enc )
-{
-    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
-    return dot( enc, kDecodeDot );
-}
-
-vec3 DecodeNormal(vec2 uv)
-{
-  vec2 encoded_normal = texture2D(_NormalDepthRT, uv).zw;
-  vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
-  return normalize(normalValue);
-}
-vec3 DecodeViewPos(vec2 uv)
-{
-  vec2 depth = texture2D(_NormalDepthRT, uv).xy;
-  vec4 inv_proj = _InverseProjMatrix * vec4(vUv * 2.0 - 1.0, 1.0, 1.0);
-  return DecodeFloatRG(depth) * (vRay.xyz/vRay.w);
-}
-
-
-
-
-
-
-
-void main()
-{
-
-    vec3 fragPos   = DecodeViewPos(vUv);
-    vec3 normal    = DecodeNormal(vUv);
-
-    vec3 dir_to_light = normalize(fragPos) * -1.0;
-
-    float diffuse = dot(normal, dir_to_light);
-
-
-    gl_FragColor = vec4(diffuse, diffuse, diffuse, 1.0);
-}
+uniform sampler2D _MainTex; //albedo
+uniform sampler2D _NormalDepthRT;
+uniform mat4 _InverseProjMatrix;
+uniform vec2 _Resolution;
+varying vec2 vUv;
+varying vec4 vRay;
+
+
+vec3 decode_normal (vec4 enc)
+{
+    float scale = 1.7777;
+    vec3 nn =
+        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
+        vec3(-scale,-scale,1.0);
+    float g = 2.0 / dot(nn.xyz,nn.xyz);
+    vec3 n;
+    n.xy = g*nn.xy;
+    n.z = g-1.0;
+    return n;
+}
+
+float DecodeFloatRG( vec2 enc )
+{
+    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
+    return dot( enc, kDecodeDot );
+}
+
+vec3 DecodeNormal(vec2 uv)
+{
+  vec2 encoded_normal = texture2D(_NormalDepthRT, uv).zw;
+  vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
+  return normalize(normalValue);
+}
+vec3 DecodeViewPos(vec2 uv)
+{
+  vec2 depth = texture2D(_NormalDepthRT, uv).xy;
+  vec4 inv_proj = _InverseProjMatrix * vec4(vUv * 2.0 - 1.0, 1.0, 1.0);
+  return DecodeFloatRG(depth) * (vRay.xyz/vRay.w);
+}
+
+
+
+
+
+
+
+void main()
+{
+
+    vec3 fragPos   = DecodeViewPos(vUv);
+    vec3 normal    = DecodeNormal(vUv);
+
+    vec3 dir_to_light = normalize(fragPos) * -1.0;
+
+    float diffuse = dot(normal, dir_to_light);
+
+
+    gl_FragColor = vec4(diffuse, diffuse, diffuse, 1.0);
+}

package/src/shaders/deferred/point_light.frag

@@ -1,66 +1,66 @@
-uniform sampler2D _AlbedoTex; //albedo
-uniform sampler2D _NormalDepthTex;
-uniform mat4 _InverseProjMatrix;
-varying vec2 vUv;
-varying vec4 vProjPos;
-varying vec3 vCenter;
-
-uniform float _Intensity;
-
-
-vec3 decode_normal (vec4 enc)
-{
-    float scale = 1.7777;
-    vec3 nn =
-        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
-        vec3(-scale,-scale,1.0);
-    float g = 2.0 / dot(nn.xyz,nn.xyz);
-    vec3 n;
-    n.xy = g*nn.xy;
-    n.z = g-1.0;
-    return n;
-}
-
-float DecodeFloatRG( vec2 enc )
-{
-    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
-    return dot( enc, kDecodeDot );
-}
-
-vec3 DecodeNormal(vec2 uv)
-{
-  vec2 encoded_normal = texture2D(_NormalDepthTex, uv).zw;
-  vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
-  return normalize(normalValue);
-}
-vec3 DecodeViewPos(vec2 uv, vec4 ray)
-{
-  vec2 depth = texture2D(_NormalDepthTex, uv).xy;
-  vec4 inv_proj = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
-  return DecodeFloatRG(depth) * (ray.xyz/ray.w);
-}
-
-
-
-
-float saturate(float x)
-{
-    return clamp(x, 0.0, 1.0);
-}
-
-
-void main()
-{
-    vec2 uv = (vProjPos.xy/vProjPos.w)*0.5+vec2(0.5);
-	vec4 ray = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
-
-    vec3 fragPos   = DecodeViewPos(uv, ray);
-    vec3 normal    = DecodeNormal(uv);
-    vec3 albedo    = texture2D(_AlbedoTex, uv).rgb;
-
-
-    vec3 dir_to_light = normalize(vCenter - fragPos);
-    float diffuse = saturate(dot(normal, dir_to_light));
-    float attenuation = _Intensity/pow(length(vCenter - fragPos), 2.0);
-    gl_FragColor = vec4(albedo * diffuse * attenuation, 1.0);
-}
+uniform sampler2D _AlbedoTex; //albedo
+uniform sampler2D _NormalDepthTex;
+uniform mat4 _InverseProjMatrix;
+varying vec2 vUv;
+varying vec4 vProjPos;
+varying vec3 vCenter;
+
+uniform float _Intensity;
+
+
+vec3 decode_normal (vec4 enc)
+{
+    float scale = 1.7777;
+    vec3 nn =
+        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
+        vec3(-scale,-scale,1.0);
+    float g = 2.0 / dot(nn.xyz,nn.xyz);
+    vec3 n;
+    n.xy = g*nn.xy;
+    n.z = g-1.0;
+    return n;
+}
+
+float DecodeFloatRG( vec2 enc )
+{
+    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
+    return dot( enc, kDecodeDot );
+}
+
+vec3 DecodeNormal(vec2 uv)
+{
+  vec2 encoded_normal = texture2D(_NormalDepthTex, uv).zw;
+  vec3 normalValue = normalize(decode_normal(vec4(encoded_normal, 0., 0.)));
+  return normalize(normalValue);
+}
+vec3 DecodeViewPos(vec2 uv, vec4 ray)
+{
+  vec2 depth = texture2D(_NormalDepthTex, uv).xy;
+  vec4 inv_proj = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+  return DecodeFloatRG(depth) * (ray.xyz/ray.w);
+}
+
+
+
+
+float saturate(float x)
+{
+    return clamp(x, 0.0, 1.0);
+}
+
+
+void main()
+{
+    vec2 uv = (vProjPos.xy/vProjPos.w)*0.5+vec2(0.5);
+	vec4 ray = _InverseProjMatrix * vec4(uv * 2.0 - 1.0, 1.0, 1.0);
+
+    vec3 fragPos   = DecodeViewPos(uv, ray);
+    vec3 normal    = DecodeNormal(uv);
+    vec3 albedo    = texture2D(_AlbedoTex, uv).rgb;
+
+
+    vec3 dir_to_light = normalize(vCenter - fragPos);
+    float diffuse = saturate(dot(normal, dir_to_light));
+    float attenuation = _Intensity/pow(length(vCenter - fragPos), 2.0);
+    gl_FragColor = vec4(albedo * diffuse * attenuation, 1.0);
+}

package/src/shaders/deferred/point_light.vert

@@ -1,13 +1,13 @@
-varying vec2 vUv;
-varying vec4 vProjPos;
-varying vec3 vCenter;
-
-void main()
-{
-	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-
-    vProjPos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-	vUv = uv;
-    vCenter = vec3(modelMatrix[3][0],modelMatrix[3][1],modelMatrix[3][2]);
-    vCenter = (viewMatrix * vec4(vCenter, 1.0)).xyz;
-}
+varying vec2 vUv;
+varying vec4 vProjPos;
+varying vec3 vCenter;
+
+void main()
+{
+	gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+
+    vProjPos = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+	vUv = uv;
+    vCenter = vec3(modelMatrix[3][0],modelMatrix[3][1],modelMatrix[3][2]);
+    vCenter = (viewMatrix * vec4(vCenter, 1.0)).xyz;
+}

package/src/shaders/depth_normals/debug_normals.frag

@@ -1,48 +1,48 @@
-uniform sampler2D _MainTex;
-uniform vec2 _Resolution;
-uniform float _FarPlane;
-
-varying vec2 vUv;
-varying vec4 vRay;
-
-vec3 decode_normal (vec4 enc)
-{
-    float scale = 1.7777;
-    vec3 nn =
-        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
-        vec3(-scale,-scale,1.0);
-    float g = 2.0 / dot(nn.xyz,nn.xyz);
-    vec3 n;
-    n.xy = g*nn.xy;
-    n.z = g-1.0;
-    return n;
-}
-
-float DecodeFloatRG( vec2 enc )
-{
-    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
-    return dot( enc, kDecodeDot );
-}
-
-vec3 DecodeNormal(vec2 uv)
-{
-  vec4 depthNormal = texture2D(_MainTex, uv);
-  vec3 normalValue = normalize(decode_normal(vec4(depthNormal.zw, 0., 0.)));
-  return normalize(normalValue);
-}
-vec3 DecodeViewPos(vec2 uv)
-{
-  vec2 depth = texture2D(_MainTex, uv).xy;
-  return DecodeFloatRG(depth) * (vRay.xyz/vRay.w);
-}
-
-void main()
-{
-    vec3 viewPos = DecodeViewPos(vUv);
-    vec3 normalValue = DecodeNormal(vUv);
-
-    float vDepth = clamp(0.0, 1.0, length(viewPos)/_FarPlane);
-    vDepth = length(viewPos)/_FarPlane;
-    // gl_FragColor = vec4(normalValue*0.5+0.5, 1.0);
-    gl_FragColor = vec4(vDepth,vDepth,vDepth, 1.0);
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+uniform float _FarPlane;
+
+varying vec2 vUv;
+varying vec4 vRay;
+
+vec3 decode_normal (vec4 enc)
+{
+    float scale = 1.7777;
+    vec3 nn =
+        enc.xyz*vec3(2.0*scale,2.0*scale,0.0) +
+        vec3(-scale,-scale,1.0);
+    float g = 2.0 / dot(nn.xyz,nn.xyz);
+    vec3 n;
+    n.xy = g*nn.xy;
+    n.z = g-1.0;
+    return n;
+}
+
+float DecodeFloatRG( vec2 enc )
+{
+    vec2 kDecodeDot = vec2(1.0, 1.0/255.0);
+    return dot( enc, kDecodeDot );
+}
+
+vec3 DecodeNormal(vec2 uv)
+{
+  vec4 depthNormal = texture2D(_MainTex, uv);
+  vec3 normalValue = normalize(decode_normal(vec4(depthNormal.zw, 0., 0.)));
+  return normalize(normalValue);
+}
+vec3 DecodeViewPos(vec2 uv)
+{
+  vec2 depth = texture2D(_MainTex, uv).xy;
+  return DecodeFloatRG(depth) * (vRay.xyz/vRay.w);
+}
+
+void main()
+{
+    vec3 viewPos = DecodeViewPos(vUv);
+    vec3 normalValue = DecodeNormal(vUv);
+
+    float vDepth = clamp(0.0, 1.0, length(viewPos)/_FarPlane);
+    vDepth = length(viewPos)/_FarPlane;
+    // gl_FragColor = vec4(normalValue*0.5+0.5, 1.0);
+    gl_FragColor = vec4(vDepth,vDepth,vDepth, 1.0);
 }

package/src/shaders/depth_normals/depth_normals.frag

@@ -1,30 +1,30 @@
-varying vec3 v_normal;
-varying vec3 v_pos;
-
-uniform float _FarPlane;
-
-vec2 EncodeFloatRG( float v )
-{
-    vec2 kEncodeMul = vec2(1.0, 255.0);
-    float kEncodeBit = 1.0/255.0;
-    vec2 enc = kEncodeMul * v;
-    enc = fract (enc);
-    enc.x -= enc.y * kEncodeBit;
-    return enc;
-}
-
-vec2 EncodeNormal (vec3 n)
-{
-    float scale = 1.7777;
-    vec2 enc = n.xy / (n.z+1.0);
-    enc /= scale;
-    enc = enc*0.5+0.5;
-    return enc;
-}
-
-
-void main()
-{
-	gl_FragColor = vec4(EncodeFloatRG(length(v_pos.z)/_FarPlane), EncodeNormal(normalize(v_normal)));	
-}
-
+varying vec3 v_normal;
+varying vec3 v_pos;
+
+uniform float _FarPlane;
+
+vec2 EncodeFloatRG( float v )
+{
+    vec2 kEncodeMul = vec2(1.0, 255.0);
+    float kEncodeBit = 1.0/255.0;
+    vec2 enc = kEncodeMul * v;
+    enc = fract (enc);
+    enc.x -= enc.y * kEncodeBit;
+    return enc;
+}
+
+vec2 EncodeNormal (vec3 n)
+{
+    float scale = 1.7777;
+    vec2 enc = n.xy / (n.z+1.0);
+    enc /= scale;
+    enc = enc*0.5+0.5;
+    return enc;
+}
+
+
+void main()
+{
+	gl_FragColor = vec4(EncodeFloatRG(length(v_pos.z)/_FarPlane), EncodeNormal(normalize(v_normal)));	
+}
+

package/src/shaders/depth_normals/depth_normals.vert

@@ -1,13 +1,13 @@
-varying vec3 v_normal;
-varying vec3 v_pos;
-
-void main()
-{
-  vec3 pos = position;
-  mat4 MVP = projectionMatrix * modelViewMatrix;
-
-  v_normal 	= (modelViewMatrix * vec4(normal, 0.0)).xyz;
-  v_pos 		= (modelViewMatrix * vec4( pos, 1.0 )).xyz;
-
-  gl_Position = MVP * vec4( pos, 1.0 );
+varying vec3 v_normal;
+varying vec3 v_pos;
+
+void main()
+{
+  vec3 pos = position;
+  mat4 MVP = projectionMatrix * modelViewMatrix;
+
+  v_normal 	= (modelViewMatrix * vec4(normal, 0.0)).xyz;
+  v_pos 		= (modelViewMatrix * vec4( pos, 1.0 )).xyz;
+
+  gl_Position = MVP * vec4( pos, 1.0 );
 }

package/src/shaders/dual_filter_blur/alpha_filter.frag

@@ -1,14 +1,14 @@
-uniform sampler2D _MainTex;
-uniform vec2 _Resolution;
-varying vec2 vUv;
-
-
-
-void main()
-{
-
-	vec4 col = texture2D( _MainTex, vUv );
-	gl_FragColor = col;
-	gl_FragColor.a = col.a;
-
-}
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+varying vec2 vUv;
+
+
+
+void main()
+{
+
+	vec4 col = texture2D( _MainTex, vUv );
+	gl_FragColor = col;
+	gl_FragColor.a = col.a;
+
+}

package/src/shaders/dual_filter_blur/downsample.frag

@@ -1,21 +1,21 @@
-uniform sampler2D _MainTex;
-uniform vec2 _Resolution;
-varying vec2 vUv;
-
-
-vec4 downsample(vec2 uv, vec2 halfpixel)
-{
-	vec4 sum = texture2D( _MainTex,uv) * 4.0;
-	sum += texture2D( _MainTex,uv - halfpixel);
-	sum += texture2D( _MainTex,uv + halfpixel);
-	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, -halfpixel.y));
-	sum += texture2D( _MainTex,uv - vec2(halfpixel.x, -halfpixel.y));
-	return sum/8.0;
-}
-
-void main()
-{
-	vec2 half_pixel = vec2(0.5/_Resolution.x, 0.5/_Resolution.y);
-	gl_FragColor = downsample(vUv, half_pixel);
-
-}
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+varying vec2 vUv;
+
+
+vec4 downsample(vec2 uv, vec2 halfpixel)
+{
+	vec4 sum = texture2D( _MainTex,uv) * 4.0;
+	sum += texture2D( _MainTex,uv - halfpixel);
+	sum += texture2D( _MainTex,uv + halfpixel);
+	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, -halfpixel.y));
+	sum += texture2D( _MainTex,uv - vec2(halfpixel.x, -halfpixel.y));
+	return sum/8.0;
+}
+
+void main()
+{
+	vec2 half_pixel = vec2(0.5/_Resolution.x, 0.5/_Resolution.y);
+	gl_FragColor = downsample(vUv, half_pixel);
+
+}

package/src/shaders/dual_filter_blur/upsample.frag

@@ -1,24 +1,24 @@
-uniform sampler2D _MainTex;
-uniform vec2 _Resolution;
-varying vec2 vUv;
-
-vec4 upsample(vec2 uv, vec2 halfpixel)
-{
-	vec4 sum = texture2D( _MainTex,uv + vec2(-halfpixel.x * 2.0, 0.0));
-	sum += texture2D( _MainTex,uv + vec2(-halfpixel.x, halfpixel.y)) * 2.0;
-	sum += texture2D( _MainTex,uv + vec2(0.0, halfpixel.y * 2.0));
-	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, halfpixel.y)) * 2.0;
-	sum += texture2D( _MainTex,uv + vec2(halfpixel.x * 2.0, 0.0));
-	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, -halfpixel.y)) * 2.0;
-	sum += texture2D( _MainTex,uv + vec2(0.0, -halfpixel.y * 2.0));
-	sum += texture2D( _MainTex,uv + vec2(-halfpixel.x, -halfpixel.y)) * 2.0;
-	return sum / 12.0;
-}
-
-void main()
-{
-	vec2 half_pixel;
-	half_pixel.x = 0.5/_Resolution.x;
-	half_pixel.y = 0.5/_Resolution.y;
-	gl_FragColor = upsample(vUv, half_pixel);
-}
+uniform sampler2D _MainTex;
+uniform vec2 _Resolution;
+varying vec2 vUv;
+
+vec4 upsample(vec2 uv, vec2 halfpixel)
+{
+	vec4 sum = texture2D( _MainTex,uv + vec2(-halfpixel.x * 2.0, 0.0));
+	sum += texture2D( _MainTex,uv + vec2(-halfpixel.x, halfpixel.y)) * 2.0;
+	sum += texture2D( _MainTex,uv + vec2(0.0, halfpixel.y * 2.0));
+	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, halfpixel.y)) * 2.0;
+	sum += texture2D( _MainTex,uv + vec2(halfpixel.x * 2.0, 0.0));
+	sum += texture2D( _MainTex,uv + vec2(halfpixel.x, -halfpixel.y)) * 2.0;
+	sum += texture2D( _MainTex,uv + vec2(0.0, -halfpixel.y * 2.0));
+	sum += texture2D( _MainTex,uv + vec2(-halfpixel.x, -halfpixel.y)) * 2.0;
+	return sum / 12.0;
+}
+
+void main()
+{
+	vec2 half_pixel;
+	half_pixel.x = 0.5/_Resolution.x;
+	half_pixel.y = 0.5/_Resolution.y;
+	gl_FragColor = upsample(vUv, half_pixel);
+}

package/src/shaders/edge_visualizer/edge_visualizer.frag

@@ -1,18 +1,18 @@
-uniform vec3 _Color;
-uniform vec3 _LineColor;
-uniform float _Alpha;
-uniform float _Thickness;
-varying vec3 vBarycentric;
-
-float edgeFactor(vec3 baryc ){
-    vec3 d = fwidth(baryc);
-    vec3 a3 = smoothstep(vec3(0.0), d*_Thickness, baryc);
-    return min(min(a3.x, a3.y), a3.z);
-}
-
-void main()
-{	
-	float alpha = edgeFactor(vBarycentric + vec3(1. , 1., 0.));
-	gl_FragColor.rgb = mix(_LineColor, _Color, alpha);
-	gl_FragColor.a = mix(1.0 - alpha, 1.0, _Alpha);
+uniform vec3 _Color;
+uniform vec3 _LineColor;
+uniform float _Alpha;
+uniform float _Thickness;
+varying vec3 vBarycentric;
+
+float edgeFactor(vec3 baryc ){
+    vec3 d = fwidth(baryc);
+    vec3 a3 = smoothstep(vec3(0.0), d*_Thickness, baryc);
+    return min(min(a3.x, a3.y), a3.z);
+}
+
+void main()
+{	
+	float alpha = edgeFactor(vBarycentric + vec3(1. , 1., 0.));
+	gl_FragColor.rgb = mix(_LineColor, _Color, alpha);
+	gl_FragColor.a = mix(1.0 - alpha, 1.0, _Alpha);
 }

package/src/shaders/edge_visualizer/edge_visualizer.vert

@@ -1,16 +1,16 @@
-uniform float _DepthOffset;
-
-attribute vec3 barycentric;
-varying vec3 vBarycentric;
-void main()
-{
-
-  mat4 VP = projectionMatrix * viewMatrix;
-  vec3 pos = (modelMatrix * vec4(position, 1.0)).xyz;
-  gl_Position = VP * vec4(pos, 1.0);
-
-  gl_Position.xy = gl_Position.xy/gl_Position.w;
-  gl_Position.z = (gl_Position.z-_DepthOffset)/gl_Position.w;
-  gl_Position.w = 1.0;
-  vBarycentric = barycentric;
+uniform float _DepthOffset;
+
+attribute vec3 barycentric;
+varying vec3 vBarycentric;
+void main()
+{
+
+  mat4 VP = projectionMatrix * viewMatrix;
+  vec3 pos = (modelMatrix * vec4(position, 1.0)).xyz;
+  gl_Position = VP * vec4(pos, 1.0);
+
+  gl_Position.xy = gl_Position.xy/gl_Position.w;
+  gl_Position.z = (gl_Position.z-_DepthOffset)/gl_Position.w;
+  gl_Position.w = 1.0;
+  vBarycentric = barycentric;
 }

package/src/shaders/edges/corners.frag

@@ -1,11 +1,11 @@
-uniform float _Thickness;
-uniform vec3 _Color;
-varying vec2 vUv;
-void main()
-{	
-	vec2 circle_uv = vUv*2.0-1.0;
-	if(length(circle_uv) > 1.0)
-		discard;
-
-  gl_FragColor = vec4(_Color, 1.);
+uniform float _Thickness;
+uniform vec3 _Color;
+varying vec2 vUv;
+void main()
+{	
+	vec2 circle_uv = vUv*2.0-1.0;
+	if(length(circle_uv) > 1.0)
+		discard;
+
+  gl_FragColor = vec4(_Color, 1.);
 }