Selected Student Works
This is a small selection of student works from the 2022 class “Advanced Computer Graphics”. The objective was to create an image of a poison dart frog using a single fragment shader. You can see the full homework description if interested.
// credit: Is
// frog: Ranitomeya amazonica
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float random(vec2 co) {
const highp float seed = 12.9898;
highp float a = seed;
highp float b = 78.233, c = 43758.5453;
highp float dt = dot(co.xy, vec2(a, b));
highp float sn = mod(dt, 3.14159265358979323846);
return fract(sin(sn) * c);
}
vec2 random2(vec2 p) { return vec2(random(p), random(p * 1000.0)); }
float stripe(vec2 st) {
float min_dist = 100.;
for (int y = -1; y <= 1; y++) {
for (int x = -1; x <= 1; x++) {
vec2 neighbor = vec2(float(x), float(y));
vec2 point = random2(floor(st) + neighbor);
point = 0.5 * sin(u_time + 8.155 * point);
min_dist =
min(min_dist, length(neighbor + point - (st - floor(st))));
}
}
return min_dist * abs(sin(st.x * 7.288));
}
float dots(vec2 st, float r) {
float min_dist = 100.;
for (int y = -1; y <= 1; y++) {
for (int x = -1; x <= 1; x++) {
vec2 neighbor = vec2(float(x), float(y));
vec2 point = random2(floor(st) + neighbor);
min_dist =
min(min_dist, length(neighbor + point - (st - floor(st))));
}
}
return step(r, min_dist);
}
float fbm_dots(in vec2 st) {
float value = 1.0;
float r = 0.208;
st *= 6.952;
st += vec2(10.0, 100.0) + u_time * 0.452;
for (int i = 0; i < 6; i++) {
value = min(value, dots(st, r));
st *= 1.312;
}
return value;
}
void main() {
vec2 st = gl_FragCoord.xy / u_resolution.xy * 0.764 - -0.116;
st = vec2(st.y, 1.0 - st.x); // rotate
float mask = 1.000;
{
// right eye
vec2 st1 = st - vec2(0.730, 0.700);
st1.x = -0.160 - st1.x;
vec2 p = vec2(-0.010, 0.000);
if (0.001 > 1.0 * pow(st1.x - p.x, 2.0) + 1.0 * pow(st1.y - p.y, 2.0)) {
colour_out = vec4(vec3(0.0), 1.0);
if (0.0001 > 1.0 * pow(st1.x - p.x + 0.01 * sin(u_time), 2.0) +
1.0 * pow(st1.y - p.y + 0.01 * sin(u_time), 2.0)) {
colour_out = vec4(vec3(1.0), 1.0);
}
return;
}
}
{
// left eye
vec2 st1 = st - vec2(0.580, 0.700);
st1.x = -0.160 - st1.x;
vec2 p = vec2(0.000, 0.000);
if (0.001 > 1.0 * pow(st1.x - p.x, 2.0) + 1.0 * pow(st1.y - p.y, 2.0)) {
colour_out = vec4(vec3(0.0), 1.0);
if (0.0001 >
1.0 * pow(st1.x - p.x - 0.01 * cos(u_time - 3.14 / 2.0), 2.0) +
1.0 * pow(st1.y - p.y + 0.01 * cos(u_time - 3.14 / 2.0),
2.0)) {
colour_out = vec4(vec3(1.0), 1.0);
}
return;
}
}
{
// body
if ((0.282 >
distance(vec2(st.x * 2.508, st.y), vec2(2.508 / 2.0, 0.5)) ||
0.178 > distance(vec2(st.x * 1.276, st.y),
vec2(1.276 / 2.0, 0.396))) &&
abs(st.x - 0.5) + st.y - 0.648 <= 0.120) {
st *= 7.616;
colour_out =
vec4(step(0.236, stripe(st)) * mix(vec3(0.865, 0.854, 0.019),
vec3(0.865, 0.383, 0.006),
abs(sin(u_time))),
1.0);
return;
}
}
{
// right back leg
vec2 st1 = st - vec2(0.110, -0.190);
mask *= step(0.003, 1.0 * pow(st1.x - 0.5, 2.000) +
1.0 * pow(st1.y - 0.5, 2.0) +
-1.320 * (st1.x - 0.5) * (st1.y - 0.5));
vec2 p1 = vec2(0.516, 0.476);
mask *= step(0.005, 2.520 * pow(st1.x - p1.x, 2.0) +
1.0 * pow(st1.y - p1.y, 2.0) +
-2.176 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.548, 0.468);
mask *= step(0.002, 1.480 * pow(st1.x - p2.x, 2.0) +
1.0 * pow(st1.y - p2.y, 2.0) +
-2.120 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.620, 0.556);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.604, 0.564);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.644, 0.556);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.636, 0.540);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// right front leg
vec2 st1 = st - vec2(0.090, 0.040);
vec2 p1 = vec2(0.508, 0.492);
mask *= step(0.005, 2.216 * pow(st1.x - p1.x, 2.0) +
2.352 * pow(st1.y - p1.y, 2.0) +
3.368 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.572, 0.508);
mask *= step(0.002, 5.400 * pow(st1.x - p2.x, 2.0) +
0.368 * pow(st1.y - p2.y, 2.0) +
0.832 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.584, 0.592);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.576, 0.600);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.6, 0.592);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.592, 0.578);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// left back leg
vec2 st1 = st - vec2(0.110, -0.190);
st1.x = 0.784 - st1.x;
mask *= step(0.003, 1.0 * pow(st1.x - 0.5, 2.000) +
1.0 * pow(st1.y - 0.5, 2.0) +
-1.320 * (st1.x - 0.5) * (st1.y - 0.5));
vec2 p1 = vec2(0.516, 0.476);
mask *= step(0.005, 2.520 * pow(st1.x - p1.x, 2.0) +
1.0 * pow(st1.y - p1.y, 2.0) +
-2.176 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.548, 0.468);
mask *= step(0.002, 1.480 * pow(st1.x - p2.x, 2.0) +
1.0 * pow(st1.y - p2.y, 2.0) +
-2.120 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.620, 0.556);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.604, 0.564);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.644, 0.556);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.636, 0.540);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// left front leg
vec2 st1 = vec2(-st.x, st.y) - vec2(-0.910, 0.040);
vec2 p1 = vec2(0.508, 0.492);
mask *= step(0.005, 2.216 * pow(st1.x - p1.x, 2.0) +
2.352 * pow(st1.y - p1.y, 2.0) +
3.368 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.572, 0.508);
mask *= step(0.002, 5.400 * pow(st1.x - p2.x, 2.0) +
0.368 * pow(st1.y - p2.y, 2.0) +
0.832 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.584, 0.592);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.576, 0.600);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.6, 0.592);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.592, 0.578);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
if (mask == 0.0) {
// legs
colour_out = fbm_dots(st) * vec4(vec3(0.037, 0.475, 1.000), 1.0);
return;
} else {
// leaf
colour_out =
vec4(mix(vec3(0.221, 0.560, 0.044), vec3(0.320, 0.735, 0.235),
abs(sin(st.y * 100.0 + u_time * 5.0))),
1.0);
}
}
Ranitomeya amazonica by Is
// credit: ksaki73
// frog: Dendrobates auratus
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float sdCircle( vec2 p, float r ){
return length(p) - r;
}
vec4 light(in vec2 p, float size){
float x = u_resolution.x * p.x;
float y = u_resolution.y * p.y;
vec2 pos = vec2(x, y);
float dist = length(gl_FragCoord.xy - pos);
float color = pow(size / dist, 2.0);
return vec4(vec3(color), 1.0);
}
float sdEgg(in vec2 p, in float ra, in float rb, in float angle){
mat3 c = mat3(cos(angle), -1.0*sin(angle), 0,
sin(angle), cos(angle), 0,
0, 0, 1.0);
vec3 new_p = c * vec3(p.xy, 1.0);
const float k = sqrt(3.0);
float r = ra - rb;
new_p.x = abs(new_p.x);
return ((new_p.y<0.0) ? length(vec2(new_p.x, new_p.y )) - r :
(k*(new_p.x+r)<new_p.y) ? length(vec2(new_p.x, new_p.y-k*r)) :
length(vec2(new_p.x+r,new_p.y )) - 2.0*r)-rb;
}
float sdArc( in vec2 p, in vec2 sc, in float ra, float rb , in float angle){
mat3 c = mat3(cos(angle), -1.0*sin(angle), 0,
sin(angle), cos(angle), 0,
0, 0, 1.0);
vec3 new_p = c * vec3(p.xy, 1.0);
new_p.x = abs(new_p.x);
return ((sc.y*new_p.x>sc.x*new_p.y) ? length(new_p.xy-sc*ra) :
abs(length(new_p.xy)-ra)) - rb;
}
vec2 sincos(in float angle){
return vec2(sin(angle),cos(angle));
}
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v){
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
vec2 i1;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
i = mod289(i);
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) + i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
float fbm(vec2 p){
float f = 0.0, scale;
for (int i=0; i<4; i++){
scale = pow(pow(2.0, 4.0/3.0), float(i));
f += snoise(p*scale) / scale;
}
return f;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
float noise = fbm(st/0.03);
int color=0;
float r = 0.2;
vec2 h_light;
if (sdArc(st-vec2(0.500,0.620), sincos(0.3), 0.2, 0.015, 2.164)<=0.0) color = 1; //l-f fing
if (sdArc(st-vec2(0.450,0.620), sincos(0.3), 0.2, 0.015, 2.364)<=0.0) {
color = 1; //l-f fing
if (sdEgg(st-vec2(0.240,0.520), 0.08, 0.1, -1.348) <= 0.0) color = 2;
}
if (sdArc(st-vec2(0.380,0.420), sincos(0.3), 0.2, 0.015, 2.364)<=0.0) {
color = 1; //l-b fing
if (sdEgg(st-vec2(0.170,0.350), 0.08, 0.1, -0.900) <= 0.0) color = 2;
}
if (sdArc(st-vec2(0.460,0.400), sincos(0.3), 0.2, 0.015, 1.948)<=0.0) color = 1; //l-b fing
if (sdArc(st-vec2(0.500,0.620), sincos(0.3), 0.2, 0.015, -2.164)<=0.0) {
color = 1;
if (sdEgg(st-vec2(0.760,0.560), 0.08, 0.1, -1.348) <= 0.0) color = 2;
}
if (sdArc(st-vec2(0.55,0.620), sincos(0.3), 0.2, 0.015, -2.364)<=0.0) {
color = 1;
if (sdEgg(st-vec2(0.760,0.560), 0.08, 0.1, -1.348) <= 0.0) color = 2;
}
if (sdArc(st-vec2(0.62,0.420), sincos(0.3), 0.2, 0.015, -2.364)<=0.0) color = 1;
if (sdArc(st-vec2(0.54,0.400), sincos(0.3), 0.2, 0.015, -1.948)<=0.0) {
color = 1;
if (sdEgg(st-vec2(0.760,0.440), 0.08, 0.1, -0.900) <= 0.0) color = 2;
}
if (sdEgg(st-vec2(0.350,0.230), 0.10, 0.05, 0.65) <= 0.0){
color = 1;
if (sdArc(st-vec2(0.250,0.100), sincos(0.5), 0.1, 0.02, -0.690)<=0.0) color = 2;
if (sdEgg(st-vec2(0.420,0.120), 0.08, 0.1, -0.900) <= 0.0) color = 2;
}
if (sdEgg(st-vec2(0.650,0.230), 0.10, 0.05, -0.65) <= 0.0){
color = 1;
if (sdArc(st-vec2(0.750,0.100), sincos(0.5), 0.1, 0.02, 0.690)<=0.0) color = 2;
if (sdEgg(st-vec2(0.580,0.120), 0.08, 0.1, 0.900) <= 0.0) color = 2;
}
if (sdEgg(st-vec2(0.5,0.3), 0.2, 0.0, 0.0) <= 0.0) {
color = 1;
if (sdEgg(st-vec2(0.360,0.370), 0.08, 0.01, -2.3) <= 0.0) color = 2;
if (sdEgg(st-vec2(1.0-0.360,0.370), 0.08, 0.01, 2.3) <= 0.0) color = 2;
if (sdEgg(st-vec2(0.420,0.120), 0.08, 0.1, -0.900) <= 0.0) color = 2;
if (sdEgg(st-vec2(0.580,0.120), 0.08, 0.1, 0.900) <= 0.0) color = 2;
}
if (sdArc(st-vec2(0.500,0.220), sincos(0.5), 0.1, 0.02, 3.14)<=0.0) color = 2;
if (sdEgg(st-vec2(0.500,0.650), 0.07, 0.06, 0.0) <= 0.0) color = 1;
if (sdEgg(st-vec2(0.500,0.520), 0.15, 0.11, 0.0) <= 0.0) color = 1;
if (sdEgg(st-vec2(0.500,0.520), 0.15, 0.11, 0.0) <= 0.0) color = 1;
if (sdEgg(st-vec2(0.500,0.550), 0.11, 0.03, 3.14) <= 0.0) color = 2;
if (sdEgg(st-vec2(0.500,0.590), 0.09, 0.1, 0.0) <= 0.0) color = 2;
if (sdEgg(st-vec2(0.500,0.270), 0.07, 0.08, 0.0) <= 0.0) color = 2; // low circle
if (sdArc(st-vec2(0.610,0.463), sincos(0.2), 0.2, 0.02, -3.984)<=0.0) color = 2;
if (sdArc(st-vec2(0.390,0.463), sincos(0.2), 0.2, 0.02, 3.984)<=0.0) color = 2;
if (sdEgg(st-vec2(0.400,0.650), 0.04, 0.08, -2.290) <= 0.0) color = 2; //eye
if (sdEgg(st-vec2(0.600,0.650), 0.04, 0.08, 2.290) <= 0.0) color = 2; //eye
if (color==1) colour_out = vec4(121.0/255.0,219.0/255.0, 209.0/255.0, noise/4.0 +1.0 ) ;
else if (color==2) colour_out = vec4(0.0, 0.0, 0.0, 1.0 );
else colour_out = vec4(1.0,1.0,1.0,1.0);
if (sdEgg(st-vec2(0.400,0.650), 0.04, 0.08, -2.290) <= 0.0) {
color = 2; //eye
h_light = vec2(0.400,0.670);
if (sdCircle(st-h_light, 0.02) <= 0.0) colour_out = light(h_light, 2.0);
}
if (sdEgg(st-vec2(0.600,0.650), 0.04, 0.08, 2.290) <= 0.0) {
color = 2; //eye
h_light = vec2(0.600,0.670);
if (sdCircle(st-h_light, 0.02) <= 0.0) colour_out = light(h_light, 2.0);
}
}
2. Dendrobates auratus by ksaki73
// credit: hosono
// frog: Dendrobates auratus
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float M_PI = 3.14159265359;
vec4 mod289(vec4 x)
{
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x)
{
return mod289(((x*34.0)+10.0)*x);
}
vec4 taylorInvSqrt(vec4 r)
{
return 1.79284291400159 - 0.85373472095314 * r;
}
vec2 fade(vec2 t) {
return t*t*t*(t*(t*6.0-15.0)+10.0);
}
// Classic Perlin noise
float cnoise(vec2 P)
{
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
vec4 gy = abs(gx) - 0.5 ;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x,gy.x);
vec2 g10 = vec2(gx.y,gy.y);
vec2 g01 = vec2(gx.z,gy.z);
vec2 g11 = vec2(gx.w,gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
float sdEllipse(vec2 p, vec2 ab)
{
p = abs(p); if( p.x > p.y ) {p=p.yx;ab=ab.yx;}
float l = ab.y*ab.y - ab.x*ab.x;
float m = ab.x*p.x/l; float m2 = m*m;
float n = ab.y*p.y/l; float n2 = n*n;
float c = (m2+n2-1.0)/3.0; float c3 = c*c*c;
float q = c3 + m2*n2*2.0;
float d = c3 + m2*n2;
float g = m + m*n2;
float co;
if( d<0.0 )
{
float h = acos(q/c3)/3.0;
float s = cos(h);
float t = sin(h)*sqrt(3.0);
float rx = sqrt( -c*(s + t + 2.0) + m2 );
float ry = sqrt( -c*(s - t + 2.0) + m2 );
co = (ry+sign(l)*rx+abs(g)/(rx*ry)- m)/2.0;
}
else
{
float h = 2.0*m*n*sqrt( d );
float s = sign(q+h)*pow(abs(q+h), 1.0/3.0);
float u = sign(q-h)*pow(abs(q-h), 1.0/3.0);
float rx = -s - u - c*4.0 + 2.0*m2;
float ry = (s - u)*sqrt(3.0);
float rm = sqrt( rx*rx + ry*ry );
co = (ry/sqrt(rm-rx)+2.0*g/rm-m)/2.0;
}
vec2 r = ab * vec2(co, sqrt(1.0-co*co));
return length(r-p) * sign(p.y-r.y);
}
float sdEquilateralTriangle(vec2 p)
{
const float k = sqrt(3.0);
p.x = abs(p.x) - 1.0;
p.y = p.y + 1.0/k;
if( p.x+k*p.y>0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
p.x -= clamp( p.x, -2.0, 0.0 );
return -length(p)*sign(p.y);
}
float sdMainBody(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.6, 0.35));
}
float sdHead(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEquilateralTriangle(5.232 * R * (P - slides)) - 0.8;
}
float sdUpperLeg(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.4, 0.1));
}
float sdLowerLeg(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.47, 0.13));
}
float sdFoot(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.3, 0.1));
}
float sdUpperArm(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.15, 0.05));
}
float sdLowerArm(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.23, 0.04));
}
vec3 get_bg_color(vec2 P) {
vec3 color1 = vec3(0.643,0.525,0.392);
vec3 color2 = vec3(0.447,0.474,0.514);
vec3 color3 = vec3(0.698,0.733,0.776);
float t = step(0.1, cnoise(2.0*P));
float u = step(0.3, cnoise(5.0*P));
vec3 out_color = mix(color1, mix(color2, color3, u), t);
out_color = mix(out_color, vec3(0.0), cnoise(200.0*P)*0.5);
return out_color;
}
vec3 get_frog_color(vec2 P) {
vec3 blue = vec3(0.43,0.71,0.90);
vec3 black = vec3(0.0);
float t = step(0.05, cnoise(12.0*P));
return mix(blue, black, t);
}
float get_frog_mask(vec2 P) {
P = P*2.0 - 1.0; // -1.0 <= P <= 1.0
float mask = 1.0;
mask *= step(0.0, sdMainBody(P, vec2(0.0, 0.1), -10.0));
mask *= step(0.0, sdHead(P, vec2(-0.5,0.2), 89.840));
mask *= step(0.0, sdUpperLeg(P, vec2(0.3, -0.2), 40.0));
mask *= step(0.0, sdLowerLeg(P, vec2(0.33, -0.35), 20.0));
mask *= step(0.0, sdFoot(P, vec2(0.6, -0.43), 70.0));
mask *= step(0.0, sdUpperArm(P, vec2(-0.22,-0.25), -30.0));
mask *= step(0.0, sdLowerArm(P, vec2(-0.31,-0.42), 30.0));
return mask;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec4 bg_color = vec4(get_bg_color(st), 1.0);
vec4 frog_color = vec4(get_frog_color(st), 1.0);
float mask = get_frog_mask(st.xy);
colour_out = mix(frog_color, bg_color, mask);
}
4. unknown by hosono
// credit: jenniroutine
// frog: Dendrobates_leucomelas
precision mediump float;
uniform vec2 u_resolution;
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 3.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 230.0 * dot(m, g) ;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
float mask = 1.0;
mask *= step( 0.096, distance( st.xy, vec2(0.690,0.690) ) );
mask *= step( 0.064, distance( st.xy, vec2(0.740,0.720) ) );
mask *= step( 0.056, distance( st.xy, vec2(0.660,0.740) ) );
mask *= step( 0.146, distance( st.xy, vec2(0.580,0.520) ) );
mask *= step( 0.166, distance( st.xy, vec2(0.540,0.450) ) );
mask *= step( 0.166, distance( st.xy, vec2(0.520,0.380) ) );
mask *= step( 0.082, distance( st.xy, vec2(0.370,0.280) ) );
float s = 1.048 + -0.348 * 0.864;
mask *= step( 0.072, distance( vec2(st.x*s,st.y), vec2(0.360,0.220) ) );
mask *= step( 0.064, distance( st.xy, vec2(0.570,0.150) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.510,0.110) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.470,0.100) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.430,0.100) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.390,0.110) ) );
mask *= step( 0.032, distance( st.xy, vec2(0.520,0.070) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.680,0.390) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.690,0.340) ) );
mask *= step( 0.035, distance( st.xy, vec2(0.710,0.300) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.740,0.280) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.770,0.260) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.290,0.280) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.270,0.260) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.260,0.250) ) );
float n = snoise( gl_FragCoord.xy / 30.0 );
n = n*0.5 + 0.5; /* Map from [-1,1] to [0,1] */
colour_out = vec4( vec2(n), 0.0, 1.0 );
if (step( 0.050, distance( st.xy, vec2(0.730,0.630) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.050, distance( st.xy, vec2(0.790,0.670) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
s = 1.024 + -0.332 * 0.936;
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.400,0.590) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.450,0.560) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.310,0.400) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.410,0.340) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
colour_out *= 1.0-mask;
}
6. Dendrobates leucomelas by jenniroutine
// name: oguni
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
// --------------------------------------------------------------------
// https://github.com/stegu/webgl-noise/blob/master/src/noise2D.glsl
//
// Description : Array and textureless GLSL 2D simplex noise function.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v) {
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
vec4 mod289(vec4 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x) {
return mod289(((x*34.0)+10.0)*x);
}
vec4 taylorInvSqrt(vec4 r) {
return 1.79284291400159 - 0.85373472095314 * r;
}
// https://github.com/stegu/webgl-noise/blob/master/src/noise3D.glsl
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmod : 20201014 (stegu)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
float snoise(vec3 v) {
const vec2 C = vec2(1.0/6.0, 1.0/3.0) ;
const vec4 D = vec4(0.0, 0.5, 1.0, 2.0);
// First corner
vec3 i = floor(v + dot(v, C.yyy) );
vec3 x0 = v - i + dot(i, C.xxx) ;
// Other corners
vec3 g = step(x0.yzx, x0.xyz);
vec3 l = 1.0 - g;
vec3 i1 = min( g.xyz, l.zxy );
vec3 i2 = max( g.xyz, l.zxy );
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
vec3 x1 = x0 - i1 + C.xxx;
vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
vec4 p = permute( permute( permute(
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
float n_ = 0.142857142857; // 1.0/7.0
vec3 ns = n_ * D.wyz - D.xzx;
vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
vec4 x_ = floor(j * ns.z);
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
vec4 x = x_ *ns.x + ns.yyyy;
vec4 y = y_ *ns.x + ns.yyyy;
vec4 h = 1.0 - abs(x) - abs(y);
vec4 b0 = vec4( x.xy, y.xy );
vec4 b1 = vec4( x.zw, y.zw );
// vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
// vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
vec4 s0 = floor(b0)*2.0 + 1.0;
vec4 s1 = floor(b1)*2.0 + 1.0;
vec4 sh = -step(h, vec4(0.0));
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
vec3 p0 = vec3(a0.xy,h.x);
vec3 p1 = vec3(a0.zw,h.y);
vec3 p2 = vec3(a1.xy,h.z);
vec3 p3 = vec3(a1.zw,h.w);
// Normalise gradients
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
vec4 m = max(0.5 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
m = m * m;
return 105.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
dot(p2,x2), dot(p3,x3) ) );
}
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// https://iquilezles.org/articles/distfunctions2d/
float sdSegment( in vec2 p, in vec2 a, in vec2 b )
{
vec2 pa = p-a, ba = b-a;
float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length( pa - ba*h );
}
// --------------------------------------------------------------------
float gamma_map(float x) {
return pow(x, 1.0/2.2);
}
float blurstep(float s, float x) {
return smoothstep(s - 0.01, s + 0.01, x);
}
float blurstep_foot(float s, float x) {
return smoothstep(s - 0.005, s + 0.0, x);
}
float mouse_y() {
return max(u_mouse.y, 0.1); // Without this, horror images are created when u_mouse.y is near 0.0
}
float frogmask(vec2 st) {
float mask = 1.0;
// head
mask *= blurstep(0.08, distance(st, vec2(0.23, 0.54 + pow(mouse_y(), 0.9) * 0.0006)));
mask *= blurstep(0.1, distance(st, vec2(0.29, 0.53 + pow(mouse_y(), 0.9) * 0.0005)));
mask *= blurstep(0.12, sdSegment(st, vec2(0.35, 0.5 + pow(mouse_y(), 0.9) * 0.0003), vec2(0.5, 0.4)));
// vocal sac
mask *= blurstep(0.08, distance(st, vec2(0.32, 0.47 - smoothstep(0.6, 0.8, smoothstep(sin(u_time * 2.0), -0.5, -1.0) * sin(u_time * 16.0)) * 0.02 + pow(mouse_y(), 0.9) * 0.0006)));
// body
mask *= blurstep(0.15, sdSegment(st, vec2(0.5, 0.4), vec2(0.7, 0.3)));
// left hind leg
mask *= blurstep_foot(0.06, sdSegment(st, vec2(0.670,0.200), vec2(0.430,0.120)));
mask *= blurstep_foot(0.03, sdSegment(st, vec2(0.430,0.120), vec2(0.750,0.110)));
mask *= blurstep_foot(0.03, sdSegment(st, vec2(0.750,0.110), vec2(0.490,0.040)));
// left hind foot fingers
vec2 a = vec2(0.7, 0.1) - vec2(0.3, 0.2);
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.070,0.140) + a, vec2(-0.010,0.130) + a));
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.090,0.130) + a, vec2(0.030,0.090) + a));
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.29, 0.18) + a, vec2(0.2, 0.2) + a));
// right hind leg
mask *= blurstep_foot(0.07, sdSegment(st, vec2(0.780,0.200) + vec2(0.05, 0.05), vec2(0.770,0.330) + vec2(0.05, 0.05)));
mask *= blurstep_foot(0.03, sdSegment(st, vec2(0.770,0.330) + vec2(0.05, 0.05), vec2(0.820,0.150) + vec2(0.05, 0.05)));
mask *= blurstep_foot(0.03, sdSegment(st, vec2(0.820,0.150) + vec2(0.05, 0.05), vec2(0.840,0.290) + vec2(0.05, 0.05)));
// left arm
mask *= blurstep_foot(0.035, sdSegment(st, vec2(0.6, 0.3), vec2(0.3, 0.2)));
// left hand fingers
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.3, 0.2), vec2(0.28, 0.26)));
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.3, 0.2), vec2(0.21, 0.25)));
mask *= blurstep_foot(0.014, sdSegment(st, vec2(0.3, 0.17), vec2(0.2, 0.2)));
return mask;
}
vec3 draw(vec2 st) {
vec2 st_frog = (st - vec2(-0.12, 0.1)) * 0.9;
vec2 mouse01 = 1.0 + u_mouse * 0.00001;
float pattern = snoise(st_frog * 8.0 + vec2(0.0, -mouse_y() * 0.003 * (1.0-st.x) * smoothstep(0.3, 1.0, st.y)));
pattern = mix(-1.0, pattern, smoothstep(0.0, 0.3, distance(vec2(0.920,0.150), st_frog)));
pattern = mix(-1.0, pattern, smoothstep(0.0, 0.3, distance(vec2(0.350,0.140), st_frog)));
float highlights = pow(
(snoise(vec3((st_frog + vec2(10.0, 10.0) - u_mouse * 0.0001) * 10.000 * mouse01.x, 6.0 + sin(u_time * 0.5) * 0.1)) + 0.2) *
(snoise(vec3((st_frog + vec2(10.8, 10.8) - u_mouse * 0.0001) * 10.0 * mouse01.y, 5.0 + sin(u_time * 0.5) * 0.1)) + 0.2),
2.0
);
highlights = pow(highlights, 2.0);
vec3 frog;
if (pattern < 0.1) {
float d = (0.1 - pattern) / 0.4;
frog = vec3(0.074,0.099,0.380) + d * vec3(0.057,0.053,0.120);
} else {
frog = vec3(0.1, 0.1, 0.1);
}
frog += highlights;
vec2 eye_center = vec2(0.280, 0.520 + pow(mouse_y(), 0.9) * 0.0005);
float eye_distance = length((st_frog - eye_center) * vec2(2.0, 2.3)) - 0.04;
// eye
float d = max(0.0, 1.0 - distance(st_frog - vec2(-0.015, 0.01), eye_center) / 0.04 * 4.0);
float eye_t = smoothstep(0.04, 0.02, eye_distance);
frog = mix(frog, vec3(pow(d, 2.0)), eye_t * 0.9);
frog.xyz += min(0.0, -(1.0-st.y - 0.4) * 1.0);
frog.xyz *= 1.0 + (
snoise((st_frog * 8.0 + vec2(0.0, -mouse_y() * 0.003 * (1.0-st.x) * smoothstep(0.3, 1.0, st.y))) * 10.0) * 0.04 +
snoise((st_frog * 8.0 + vec2(0.0, -mouse_y() * 0.003 * (1.0-st.x) * smoothstep(0.3, 1.0, st.y))) * 20.0) * 0.05 +
snoise((st_frog * 8.0 + vec2(0.0, -mouse_y() * 0.003 * (1.0-st.x) * smoothstep(0.3, 1.0, st.y))) * 40.0) * 0.025
) * 3.0;
// background
vec2 st_background = vec2((st.x - 0.5) * pow(st.y + 1.0, 1.5), log(1.0-(st.y - 0.01)));
float background_noise =
snoise(st_background * 20.0) * 0.3 *
snoise((st_background + vec2(0.0, 0.03)) * 20.0) * 0.3 +
snoise(vec3((st_background) * 1.0, sin(u_time) * 0.1)) * 0.2;
vec3 background = vec3(0.440, 0.367, 0.269) + background_noise;
// shadow
background.xyz -= (1.0 - frogmask(st_frog + vec2(0.0 - smoothstep(0.3, 0.6, st.y) * 0.3, 0.01 + smoothstep(0.3, 0.6, st.y) * 0.5))) * 0.3;
background.xyz -= (1.0 - frogmask((st_frog + vec2(0.0, 0.02)) + vec2(0.0 - smoothstep(0.3, 0.6, st.y) * 0.3, 0.01 + smoothstep(0.3, 0.6, st.y) * 0.5))) * 0.1;
background.xyz -= smoothstep(0.5, 0.0, distance(vec2(0.540,0.700), st * vec2(1.0, 2.0))) * 0.3;
float mask = frogmask(st_frog);
return mix(frog.xyz, background, mask);
}
void main() {
vec2 st = gl_FragCoord.xy / u_resolution.xy;
vec3 col = draw(st);
colour_out = vec4(col * 1.5 + smoothstep(0.4, 0.7, col) * 1.0, 1.0);
}
7. Dendrobates tinctorius by oguni
// credit: shaw
// frog: Dendrobates tinctorius Freetoast
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float hash( float n )
{
return fract(sin(n)*43758.5453);
}
float noise( vec2 x )
{
vec2 p = floor(x);
vec2 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*57.0;
return mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x),
mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y);
}
float marbleturbulence(vec2 p) {
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(2.0, 4.0 / 3.0), float(i));
f += abs(noise( p * scale )) / scale;
}
return f;
}
mat2 m = mat2( 0.8, 0.6, -0.6, 0.8 );
float fbm( vec2 p ) {
float f = 0.0;
f += 0.5000 * noise( p ); p *= m*2.02;
f += 0.2500 * noise( p ); p *= m*2.01;
f += 0.1250 * noise( p ); p *= m*2.03;
f += 0.0625 * noise( p ); p *= m*2.04;
f /= 0.9375;
return f;
}
void main() {
vec2 p = gl_FragCoord.xy/u_resolution.xy;
float mask = 1.0;
mask *= step( 0.5, distance( p.xy, vec2(0.50,0.060) ) ); // down
mask *= step( 0.18, distance( p.xy, vec2(0.310,0.410) ) ); // right
mask *= step( 0.18, distance( p.xy, vec2(0.690,0.410) ) ); // left
vec3 background = vec3(89.0 / 255.0, 151.0 / 255.0, 30.0 / 255.0);
vec3 mouth = vec3(184.0 / 255.0, 223.0 / 255.0, 200.0 / 255.0);
// background fbm
float f = fbm(1.0 * p);
vec3 col = mix(background, vec3(0.1, 0.1, 0.1), f);
// head
vec3 head = vec3( 172.0 / 255.0, 229.0 / 255.0, 210.0 / 255.0 );
col = mix(head, col, mask);
if(mask == 0.0) {
// skin: random dots
vec2 ti = floor(9.0 + p / 0.08);
vec2 uv = fract(p / 0.08) - 0.5;
float rho = fract(111.0 * sin(1111.0 * ti.x + 1331.0 * ti.y));
rho = smoothstep(0.6, 1.1, rho)*exp(-dot(uv,uv)*24.0);
col *= mix(head, vec3(0.0), rho);
// skin: random black bars
float n = marbleturbulence(gl_FragCoord.xy / 500.0);
float t = 1.0 + sin(gl_FragCoord.x / 80.0 + 20.0 * n) / 2.0;
col = mix(col, 1.0 - vec3(t), 0.4*t);
// mouth
f = 1.0 - step(0.50, length(p - vec2(0.5, -0.25)));
col = mix(col, mouth, f);
f = 1.0 - step(0.05, length(p - vec2(0.35, 0.21)));
col = mix(col, mouth, f);
f = 1.0 - step(0.05, length(p - vec2(0.65, 0.21)));
col = mix(col, mouth, f);
// left eye
float r = length(p - vec2(0.690,0.410));
// outmost
f = 1.0 - smoothstep(0.09, 0.12, r);
col = mix(col, vec3(1.0), f);
// gray part
f = 1.0 - smoothstep(0.085, 0.1, r);
col = mix(col, vec3(0.15, 0.15, 0.15), f);
// yellow part
//f = 1.0 - smoothstep(0.03, 0.10, r);
//col = mix(col, vec3(0.9, 0.6, 0.2), f);
// center black circle
//f = 1.0 - smoothstep(0.02, 0.04, r);
//col = mix(col, vec3(0.0, 0.0, 0.0), f);
// highlight
f = 1.0 - smoothstep(0.0, 0.03, length(p - vec2(0.720, 0.420)));
col += vec3(1.0, 0.9, 0.8) * vec3(f) * 0.9;
// right eye
r = length(p - vec2(0.310,0.410));
f = 1.0 - smoothstep(0.09, 0.12, r);
col = mix(col, vec3(1.0), f);
f = 1.0 - smoothstep(0.085, 0.1, r);
col = mix(col, vec3(0.15, 0.15, 0.15), f);
f = 1.0 - smoothstep(0.0, 0.03, length(p - vec2(0.340, 0.420)));
col += vec3(1.0, 0.9, 0.8) * vec3(f) * 0.9;
}
colour_out = vec4(col, 1.0);
}
10. Dendrobates tinctorius Freetoast by
shaw
// credit: Tori
// frog: Dendrobates galactonotus
uniform vec2 u_resolution;
float myCircle( vec2 p, vec2 center, float r, float threshold )
{
return step( threshold, length( p-center ) - r );
}
float myUnevenCapsule( vec2 p, float r1, float r2, float h, float offset, float threshold )
{
p.x = abs(p.x - 0.5);
p.y -= offset;
float b = (r2-r1)/h;
float a = sqrt(1.0-b*b);
float k = dot(p,vec2(-b,a));
float val;
if( k < 0.0 )
val = length(p) - r2;
else if( k > a*h )
val = length(p-vec2(0.0,h)) - r1;
else
val = dot(p, vec2(a,b) ) - r2;
return step( threshold, val );
}
float myFrogLimb( vec2 pos, vec2 A, vec2 B, vec2 C, float threshold )
{
vec2 a = B - A;
vec2 b = A - 2.0*B + C;
vec2 c = a * 2.0;
vec2 d = A - pos;
float kk = 1.0/dot(b,b);
float kx = kk * dot(a,b);
float ky = kk * (2.0*dot(a,a)+dot(d,b)) / 3.0;
float kz = kk * dot(d,a);
float res = 0.0;
float p = ky - kx*kx;
float p3 = p*p*p;
float q = kx*(2.0*kx*kx-3.0*ky) + kz;
float h = q*q + 4.0*p3;
if( h >= 0.0 )
{
h = sqrt(h);
vec2 x = (vec2(h,-h)-q)/2.0;
vec2 uv = sign(x)*pow(abs(x), vec2(1.0/3.0));
float t = clamp( uv.x+uv.y-kx, 0.0, 1.0 );
res = dot(d + (c + b*t)*t, d + (c + b*t)*t );
}
else
{
float z = sqrt(-p);
float v = acos( q/(p*z*2.0) ) / 3.0;
float m = cos(v);
float n = sin(v)*1.732050808;
vec3 t = clamp(vec3(m+m,-n-m,n-m)*z-kx,0.0,1.0);
res = min( dot(d+(c+b*t.x)*t.x, d+(c+b*t.x)*t.x),
dot(d+(c+b*t.y)*t.y, d+(c+b*t.y)*t.y) );
}
return step( threshold, sqrt( res ) );
}
float myFrogHand( vec2 p, float r, vec2 root, float arg, float threshold )
{
arg = arg * 3.14159 / 180.0;
p -= root;
float tmp = p.x;
arg -= 1.570795;
p.x = p.x * cos( arg ) - p.y * sin( arg );
p.y = tmp * sin( arg ) + p.y * cos( arg );
p += root;
if( atan( p.x - root.x, p.y - root.y ) < 0.0 )
return 1.0;
p = abs( p - root );
float an = 3.141593/8.0;
float en = 3.141593/7.0;
vec2 acs = vec2(cos(an),sin(an));
vec2 ecs = vec2(cos(en),sin(en));
float bn = mod(atan(p.x,p.y)+0.3925,2.0*an) - an;
p = length(p)*vec2(cos(bn),abs(sin(bn)));
p -= r*acs;
p += ecs*clamp( -dot(p,ecs), 0.0, r*acs.y/ecs.y);
return step( threshold, length(p)*sign(p.x) );
}
vec3 myBodyColor( vec2 p ){
float scale = 5.0;
p *= scale;
p.x += 0.4;
p.y += ( p.x - fract( p.x ) ) * 0.4;
vec2 center = vec2( p.x - fract( p.x ) + 0.5, p.y - fract( p.y ) + 0.5 );
float mask = step( 0.4, length( center - p ) );
return mask * vec3( 0.525, 0.922, 0.204 );
}
vec3 myLimbColor( vec2 p ){
float scale = 20.0;
p *= scale;
p.y += ( p.x - fract( p.x ) ) * 0.5;
vec2 center = vec2( p.x - fract( p.x ) + 0.5, p.y - fract( p.y ) + 0.5 );
float mask = step( 0.4, length( center - p ) );
return mask * vec3( 0.204, 0.729, 0.922 );
}
vec3 myBackColor( vec2 p ){
float sum1 = 2.0 * p.x + p.y;
float sum2 = p.x + 2.0 * p.y;
float diff = p.y - p.x;
float branchMask = 1.0;
branchMask = min( branchMask, step( 0.03, abs( diff + 0.3 ) ) );
if( diff > -0.3 ){
branchMask = min( branchMask, step( 0.03, abs( sum1 - 1.3 ) ) );
branchMask = min( branchMask, step( 0.03, abs( sum1 - 0.7 ) ) );
}else{
branchMask = min( branchMask, step( 0.03, abs( sum2 - 1.5 ) ) );
branchMask = min( branchMask, step( 0.03, abs( sum2 - 0.5 ) ) );
}
return mix( vec3( 0.541, 0.431, 0.275 ), vec3( 0.518, 0.580, 0.388 ), branchMask );
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
// body
float headRadius = 0.02;
float bodyRadius = 0.10;
float bodyLength = 0.4;
float bodyOffset = 0.3;
float bodyThreshold = 0.1;
// eye
float eyeRadius = 0.025;
vec2 leftEyeCenter = vec2( 0.4, 0.8 );
vec2 rightEyeCenter = vec2( 0.6, 0.8 );
float eyeThreshold = 0.01;
// arm
float armThreshold = 0.015;
vec2 leftArmRoot = vec2( 0.375, 0.65 );
vec2 leftArmAnchor = vec2( 0.3, 0.5 );
vec2 leftArmTip = vec2( 0.3, 0.7 );
vec2 rightArmRoot = vec2( 0.64, 0.6 );
vec2 rightArmAnchor = vec2( 0.675, 0.45 );
vec2 rightArmTip = vec2( 0.8, 0.6 );
// leg
float legThreshold = 0.02;
vec2 leftLegRoot = vec2( 0.35, 0.2 );
vec2 leftLegAnchor1 = vec2( 0.2, 0.5 );
vec2 leftLegJoint = vec2( 0.29, 0.2 );
vec2 leftLegAnchor2 = vec2( 0.4, 0.0 );
vec2 leftLegTip = vec2( 0.2, 0.3 );
vec2 rightLegRoot = vec2( 0.65, 0.2 );
vec2 rightLegAnchor1 = vec2( 0.8, 0.5 );
vec2 rightLegJoint = vec2( 0.71, 0.2 );
vec2 rightLegAnchor2 = vec2( 0.6, 0.0 );
vec2 rightLegTip = vec2( 0.8, 0.2 );
// hand
float handThreshold = 0.01;
float handSize = 0.1;
vec2 leftHandRoot = vec2( 0.3, 0.7 );
float leftHandArg = -10.0;
vec2 rightHandRoot = vec2( 0.8, 0.6 );
float rightHandArg = 20.0;
// foot
float footThreshold = 0.01;
float footSize = 0.1;
vec2 leftFootRoot = vec2( 0.2, 0.3 );
float leftFootArg = -35.0;
vec2 rightFootRoot = vec2( 0.8, 0.2 );
float rightFootArg = 45.0;
// background
float backMask = 1.0;
float bodyMask = 1.0;
bodyMask = min( bodyMask, myUnevenCapsule( st, headRadius, bodyRadius, bodyLength, bodyOffset, bodyThreshold ) );
bodyMask = min( bodyMask, myCircle( st, leftEyeCenter, eyeRadius, eyeThreshold ) );
bodyMask = min( bodyMask, myCircle( st, rightEyeCenter, eyeRadius, eyeThreshold ) );
backMask = min( backMask, bodyMask );
bodyMask = 1.0 - bodyMask;
vec3 bodyColor = myBodyColor( st );
bodyColor *= bodyMask;
float limbMask = 1.0;
limbMask = min( limbMask, myFrogLimb( st, leftArmRoot, leftArmAnchor, leftArmTip, armThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightArmRoot, rightArmAnchor, rightArmTip, armThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, leftLegRoot, leftLegAnchor1, leftLegJoint, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, leftLegJoint, leftLegAnchor2, leftLegTip, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightLegRoot, rightLegAnchor1, rightLegJoint, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightLegJoint, rightLegAnchor2, rightLegTip, legThreshold ) );
limbMask = min( limbMask, myFrogHand( st, handSize, leftHandRoot, leftHandArg, handThreshold ) );
limbMask = min( limbMask, myFrogHand( st, handSize, rightHandRoot, rightHandArg, handThreshold ) );
limbMask = min( limbMask, myFrogHand( st, footSize, leftFootRoot, leftFootArg, footThreshold ) );
limbMask = min( limbMask, myFrogHand( st, footSize, rightFootRoot, rightFootArg, footThreshold ) );
backMask = min( backMask, limbMask );
limbMask = 1.0 - limbMask;
vec3 limbColor = myLimbColor( st );
limbColor *= limbMask;
vec3 backColor = myBackColor( st );
colour_out = vec4( backColor * backMask, 1.0 );
colour_out += vec4( max( bodyColor, limbColor ), 1.0 );
}
12. Dendrobates galactonotus by Tori
// Name - LeeHyeonJoon
// Scientific Name of the Frog - Oophaga pumilio (strawberry poison-dart frog)
uniform vec2 u_resolution;
// Modulo 289 without a division (only multiplications)
vec3 mod289(vec3 x){
return x-floor(x*(1./289.))*289.;
}
vec2 mod289(vec2 x){
return x-floor(x*(1./289.))*289.;
}
// Modulo 7 without a division
vec3 mod7(vec3 x){
return x-floor(x*(1./7.))*7.;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec3 permute(vec3 x){
return mod289((34.*x+10.)*x);
}
// Cellular (Worley) noise, returning F1 and F2 in a vec2.
// Standard 3x3 search window for good F1 and F2 values
vec2 cellular(vec2 P){
#define K .142857142857// 1/7
#define Ko .428571428571// 3/7
#define jitter 1.0// Less gives more regular pattern
vec2 Pi=mod289(floor(P));
vec2 Pf=fract(P);
vec3 oi=vec3(-1.,0.,1.);
vec3 of=vec3(-.5,.5,1.5);
vec3 px=permute(Pi.x+oi);
vec3 p=permute(px.x+Pi.y+oi);// p11, p12, p13
vec3 ox=fract(p*K)-Ko;
vec3 oy=mod7(floor(p*K))*K-Ko;
vec3 dx=Pf.x+.5+jitter*ox;
vec3 dy=Pf.y-of+jitter*oy;
vec3 d1=dx*dx+dy*dy;// d11, d12 and d13, squared
p=permute(px.y+Pi.y+oi);// p21, p22, p23
ox=fract(p*K)-Ko;
oy=mod7(floor(p*K))*K-Ko;
dx=Pf.x-.5+jitter*ox;
dy=Pf.y-of+jitter*oy;
vec3 d2=dx*dx+dy*dy;// d21, d22 and d23, squared
p=permute(px.z+Pi.y+oi);// p31, p32, p33
ox=fract(p*K)-Ko;
oy=mod7(floor(p*K))*K-Ko;
dx=Pf.x-1.5+jitter*ox;
dy=Pf.y-of+jitter*oy;
vec3 d3=dx*dx+dy*dy;// d31, d32 and d33, squared
// Sort out the two smallest distances (F1, F2)
vec3 d1a=min(d1,d2);
d2=max(d1,d2);// Swap to keep candidates for F2
d2=min(d2,d3);// neither F1 nor F2 are now in d3
d1=min(d1a,d2);// F1 is now in d1
d2=max(d1a,d2);// Swap to keep candidates for F2
d1.xy=(d1.x<d1.y)?d1.xy:d1.yx;// Swap if smaller
d1.xz=(d1.x<d1.z)?d1.xz:d1.zx;// F1 is in d1.x
d1.yz=min(d1.yz,d2.yz);// F2 is now not in d2.yz
d1.y=min(d1.y,d1.z);// nor in d1.z
d1.y=min(d1.y,d2.x);// F2 is in d1.y, we're done.
return sqrt(d1.xy);
}
float snoise(vec2 v){
const vec4 C=vec4(.211324865405187,// (3.0-sqrt(3.0))/6.0
.366025403784439,// 0.5*(sqrt(3.0)-1.0)
-.577350269189626,// -1.0 + 2.0 * C.x
.024390243902439);// 1.0 / 41.0
// First corner
vec2 i=floor(v+dot(v,C.yy));
vec2 x0=v-i+dot(i,C.xx);
// Other corners
vec2 i1;
i1=(x0.x>x0.y)?vec2(1.,0.):vec2(0.,1.);
vec4 x12=x0.xyxy+C.xxzz;
x12.xy-=i1;
// Permutations
i=mod289(i);// Avoid truncation effects in permutation
vec3 p=permute(permute(i.y+vec3(0.,i1.y,1.))
+i.x+vec3(0.,i1.x,1.));
vec3 m=max(.5-vec3(dot(x0,x0),dot(x12.xy,x12.xy),dot(x12.zw,x12.zw)),0.);
m=m*m;
m=m*m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x=2.*fract(p*C.www)-1.;
vec3 h=abs(x)-.5;
vec3 ox=floor(x+.5);
vec3 a0=x-ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m*=1.79284291400159-.85373472095314*(a0*a0+h*h);
// Compute final noise value at P
vec3 g;
g.x=a0.x*x0.x+h.x*x0.y;
g.yz=a0.yz*x12.xz+h.yz*x12.yw;
return 130.*dot(m,g);
}
float customEllipse(vec2 p,vec2 ab,float rad,vec2 center){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
p=(inverse(H)*vec3(p,1.)).xy;
p=abs(p);if(p.x>p.y){p=p.yx;ab=ab.yx;}
float l=ab.y*ab.y-ab.x*ab.x;
float m=ab.x*p.x/l;float m2=m*m;
float n=ab.y*p.y/l;float n2=n*n;
float c=(m2+n2-1.)/3.;float c3=c*c*c;
float q=c3+m2*n2*2.;
float d=c3+m2*n2;
float g=m+m*n2;
float co;
if(d<0.)
{
float h=acos(q/c3)/3.;
float s=cos(h);
float t=sin(h)*sqrt(3.);
float rx=sqrt(-c*(s+t+2.)+m2);
float ry=sqrt(-c*(s-t+2.)+m2);
co=(ry+sign(l)*rx+abs(g)/(rx*ry)-m)/2.;
}
else
{
float h=2.*m*n*sqrt(d);
float s=sign(q+h)*pow(abs(q+h),1./3.);
float u=sign(q-h)*pow(abs(q-h),1./3.);
float rx=-s-u-c*4.+2.*m2;
float ry=(s-u)*sqrt(3.);
float rm=sqrt(rx*rx+ry*ry);
co=(ry/sqrt(rm-rx)+2.*g/rm-m)/2.;
}
vec2 r=ab*vec2(co,sqrt(1.-co*co));
return length(r-p)*sign(p.y-r.y);
}
float customUnevenCapsule(vec2 p,float r1,float r2,float h,float rad,vec2 center){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
p=(inverse(H)*vec3(p,1.)).xy;
p.x=abs(p.x);
float b=(r1-r2)/h;
float a=sqrt(1.-b*b);
float k=dot(p,vec2(-b,a));
if(k<0.)return length(p)-r1;
if(k>a*h)return length(p-vec2(0.,h))-r2;
return dot(p,vec2(a,b))-r1;
}
float customBlobbyCross(vec2 pos,float he,float rad,vec2 center,float size){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
pos=(inverse(H)*vec3(pos,1.)).xy;
pos=abs(pos)/size;
pos=vec2(abs(pos.x-pos.y),1.-pos.x-pos.y)/sqrt(2.);
float p=(he-pos.y-.25/he)/(6.*he);
float q=pos.x/(he*he*16.);
float h=q*q-p*p*p;
float x;
if(h>0.){float r=sqrt(h);x=pow(q+r,1./3.)-pow(abs(q-r),1./3.)*sign(r-q);}
else{float r=sqrt(p);x=2.*r*cos(acos(q/(p*r))/3.);}
x=min(x,sqrt(2.)/2.);
vec2 z=vec2(x,he*(1.-2.*x*x))-pos;
return length(z)*sign(z.y);
}
float colour_cellular(vec2 xy){return cellular(xy).x*2.-1.;}
void main(){
vec2 st=(gl_FragCoord.xy/u_resolution.xy)*2.-1.;
vec3 xyz=vec3(st,0);
// light blue (feet)
float light_blue=colour_cellular(xyz.xy*20.);
vec3 colour_light_blue=vec3(.3+.5*vec3(light_blue));
colour_light_blue=1.-colour_light_blue;
// blue (rear legs and the lower part of front legs)
float blue=colour_cellular(xyz.xy*20.);
vec3 colour_blue=vec3(.7+.7*vec3(blue));
colour_blue=1.-colour_blue;
// red (body and the upper part of front legs)
float red=snoise(xyz.xy*7.);
vec3 colour_red=vec3(.3+.6*vec3(red));
// background
float background=colour_cellular(xyz.xy*2.);
vec3 colour_background=vec3(.3+.4*vec3(background));
colour_out=vec4(colour_background.x-.5,colour_background.y,colour_background.z-.5,1.);
// eyes
float mask=1.;
mask*=step(.09,distance(st.xy,vec2(.15,.4)));
mask*=step(.09,distance(st.xy,vec2(-.15,.4)));
if(mask==0.){
colour_out=vec4(0.0, 0.0, 0.0, 1.0);
}
// light blue part
mask=1.;
mask*=step(0.,customBlobbyCross(st.xy,.6,.5,vec2(.55,.25),.1)-.2);// right front feet
mask*=step(0.,customBlobbyCross(st.xy,.6,-.8,vec2(-.44,.25),.1)-.2);// left front feet
mask*=step(0.,customBlobbyCross(st.xy,.6,1.,vec2(.57,-.63),.15)-.2);// right rear feet
mask*=step(0.,customBlobbyCross(st.xy,.6,1.,vec2(-.56,-.77),.15)-.2);// left rear feet
if(mask==0.){
colour_out=vec4(colour_light_blue.x-.6,colour_light_blue.y-.2,colour_light_blue.z,1.);
}
// blue part
mask=1.;
mask*=step(0.,customEllipse(st.xy,vec2(.15,.04),1.2,vec2(.5,.11)));// right front leg
mask*=step(0.,customEllipse(st.xy,vec2(.15,.04),1.5,vec2(-.45,.11)));// left front leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.11),.5,vec2(.25,-.42)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.11),-.5,vec2(-.25,-.42)));// left rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.09),1.,vec2(.33,-.5)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.09),-1.,vec2(-.33,-.5)));// left rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.2,.05),.15,vec2(.38,-.66)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.2,.05),.25,vec2(-.38,-.73)));// left rear leg
if(mask==0.){
colour_out=vec4(colour_blue.x-.8,colour_blue.y-.2,colour_blue.z,1.);
}
// red part
mask=1.;
mask*=step(0.,customEllipse(st.xy,vec2(.6,.25),1.55,vec2(0)));// body
mask*=step(0.,customUnevenCapsule(st.xy,.04,.05,.25,1.,vec2(.45,0.)));// right front leg
mask*=step(0.,customUnevenCapsule(st.xy,.04,.05,.25,-1.,vec2(-.45,0.)));// left front leg
mask*=step(0.,customEllipse(st.xy,vec2(.11,.09),1.8,vec2(.115,.39)));// right eyelid
mask*=step(0.,customEllipse(st.xy,vec2(.11,.09),-1.8,vec2(-.115,.39)));// left eyelid
if(mask==0.){
colour_out=vec4(colour_red.x,colour_red.y-1.,colour_red.z-1.,1.);
}
// light
colour_out.xyz+=vec3(.04/distance(st,vec2(.15,.43)));
}
14. Oophaga pumilio by LeeHyeonJoon
// Author: Jingyi Huang 5122FG14
// PseudoName: algaeee
// Title:
#ifdef GL_ES
precision mediump float;
#endif
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
struct Material
{
vec3 diffuseAlbedo;
vec3 specularAlbedo;
float specularPower;
};
#define AA 1
#define NUM_OCTAVES 20
// dist funcs
// https://iquilezles.org/articles/distfunctions
float dot2(in vec3 v ) { return dot(v,v); }
float sdRoundCone(vec3 p, vec3 a, vec3 b, float r1, float r2)
{
// sampling independent computations (only depend on shape)
vec3 ba = b - a;
float l2 = dot(ba,ba);
float rr = r1 - r2;
float a2 = l2 - rr*rr;
float il2 = 1.0/l2;
// sampling dependant computations
vec3 pa = p - a;
float y = dot(pa,ba);
float z = y - l2;
float x2 = dot2( pa*l2 - ba*y );
float y2 = y*y*l2;
float z2 = z*z*l2;
// single square root!
float k = sign(rr)*rr*rr*x2;
if( sign(z)*a2*z2 > k ) return sqrt(x2 + z2) *il2 - r2;
if( sign(y)*a2*y2 < k ) return sqrt(x2 + y2) *il2 - r1;
return (sqrt(x2*a2*il2)+y*rr)*il2 - r1;
}
float sdSphere( vec3 p, float s )
{
return length(p)-s;
}
float sdCappedTorus(in vec3 p, in vec2 sc, in float ra, in float rb)
{
p.x = abs(p.x);
float k = (sc.y*p.x>sc.x*p.y) ? dot(p.xy,sc) : length(p.xy);
return sqrt( dot(p,p) + ra*ra - 2.0*ra*k ) - rb;
}
// http://research.microsoft.com/en-us/um/people/hoppe/ravg.pdf
float det( vec2 a, vec2 b ) { return a.x*b.y-b.x*a.y; }
vec3 getClosest( vec2 b0, vec2 b1, vec2 b2 )
{
float a = det(b0,b2);
float b = 2.0*det(b1,b0);
float d = 2.0*det(b2,b1);
float f = b*d - a*a;
vec2 d21 = b2-b1;
vec2 d10 = b1-b0;
vec2 d20 = b2-b0;
vec2 gf = 2.0*(b*d21+d*d10+a*d20); gf = vec2(gf.y,-gf.x);
vec2 pp = -f*gf/dot(gf,gf);
vec2 d0p = b0-pp;
float ap = det(d0p,d20);
float bp = 2.0*det(d10,d0p);
float t = clamp( (ap+bp)/(2.0*a+b+d), 0.0 ,1.0 );
return vec3( mix(mix(b0,b1,t), mix(b1,b2,t),t), t );
}
vec4 sdBezier( vec3 a, vec3 b, vec3 c, vec3 p )
{
vec3 w = normalize( cross( c-b, a-b ) );
vec3 u = normalize( c-b );
vec3 v = ( cross( w, u ) );
vec2 a2 = vec2( dot(a-b,u), dot(a-b,v) );
vec2 b2 = vec2( 0.0 );
vec2 c2 = vec2( dot(c-b,u), dot(c-b,v) );
vec3 p3 = vec3( dot(p-b,u), dot(p-b,v), dot(p-b,w) );
vec3 cp = getClosest( a2-p3.xy, b2-p3.xy, c2-p3.xy );
return vec4( sqrt(dot(cp.xy,cp.xy)+p3.z*p3.z), cp.z, length(cp.xy), p3.z );
}
float sdEllipsoid( in vec3 p, in vec3 c, in vec3 r )
{
#if 1
return (length( (p-c)/r ) - 1.0) * min(min(r.x,r.y),r.z);
#else
float k0 = length((p-c)/r);
float k1 = length((p-c)/(r*r));
return k0*(k0-1.0)/k1;
#endif
}
vec2 sdSegment( vec3 p, vec3 a, vec3 b )
{
vec3 pa = p-a, ba = b-a;
float h = clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return vec2( length( pa - ba*h ), h );
}
// https://iquilezles.org/articles/smin
float smin( float a, float b, float k )
{
float h = max(k-abs(a-b),0.0);
return min(a, b) - h*h*0.25/k;
}
float smax( float a, float b, float k )
{
float h = max(k-abs(a-b),0.0);
return max(a, b) + h*h*0.25/k;
}
vec3 smax( vec3 a, vec3 b, float k )
{
vec3 h = max(k-abs(a-b),0.0);
return max(a, b) + h*h*0.25/k;
}
// ------------------------------------------------------------------------
vec2 map( in vec3 pos )
{
float objID = 0.0;
// body
vec3 pa = vec3(-0.180,-0.160,0.100);
vec3 pb = vec3(0.400,0.293,0.316);
float ra = 0.3;
float rb = 0.1;
float d = sdRoundCone(pos, pa, pb, ra, rb );
vec2 res = vec2(d, objID);
// back
pa = vec3(0.32,0.20,0.108);
pb = vec3(0.5,-0.,0.050);
ra = 0.02;
rb = 0.12;
float d1 = sdRoundCone(pos+vec3(0.4, -0.1, 0.0), pa, pb, ra, rb );
d = smin(d, d1, 0.3);
if( d1<res.x ) res = vec2(d1,objID++);
// throat
pa = vec3(0.520,0.015,0.152);
pb = vec3(0.820,0.08,0.3);
ra = 0.1;
rb = 0.03;
d1 = sdRoundCone(pos+vec3(0.4, -0.1, 0.0), pa, pb, ra, rb );
d = smin(d, d1, 0.06);
if( d1<res.x ) res = vec2(d1,objID++);
// mouth
float an = 2.5*(0.428+0.164*sin(1.1+3.0));
vec2 c = vec2(sin(an),cos(an));
float theta1 = -0.968;
float theta2 = 0.056;
float theta3 = -1.164;
mat3 rot_X = mat3(1.0,0.,0.,
0., cos(theta1),-sin(theta1),
0.0, sin(theta1),cos(theta1) );
mat3 rot_Y = mat3(cos(theta2),0.,sin(theta2),
0., 1.0,0.,
-sin(theta2), 0.,cos(theta2) );
mat3 rot_Z = mat3(cos(theta3),-sin(theta3),0.,
sin(theta3), cos(theta3),0.,
0.0, 0.,1. );
d1 = sdCappedTorus(rot_Z*rot_Y*rot_X*(pos+vec3(-0.280,-0.300,-0.380)), c, 0.208, 0.016 );
d = smin(d, d1, 0.06);
if( d1<res.x ) res = vec2(d1,objID++);
// eyes
// eyeframe
d1 = sdSphere( pos+vec3(-0.360,-0.300,-0.4200), 0.08);
d = smin(d, d1, 0.02);
if( d1<res.x ) res = vec2(d1,objID++);
d1 = sdSphere( pos+vec3(-0.440,-0.530,0.200), 0.1);
d = smin(d, d1, 0.02);
mat3 scale = mat3(0.2,0.,0.,
0., 0.224,0.,
0., 0.,0.2);
d1 = sdEllipsoid(pos+vec3(-0.36,-0.3,-0.420),vec3(0.0,0.00,0.00),vec3(0.046,0.030,0.30) );
d = smax(d, -d1, 0.02);
if( d1<res.x ) res = vec2(d1,objID++);
// eye
mat3 rot = mat3(0.8,-0.6,0.0,
0.6, 0.8,0.0,
0.0, 0.0,1.0 );
d1 = sdEllipsoid(rot*(pos+vec3(-0.36,-0.31,-0.430)),vec3(0.0,0.00,0.00),vec3(0.100,0.099,0.099)*0.3 );
d = smin(d, d1, 0.02);
if( d1<res.x ) res = vec2(d1,objID++);
// legs
// front left
pa = vec3(0.22,0.22,0.16);
pb = vec3(0.400,0.023,0.081);
ra = 0.08;
rb = 0.1;
d1 = sdRoundCone(pos+vec3(0.4, 0.36, -0.24), pa, pb, ra, rb );
d = smin(d, d1, 0.05);
if( d1<res.x ) res = vec2(d1,objID++);
pa = vec3(0.220,0.200,0.156);
pb = vec3(0.360,-0.100,0.150);
ra = 0.09;
rb = 0.03;
d1 = sdRoundCone(pos+vec3(0.4, 0.36, -0.24), pa, pb, ra, rb );
d = smin(d, d1, 0.01);
if( d1<res.x ) res = vec2(d1,objID++);
// front right
vec4 d2 = sdBezier( vec3(0.520,-0.200,0.145), vec3(0.432,-0.100+0.1,0.14), vec3(0.460,0.248,0.15), pos +vec3(0.220,0.140,-0.200));
d1 = d2.x - smoothstep(-0.512,0.360,d2.y)*(0.163 - 0.074 *smoothstep(1.8,1.0,d2.y));
d = smin(d, d1, 0.03);
if( d1<res.x ) res = vec2(d1,objID++);
// back right
d2 = sdBezier( vec3(0.540,-0.200,0.050), vec3(0.432,-0.052+0.1,0.14), vec3(0.460,0.248,0.15), pos +vec3(0.1,0.1,0.20));
d1 = d2.x - smoothstep(-0.624,0.280,d2.y)*(0.187 - 0.106 *smoothstep(1.8,1.0,d2.y));
d = smin(d, d1, 0.03);
if( d1<res.x ) res = vec2(d1,objID++);
// paw
vec3 offset = vec3(-0.270,0.360,-0.850);
d2 = sdBezier( vec3(0.159,-0.082,-0.700), vec3(0.120,-0.180+0.1,-0.6), vec3(0.040,0.008,-0.5), pos + offset);
float dd = d2.x - smoothstep(-0.352,0.47,d2.y)*(0.12 - 0.09 *smoothstep(1.8,1.0,d2.y));
d2 = sdBezier( vec3(0.179,-0.102,-0.500), vec3(0.112,-0.212+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.440,0.470,d2.y)*(0.115 - 0.09 *smoothstep(1.8,1.0,d2.y));
dd = smin( dd, d1, 0.04 );
d2 = sdBezier( vec3(0.019,-0.162,-0.500), vec3(0.080,-0.116+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.224,0.200,d2.y)*(0.115 - 0.082 *smoothstep(1.8,1.0,d2.y));
dd = smin( dd, d1, 0.04 );
d1 = sdSphere(pos+vec3(-0.420,0.430,-0.200), 0.03);
dd = smin(dd, d1, 0.03);
d1 = sdSphere(pos+vec3(-0.450,0.480,-0.350), 0.02);
dd = smin(dd, d1, 0.03);
d1 = sdSphere(pos+vec3(-0.290,0.520,-0.380), 0.02);
dd = smin(dd, d1, 0.03);
d = smin(d, dd, 0.02);
if( dd<res.x ) res = vec2(dd,objID++);
offset = vec3(-0.40,0.28,-0.40);
d2 = sdBezier( vec3(0.119,-0.182,-0.700), vec3(0.056,-0.244+0.1,-0.6), vec3(0.040,0.008,-0.5), pos + offset);
dd = d2.x - smoothstep(-0.352,0.47,d2.y)*(0.12 - 0.09 *smoothstep(1.8,1.0,d2.y));
d2 = sdBezier( vec3(0.039,-0.122,-0.300), vec3(0.040,-0.212+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.696,0.470,d2.y)*(0.115 - 0.09 *smoothstep(1.8,1.0,d2.y));
dd = smin( dd, d1, 0.06 );
d2 = sdBezier( vec3(0.219,-0.162,-0.500), vec3(0.136,-0.212+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.440,0.470,d2.y)*(0.115 - 0.09 *smoothstep(1.512,1.040,d2.y));
dd = smin( dd, d1, 0.06 );
d1 = sdSphere(pos+vec3(-0.14,0.55,-0.40), 0.026);
dd = smin(dd, d1, 0.03);
d1 = sdSphere(pos+vec3(0.03,0.610,-0.40), 0.02);
dd = smin(dd, d1, 0.03);
d1 = sdSphere(pos+vec3(-0.140,0.620,-0.200), 0.03);
dd = smin(dd, d1, 0.03);
d = smin(d, dd, 0.02);
if( dd<res.x ) res = vec2(dd,objID++);
offset = vec3(0.0660,0.450,-0.8800);
d2 = sdBezier( vec3(0.199,-0.162,-0.700), vec3(0.136,-0.268+0.1,-0.6), vec3(0.040,0.008,-0.5), pos + offset);
dd = d2.x - smoothstep(-0.352,0.47,d2.y)*(0.12 - 0.09 *smoothstep(1.8,1.0,d2.y));
d2 = sdBezier( vec3(0.219,-0.102,-0.500), vec3(0.112,-0.212+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.440,0.470,d2.y)*(0.115 - 0.09 *smoothstep(1.8,1.0,d2.y));
dd = smin( dd, d1, 0.06 );
d2 = sdBezier( vec3(0.019,-0.162,-0.500), vec3(0.040,-0.172+0.1,-0.5), vec3(0.040,0.008,-0.5), pos + offset);
d1 = d2.x - smoothstep(-0.440,0.08,d2.y)*(0.115 - 0.09 *smoothstep(1.8,1.0,d2.y));
dd = smin( dd, d1, 0.06 );
d1 = sdSphere(pos+vec3(-0.620,0.420,0.100), 0.02);
dd = smin(dd, d1, 0.03);
d1 = sdSphere(pos+vec3(-0.440,0.40,-0.080), 0.02);
dd = smin(dd, d1, 0.03);
d = smin(d, dd, 0.02);
if( dd<res.x ) res = vec2(dd,objID++);
return vec2(d, objID);
}
// https://iquilezles.org/articles/normalsSDF
vec3 calcNormal( in vec3 pos )
{
vec2 e = vec2(1.0,-1.0)*0.5773;
const float eps = 0.0005;
return normalize( e.xyy*map( pos + e.xyy*eps ).x +
e.yyx*map( pos + e.yyx*eps ).x +
e.yxy*map( pos + e.yxy*eps ).x +
e.xxx*map( pos + e.xxx*eps ).x );
}
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmod : 20201014 (stegu)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 mod289(vec4 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x) {
return mod289(((x*34.0)+10.0)*x);
}
// 2D
vec2 mod289(vec2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
vec3 permute(vec3 x) { return mod289(((x*34.0)+1.0)*x); }
vec4 taylorInvSqrt(vec4 r)
{
return 1.79284291400159 - 0.85373472095314 * r;
}
float snoise(vec3 v)
{
const vec2 C = vec2(1.0/6.0,1.0/3.0);
const vec4 D = vec4(0.211324865405187,
// (3.0-sqrt(3.0))/6.0
0.366025403784439,
// 0.5*(sqrt(3.0)-1.0)
-0.577350269189626,
// -1.0 + 2.0 * C.x
0.024390243902439);
// 1.0 / 41.0
// First corner
vec3 i = floor(v + dot(v, C.yyy) );
vec3 x0 = v - i + dot(i, C.xxx) ;
// Other corners
vec3 g = step(x0.yzx, x0.xyz);
vec3 l = 1.0 - g;
vec3 i1 = min( g.xyz, l.zxy );
vec3 i2 = max( g.xyz, l.zxy );
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
vec3 x1 = x0 - i1 + C.xxx;
vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
vec4 p = permute( permute( permute(
i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
+ i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
+ i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
float n_ = 0.142857142857; // 1.0/7.0
vec3 ns = n_ * D.wyz - D.xzx;
vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7)
vec4 x_ = floor(j * ns.z);
vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N)
vec4 x = x_ *ns.x + ns.yyyy;
vec4 y = y_ *ns.x + ns.yyyy;
vec4 h = 1.0 - abs(x) - abs(y);
vec4 b0 = vec4( x.xy, y.xy );
vec4 b1 = vec4( x.zw, y.zw );
//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
vec4 s0 = floor(b0)*2.0 + 1.0;
vec4 s1 = floor(b1)*2.0 + 1.0;
vec4 sh = -step(h, vec4(0.0));
vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
vec3 p0 = vec3(a0.xy,h.x);
vec3 p1 = vec3(a0.zw,h.y);
vec3 p2 = vec3(a1.xy,h.z);
vec3 p3 = vec3(a1.zw,h.w);
//Normalise gradients
vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
vec4 m = max(0.5 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
m = m * m;
return 130.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1),
dot(p2,x2), dot(p3,x3) ) );
}
float snoise(vec2 v) {
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
vec2 i1;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
float random (in vec2 _st) {
return fract(sin(dot(_st.xy,vec2(12.9898,78.633)))*43758.5453123);
}
float noise (in vec2 _st) {
vec2 i = floor(_st);
vec2 f = fract(_st);
float a = random(i);
float b = random(i + vec2(1.0, 0.0));
float c = random(i + vec2(0.0, 1.0));
float d = random(i + vec2(1.0, 1.0));
vec2 u = f * f * f * f *(3.0 - 2.0 * f); //+2.0*sin(u_time/10.0)
return mix(a, b, u.x) +
(c - a)* u.y * (1.0 - u.x) +
(d - b) * u.x * u.y;
}
float fbm ( in vec2 _st, in vec2 _mo) {
float v = 0.0;
float a = 0.5;
vec2 shift = vec2(100.0);
mat2 rot = mat2(cos(0.5), sin(0.5),
-sin(0.5), cos(0.5));
for (int i = 0; i < NUM_OCTAVES; ++i) {
v += a * noise(_st);
_st = rot * _st * (4.5) + shift;
a *= 0.45;
}
return v;
}
// ------------------------------------------------------------------------
// Translucency: https://www.shadertoy.com/view/3lK3RR
vec3 calculateTransmittance(vec3 ro, vec3 rd, float tmin, float tmax, float atten)
{
const int MAX_DEPTH = 4;
float hitPoints[MAX_DEPTH];
int depth = 0;
for (float t = tmin; t < tmax;)
{
float h = abs(map(ro + t * rd).x);
if (h < 1e-5) { hitPoints[depth++] = t; t += 0.01; };
if (depth >= MAX_DEPTH) break;
t += h;
}
float thickness = 0.0;
for (int i = 0; i < depth - 1; i += 2) thickness += hitPoints[i+1] - hitPoints[i];
return vec3(1.0) * exp(-atten * thickness * thickness);
}
// ------------------------------------------------------------------------
void main() {
// camera movement
float an = 0.7;
vec3 ro = vec3( 0.5*cos(an), 0.0, 2.0*sin(an) );
vec3 ta = vec3( 0.0, 0.0, 0.0 );
// camera matrix
vec3 ww = normalize( ta - ro );
vec3 uu = normalize( cross(ww,vec3(0.0,1.0,0.0) ) );
vec3 vv = normalize( cross(uu,ww));
// render
vec3 tot = vec3(0.9);
for( int m=0; m<AA; m++ )
for( int n=0; n<AA; n++ )
{
// pixel coordinates
vec2 offset = vec2(float(m)+0.5,float(n)+0.5) / float(AA) - 0.5;
vec2 p = (-u_resolution.xy + 2.0*(gl_FragCoord.xy+offset))/u_resolution.y;
// create view ray
vec3 rd = normalize( p.x*uu + p.y*vv + 1.5*ww );
// raymarch
const float tmax = 2.0;
float t = 0.0;
for( int i=0; i<256; i++ )
{
vec3 pos = ro + t*rd;
float h = map(pos).x;
if( h<0.0001 || t>tmax ) break;
t += h;
}
// shading/lighting
vec3 col = vec3(0.0);
if( t<tmax )
{
vec3 pos = ro + t*rd;
vec3 nor = calcNormal(pos);
vec3 lightDir = normalize(vec3(1.0, 1.5, -1.0));
vec3 lightColor = vec3(1.0);
Material mat = Material(vec3(0.6,0.08,0.0), vec3(0.3), 8.0);
float dif = clamp( dot(nor,vec3(0.57703)), 0.0, 1.0 ); // diffusion
float t = clamp(0.5, 0.2, 1.0);
vec3 light = t * lightColor * calculateTransmittance(pos+nor*vec3(0.01), lightDir, 0.01, 10.0, 2.0);
light += (1.0 - t) * calculateTransmittance(pos+nor*vec3(0.01), rd, 0.01, 10.0, 0.5);
col += light * mat.diffuseAlbedo + mat.specularAlbedo * pow(max(0.0, dot(reflect(lightDir,nor),rd)), 4.0);
// float amb = 0.5 + 0.5*dot(nor,vec3(0.0,1.0,0.0));
// col = vec3(0.2,0.3,0.4)*amb + vec3(0.8,0.7,0.5)*dif;
}
// apply texture
float DF = 0.0;
// Add a random position
DF += snoise(9.0*p)*.25+.25;
// Add a random position
float a = snoise(p*0.1)*3.1415;
vec2 vel = vec2(cos(a),sin(a));
DF += snoise(12.0*p+vel)*.25+.25;
// float n = texture(p * 4.0); // 2D
if( length((p-vec2(0.3, -0.3)).xy) > 0.32 && length(p.xy) < 0.33) { col *= 1.0-smoothstep(.7,.75,fract(DF)); }
else { col*=1.0; }
// gamma
col = sqrt( col );
tot *= col;
}
tot /= float(AA*AA);
vec2 p = (-u_resolution.xy + 2.0*gl_FragCoord.xy)/u_resolution.y;
vec2 m = u_mouse.xy/u_resolution.xy;
vec2 q = vec2(0.);
q.x = fbm( p, m);
q.y = fbm( p + vec2(1.0), m);
vec2 r = vec2(0.);
r.x = fbm( p + 1.0*q + vec2(1.7,9.2), m);
r.y = fbm( p + 1.0*q + vec2(8.3,2.8), m);
float f = fbm(p+r, m);
vec2 g = vec2(f);
vec3 color = vec3(0.0);
color = mix(vec3(0.681,0.858,0.920),
vec3(0.967,0.156,0.573),
clamp((f*f)*4.312,0.992,1.0));
color = mix(color,
vec3(0.300,0.034,0.134),
clamp(length(q),0.0,1.0));
color = mix(color,
vec3(1.000,0.700,0.315),
clamp(length(r.x),0.0,1.0));
tot *= vec3((f*f*f+0.7*f*f*f*f+3.068*f*f)*color*5.0);
tot = pow(tot, vec3(0.4545));
colour_out = vec4(tot, 1.0);
}
15. unknown by algaeee
// credit: TATyz
// frog: Blue Poison Dart Frog
#define BLADES_SPACING 0.004
#define JITTER_MAX 0.004
// depends on size of grass blades in pixels
#define LOOKUP_DIST 5
#define HASHSCALE1 .1031
#define HASHSCALE3 vec3(.1031, .1030, .0973)
precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
float msign(in float x) { return (x<0.0)?-1.0:1.0; }
// background grass start
float hash12(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE1);
p3 += dot(p3, p3.yzx + 19.19);
return fract((p3.x + p3.y) * p3.z);
}
/// 3 out, 2 in...
vec3 hash32(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE3);
p3 += dot(p3, p3.yxz+19.19);
return fract((p3.xxy+p3.yzz)*p3.zyx);
}
/// 2 out, 2 in...
vec2 hash22(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE3);
p3 += dot(p3, p3.yzx+19.19);
return fract((p3.xx+p3.yz)*p3.zy);
}
vec3 getGrassColor(float x) {
vec3 a = vec3(0.2, 0.4, 0.3);
vec3 b = vec3(0.3, 0.5, 0.2);
vec3 c = vec3(0.2, 0.4, 0.2);
vec3 d = vec3(0.66, 0.77, 0.33);
vec3 col = a + b * cos(2. * 3.14 * (c * x + d));
return col;
}
float getGrassBlade(in vec2 position, in vec2 grassPos, out vec4 color) {
// between {-1, -1, -1} and {1, 1, 1}
vec3 grassVector3 = hash32(grassPos * 123512.41) * 2.0 - vec3(1);
// keep grass z between 0 and 0.4
grassVector3.z = grassVector3.z * 0.2 + 0.2;
vec2 grassVector2 = normalize(grassVector3.xy);
float grassLength = hash12(grassPos * 102348.7) * 0.01 + 0.012;
// take coordinates in grass blade frame
vec2 gv = position - grassPos;
float gx = dot(grassVector2, gv);
float gy = dot(vec2(-grassVector2.y, grassVector2.x), gv);
float gxn = gx / grassLength;
// TODO make gy depends to gx
if (gxn >= 0.0 && gxn <= 1.0 && abs(gy) <= 0.0008 * (1. - gxn * gxn)) {
vec3 thisGrassColor = getGrassColor(hash12(grassPos * 2631.6));
color = vec4(thisGrassColor * (0.2 + 0.8 * gxn), 1.0);
return grassVector3.z * gxn;
}
else {
color = vec4(0., 0., 0., 1.);
return -1.0;
}
}
float getPoint(in vec2 position, out vec4 color) {
int xcount = int(1. / BLADES_SPACING);
int ycount = int(1. / BLADES_SPACING);
int ox = int(position.x * float(xcount));
int oy = int(position.y * float(ycount));
float maxz = 0.0;
for (int i = -LOOKUP_DIST; i < LOOKUP_DIST; ++i) {
for (int j = -LOOKUP_DIST; j < LOOKUP_DIST; ++j) {
vec2 upos = vec2(ox + i, oy + j);
vec2 grassPos = (upos * BLADES_SPACING + hash22(upos) * JITTER_MAX);
vec4 tempColor;
float z = getGrassBlade(position, grassPos, tempColor);
if (z > maxz) {
maxz = z;
color = tempColor;
}
}
}
if (maxz == 0.0) {
color = vec4(0.);
}
return maxz;
}
// end
float sdUnion( float d1, float d2 ) {
return min( d1, d2 );
}
float sdDifference( float d1, float d2 ) {
return max( -d1, d2 ); /* Remove d1 from d2 */
}
float sdEllipse( vec2 p, in vec2 ab , in vec2 bias, in float rot)
{
//if( ab.x==ab.y ) return length(p)-ab.x;
vec2 p0 = p;
p.x = p0.x * cos(rot) - p0.y * sin(rot);
p.y = p0.x * sin(rot) + p0.y * cos(rot);
p = abs( p + bias);
if( p.x>p.y ){ p=p.yx; ab=ab.yx; }
float l = ab.y*ab.y - ab.x*ab.x;
float m = ab.x*p.x/l;
float n = ab.y*p.y/l;
float m2 = m*m;
float n2 = n*n;
float c = (m2+n2-1.0)/3.0;
float c3 = c*c*c;
float d = c3 + m2*n2;
float q = d + m2*n2;
float g = m + m *n2;
float co;
if( d<0.0 )
{
float h = acos(q/c3)/3.0;
float s = cos(h) + 2.0;
float t = sin(h) * sqrt(3.0);
float rx = sqrt( m2-c*(s+t) );
float ry = sqrt( m2-c*(s-t) );
co = ry + sign(l)*rx + abs(g)/(rx*ry);
}
else
{
float h = 2.0*m*n*sqrt(d);
float s = msign(q+h)*pow( abs(q+h), 1.0/3.0 );
float t = msign(q-h)*pow( abs(q-h), 1.0/3.0 );
float rx = -(s+t) - c*4.0 + 2.0*m2;
float ry = (s-t)*sqrt(3.0);
float rm = sqrt( rx*rx + ry*ry );
co = ry/sqrt(rm-rx) + 2.0*g/rm;
}
co = (co-m)/2.0;
float si = sqrt( max(1.0-co*co,0.0) );
vec2 r = ab * vec2(co,si);
return length(r-p) * msign(p.y-r.y);
}
float sdEgg( in vec2 p, in float ra, in float rb, in vec2 bias, in float rot)
{
const float k = sqrt(3.0);
vec2 p0 = p;
p.x = p0.x * cos(rot) - p0.y * sin(rot);
p.y = p0.x * sin(rot) + p0.y * cos(rot);
p.y = p.y + bias.y;
p.x = abs(p.x + bias.x);
float r = ra - rb;
return ((p.y<0.0) ? length(vec2(p.x, p.y )) - r :
(k*(p.x+r)<p.y) ? length(vec2(p.x, p.y-k*r)) :
length(vec2(p.x+r,p.y )) - 2.0*r) - rb;
}
float udSegment( in vec2 p, in vec2 a, in vec2 b )
{
vec2 ba = b-a;
vec2 pa = p-a;
float h =clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length(pa-h*ba);
}
float sdCircle( in vec2 p, in float r )
{
return length(p)-r;
}
// texture
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
vec3 body_bubble( in vec2 p , in vec2 resolution, in float time)
{
// background
//vec3 color = vec3(0.137, 0.582, 0.836);
vec3 color = vec3(0.008, 0.348, 0.590) + vec3(sin(0.5*p.x));
// bubbles
for( int i=0; i<1000; i++ )
{
// bubble seeds
float pha = sin(float(i)*546.13+5.0)*0.5 + 0.5;
float siz = pow( sin(float(i)*652.74+6.0)*0.5 + 0.5, 9.0 );
if (siz > 0.15){
continue;
}
float pox = sin(float(i)*321.55+6.1) * resolution.x / resolution.y;
// buble size, position and color
float rad = (0.04 + 0.5*siz)+0.03*sin(16.0*p.y)*abs(cos(0.5*time+0.2))-0.03*sin(15.0*p.x)*abs(sin(0.5*time-0.1)) ; // shape of all
vec2 pos = vec2( pox, -1.0-rad + (2.0+2.0*rad)*mod(pha+0.1*(0.2+0.8*siz),1.0));
float dis = length( p - pos -vec2(-.001,.001)); // control circle shape
// vec3 col = mix( vec3(0.94,0.3,0.0), vec3(0.1,0.4,0.8), 0.5+0.5*sin(float(i)*1.2+1.9));
vec3 col = vec3(0.6);
// col+= 8.0*smoothstep( rad*0.95, rad, dis );
// render
float f = length(p-pos)/rad;
f = sqrt(clamp(1.0-f*f,0.0,1.0));
color -= col.zyx *(1.0-smoothstep( rad*0.95, rad, dis )) * f;
}
// vigneting
color *= sqrt(1.5-0.8*length(p));
return color;
}
float turbulence_example( vec2 p ) {
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(1.376, 3.952/2.960), float(i) );
f += abs( snoise( p * scale ) ) / scale;
}
return f;
}
vec3 random(vec2 co, vec2 bias) {
const highp float seed = 12.9898;
highp float a = seed;
highp float b = 78.305, c = 47386.098;
highp float dt= dot(co.xy, vec2(a,b));
highp float sn= mod(dt,3.14159265358979323846);
float n = fract(sin(sn) * c)*2.0-1.0;
//vec3 colour_out = vec3(0.133,0.156,0.359)*n*3.0;
vec3 colour = vec3(0.197,0.242,0.510)*n*3.0; // basic color
return colour - 0.9*length(co+bias);
}
void main() {
float PI = 3.14159265358;
vec2 p = (2.0*gl_FragCoord.xy-u_resolution.xy)/u_resolution.y;
vec2 ra = vec2(0.6,0.3);
float d_body = sdEllipse(p, ra, vec2(0.0, 0.1), 135.0 * PI / 180.0); // draw body1
ra = vec2(0.35, 0.2);
float d_head = sdEllipse(p, ra, vec2(0.45, 0.25), 155.0 * PI / 180.0); // draw head
// right leg
float ra_egg = 0.12;
float d_leg_b = sdEgg(p, ra_egg, ra_egg*(3.9+12.9)*cos(2.0), vec2(0.39, 0.2), -90.0*PI / 180.0) - 0.06;
// left leg
ra = vec2(0.3, 0.13);
float d_leg_a = sdEllipse(p, ra, vec2(0.1, -0.53), -80.0 * PI / 180.0);
// arm
vec2 ar_v1 = vec2(0.2, 0.2);
vec2 ar_v2 = vec2(0.4, -0.1);
float d_arm1 = udSegment(p, ar_v1, ar_v2) - 0.08;
ar_v1 = vec2(0.4, -0.1);
ar_v2 = vec2(0.6, -0.1);
float d_arm2 = udSegment(p, ar_v1, ar_v2) - 0.08;
// feet
ra = vec2(0.21, 0.1);
float d_feet = sdEllipse(p, ra, vec2(0.1, 0.53), 15.0 * PI / 180.0);
// eye
float d_eye_b = sdCircle(p + vec2(-0.48, -0.45), 0.07);
float d_eye_center = sdCircle(p + vec2(-0.51+0.015*abs(sin(1.0*u_time+0.3)), -0.45+0.01*cos(1.0*u_time-0.3)), 0.02);
float d_body_com = sdUnion(d_body, d_head);
d_body_com = sdUnion(d_body_com, d_arm1);
d_body_com = sdUnion(d_body_com, d_arm2);
float d_back = sdUnion(d_body_com, d_leg_a);
d_back = sdUnion(d_back, d_leg_b);
d_back = sdUnion(d_back, d_feet);
d_body_com = sdDifference(d_leg_b, d_body_com);
d_body_com = sdDifference(d_eye_b, d_body_com);
d_leg_a = sdDifference(d_body_com, d_leg_a);
d_leg_b = sdUnion(d_leg_b, d_feet);
d_eye_b = sdDifference(d_eye_center, d_eye_b);
// draw texture
//vec3 col = sign(-d_body_com)*vec3(0.1,0.4,0.7);
vec3 col = ((sign(-d_body_com)+1.0)/2.0)*body_bubble(p, u_resolution, u_time);
//vec3 col_head = sign(-d_head)*vec3(0.5,0.4,0.7);
vec3 col_leg_b = ((sign(-d_leg_b)+1.0)/2.0) * random(p, vec2(-0.2, 0.4));
vec3 col_leg_a = ((sign(-d_leg_a)+1.0)/2.0) * random(p, vec2(0.8, 0.15));
vec3 col_eye_b = ((sign(-d_eye_b)+1.0)/2.0) * vec3(0.1,0.1,0.1);
vec3 col_eye_center = ((sign(-d_eye_center)+1.0)/2.0) * vec3(0.9,0.9,0.9);
/* leg 0.133,0.156,0.359 */
vec4 col_back;
float z_back = getPoint(gl_FragCoord.xy/vec2(8000.0, 8000.0), col_back);
col_back = ((sign(d_back)+1.0)/2.0) * col_back;
//vec3 col_back = ((sign(d_back)+1.0)/2.0)*vec3(0.2,0.2,0.2);
//col *= 1.0 - exp(-2.0*abs(d));
//col *= 0.8 + 0.2*cos(120.0*d);
//col = mix( col, vec3(1.0), 1.0 - smoothstep(0.0,0.01,abs(d)) ); // 白边
colour_out = vec4((col+col_leg_b+col_leg_a+col_eye_b+col_eye_center+col_back.xyz), 1.0);
}
17. Blue Poison Dart Frog by TATyz
// credit: Ziyang Zhang (will show up on website)
// frog: Yellow-band poison dart
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float cro(vec2 a,vec2 b )
{
return a.x*b.y - a.y*b.x;
}
float sdUnevenCapsule(vec2 p,vec2 pa,vec2 pb,float ra,float rb )
{
p -= pa;
pb -= pa;
float h = dot(pb,pb);
vec2 q = vec2( dot(p,vec2(pb.y,-pb.x)), dot(p,pb) )/h;
//-----------
q.x = abs(q.x);
float b = ra-rb;
vec2 c = vec2(sqrt(h-b*b),b);
float k = cro(c,q);
float m = dot(c,q);
float n = dot(q,q);
if( k < 0.0 ) return sqrt(h*(n )) - ra;
else if( k > c.x ) return sqrt(h*(n+1.0-2.0*q.y)) - rb;
return m - ra;
}
float get_body_mask(vec2 p)
{
vec2 v1 = ( vec2(0.0,-0.40) + 0.0 );
vec2 v2 = ( vec2(0.0,0.10) );
float r1 = 0.45;
float r2 = 0.275;
float d = step( 0.01,sdUnevenCapsule( p, v1, v2, r1, r2 ));
return d;
}
float get_leg_mask_left(vec2 p)
{
vec2 v1 = ( vec2(-0.5,-0.40) + 0.0 );
vec2 v2 = vec2(-0.9,0);
float r1 = 0.22;
float r2 = 0.1;
vec2 p2 = vec2(p.x - 0.2f,p.y + 0.3f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_leg_mask_right(vec2 p)
{
vec2 v1 = ( vec2(0.5,-0.40) + 0.0 );
vec2 v2 = vec2(0.9,0);
float r1 = 0.22;
float r2 = 0.1;
vec2 p2 = vec2(p.x + 0.2f,p.y + 0.3f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_body_right(vec2 p)
{
vec2 v1 = ( vec2(0.1,0.30) + 0.0 );
vec2 v2 = vec2(0.35,0);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x - 0.05f,p.y + 0.2f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_body_left(vec2 p)
{
vec2 v1 = ( vec2(-0.1,0.30) + 0.0 );
vec2 v2 = vec2(-0.35,0);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x + 0.05f,p.y + 0.2f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_right(vec2 p)
{
vec2 v1 = ( vec2(0.1,0.40) + 0.0 );
vec2 v2 = vec2(0.35,0.75);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x - 0.15f,p.y + 0.55f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_left(vec2 p)
{
vec2 v1 = ( vec2(-0.1,0.40) + 0.0 );
vec2 v2 = vec2(-0.35,0.75);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x + 0.15f,p.y + 0.55f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_mask(vec2 st, vec2 p)
{
float mask = 1.0;
mask *= step( 0.055, distance( st.xy, vec2(0.6, 0.65) ) );
mask *= step( 0.055, distance( st.xy, vec2(0.4, 0.65) ) );
mask *= get_body_mask(p);
mask *= get_leg_mask_left(p);
mask *= get_leg_mask_right(p);
mask *= get_arm_body_right(p);
mask *= get_arm_body_left(p);
mask *= get_arm_right(p);
mask *= get_arm_left(p);
return mask;
}
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
float marbleturbulence( vec2 p )
{ /* Same as the turbulence before. */
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(2.0, 4.0/3.0), float(i) );
f += abs( snoise( p * scale ) ) / scale; }
return f;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec2 p = st * 2.0f - 1.0f;
float mask = get_mask(st,p);
vec4 leg_c = vec4( 0.94, 0.78, 0.329, 1.0 ) * 0.95f;
leg_c.a = 1.0f;
colour_out = vec4( 0.94, 0.78, 0.329, 1.0 );
colour_out *= 1.0-mask;
float n = marbleturbulence( st );
float t = step(1.0,1.0 + sin( (st.y * u_resolution.y) / 18.556 + 3.2528 * n ) / 2.0);
colour_out *= vec4( vec3(t), 1.0 );
float dot_mask = snoise(st * 9.75f - u_time * 0.1f);
dot_mask = step(0.3 , dot_mask*0.5 + 0.5);
colour_out *= dot_mask;
dot_mask = 1.0f - snoise(st * 1.75f * (5.0f+cos(u_time)));
dot_mask = step(0.5,dot_mask);
float cmask_l = get_leg_mask_left(p);
colour_out *= cmask_l;
colour_out += (1.0f - cmask_l) * leg_c * dot_mask;
float cmask_r = get_leg_mask_right(p);
colour_out *= cmask_r;
colour_out += (1.0f - cmask_r) * leg_c* dot_mask;
colour_out *= step( 0.035, distance( st.xy, vec2(0.6, 0.675) ) );
colour_out *= step( 0.035, distance( st.xy, vec2(0.4, 0.675) ) );
colour_out += 1.0 - step( 0.0085, distance( st.xy, vec2(0.61, 0.6795) ) );
colour_out += 1.0 - step( 0.0085, distance( st.xy, vec2(0.41, 0.6795) ) );
colour_out.a = 1.0f;
//colour_out = vec4(dot_mask,dot_mask,dot_mask,1);
colour_out += step(1.0,mask) * vec4(1,1,1,1);
}
19. Yellow-band poison dart frog by
Ziyang Zhang
//by nagisa
uniform vec2 u_resolution;
uniform float u_time;
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 mod289(vec4 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec4 permute(vec4 x) {
return mod289((34.0 * x + 10.0) * x);
}
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec3 permute(vec3 x) {
return mod289((34.0 * x + 10.0) * x);
}
float snoise(vec2 v) {
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy));
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
m = m * m;
m = m * m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
vec4 taylorInvSqrt(vec4 r) {
return 1.79284291400159 - 0.85373472095314 * r;
}
vec2 fade(vec2 t) {
return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}
// Classic Perlin noise
float cnoise(vec2 P) {
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0;
vec4 gy = abs(gx) - 0.5;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x, gy.x);
vec2 g10 = vec2(gx.y, gy.y);
vec2 g01 = vec2(gx.z, gy.z);
vec2 g11 = vec2(gx.w, gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
float random(in vec2 st) {
return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}
// Value noise by Inigo Quilez - iq/2013
// https://www.shadertoy.com/view/lsf3WH
float noise(vec2 st) {
vec2 i = floor(st);
vec2 f = fract(st);
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(mix(random(i + vec2(0.0, 0.0)), random(i + vec2(1.0, 0.0)), u.x), mix(random(i + vec2(0.0, 1.0)), random(i + vec2(1.0, 1.0)), u.x), u.y);
}
mat2 rotate2d(float angle) {
return mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
}
float lines(in vec2 pos, float b) {
float scale = 1.2;
pos *= scale;
return smoothstep(0.1, .5 + b * .5, abs((sin(pos.x * 3.1415) + b * 2.0)) * .5);
}
float dot2(in vec3 v) {
return dot(v, v);
}
float opUnion(float d1, float d2) {
return min(d1, d2);
}
float opSmoothUnion(float d1, float d2, float k) {
float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
return mix(d2, d1, h) - k * h * (1.0 - h);
}
float sdSphere(vec3 p, float s) {
return length(p) - s;
}
float sdCapsule(vec3 p, vec3 a, vec3 b, float r) {
vec3 pa = p - a, ba = b - a;
float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
return length(pa - ba * h) - r;
}
float sdRoundCone(vec3 p, vec3 a, vec3 b, float r1, float r2) {
// sampling independent computations (only depend on shape)
vec3 ba = b - a;
float l2 = dot(ba, ba);
float rr = r1 - r2;
float a2 = l2 - rr * rr;
float il2 = 1.0 / l2;
// sampling dependant computations
vec3 pa = p - a;
float y = dot(pa, ba);
float z = y - l2;
float x2 = dot2(pa * l2 - ba * y);
float y2 = y * y * l2;
float z2 = z * z * l2;
// single square root!
float k = sign(rr) * rr * rr * x2;
if(sign(z) * a2 * z2 > k)
return sqrt(x2 + z2) * il2 - r2;
if(sign(y) * a2 * y2 < k)
return sqrt(x2 + y2) * il2 - r1;
return (sqrt(x2 * a2 * il2) + y * rr) * il2 - r1;
}
float sdCappedCylinder(vec3 p, vec3 a, vec3 b, float r) {
vec3 ba = b - a;
vec3 pa = p - a;
float baba = dot(ba, ba);
float paba = dot(pa, ba);
float x = length(pa * baba - ba * paba) - r * baba;
float y = abs(paba - baba * 0.5) - baba * 0.5;
float x2 = x * x;
float y2 = y * y * baba;
float d = (max(x, y) < 0.0) ? -min(x2, y2) : (((x > 0.0) ? x2 : 0.0) + ((y > 0.0) ? y2 : 0.0));
return sign(d) * sqrt(abs(d)) / baba;
}
float sdEllipsoid(vec3 p, vec3 r) {
float k0 = length(p / r);
float k1 = length(p / (r * r));
return k0 * (k0 - 1.0) / k1;
}
vec2 opU(vec2 d1, vec2 d2) {
return (d1.x < d2.x) ? d1 : d2;
}
vec2 map(vec3 pos) {
vec2 res = vec2(2.0, 0.0);
float tree = sdCappedCylinder(pos, vec3(-5.0, 3.0, -3.75), vec3(3.9, -5.0, 2.4), 1.2);
res = opU(res, vec2(tree, 1.0));
float body = sdRoundCone(pos, vec3(0, 0.15, 0.5), vec3(-0.67, 0.04, 0.12), 0.23, 0.28);
float eyes = opUnion(sdSphere(pos - vec3(.10, 0.32, 0.40), 0.14), sdSphere(pos - vec3(-.05, 0.17, 0.63), 0.14));
float eyeball = sdEllipsoid(pos - vec3(-.06, 0.18, 0.70), vec3(0.1, 0.08, 0.11));
float p = 130.0 * 3.1415 / 180.0;
mat3 rotx = mat3(1.0, 0.0, 0.0, 0, cos(p), sin(p), 0, -sin(p), cos(p));
p = -10.0 * 3.1415 / 180.0;
mat3 rotz = mat3(cos(p), sin(p), 0, -sin(p), cos(p), 0, 0, 0, 1);
p = 20.0 * 3.1415 / 180.0;
mat3 roty = mat3(cos(p), 0, -sin(p), 0, 1, 0, sin(p), 0, cos(p));
float mouth = sdEllipsoid(rotx * roty * rotz * (pos - vec3(0.0, 0.15, 0.61)), vec3(0.3, 0.13, 0.18));
p = 80.0 * 3.1415 / 180.0;
rotx = mat3(1.0, 0.0, 0.0, 0, cos(p), sin(p), 0, -sin(p), cos(p));
p = 10.0 * 3.1415 / 180.0;
rotz = mat3(cos(p), sin(p), 0, -sin(p), cos(p), 0, 0, 0, 1);
p = 50.0 * 3.1415 / 180.0;
roty = mat3(cos(p), 0, -sin(p), 0, 1, 0, sin(p), 0, cos(p));
float naka = sdEllipsoid(rotx * roty * rotz * (pos - vec3(-0.46, 0.11, 0.3)), vec3(0.2, 0.22, 0.25));
body = opSmoothUnion(body, naka, 0.14);
body = opSmoothUnion(opSmoothUnion(body, eyes, 0.0001), mouth, 0.05);
float frog = opSmoothUnion(body, eyes, 0.0001);
float legL1 = sdCapsule(pos, vec3(-0.83, -0.1, 0.2), vec3(-.81, -.3, 0.5), 0.07);
float legL2 = sdCapsule(pos, vec3(-.83, -0.31, 0.5), vec3(-1.05, -0.13, 0.27), 0.06);
float legL3 = sdCapsule(pos, vec3(-1.05, -0.1, 0.32), vec3(-.96, -0.43, 0.37), 0.04);
float legR1 = sdCapsule(pos, vec3(-0.2, -0.1, 0.5), vec3(-.26, -0.3, 0.7), 0.04);
float legR2 = sdCapsule(pos, vec3(-.26, -0.33, 0.7), vec3(-.21, -0.6, 0.6), 0.04);
float legL = opSmoothUnion(legL1, opSmoothUnion(legL2, legL3, 0.02), 0.02);
float legR = opSmoothUnion(legR1, legR2, 0.02);
float fingerL1 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.79, -.52, 0.4), 0.02);
float fingerL2 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.76, -.56, 0.6), 0.02);
float fingerL3 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.91, -.55, 0.55), 0.02);
float fingerR1 = sdCapsule(pos, vec3(-.21, -0.63, 0.57), vec3(-.10, -.57, 0.6), 0.02);
float fingerR2 = sdCapsule(pos, vec3(-.21, -0.6, 0.6), vec3(-.01, -.67, 0.6), 0.02);
float fingerR3 = sdCapsule(pos, vec3(-.21, -0.63, 0.6), vec3(-.12, -.72, 0.67), 0.02);
float fingerL = opUnion(fingerL1, opUnion(fingerL2, fingerL3));
float fingerR = opUnion(fingerR1, opUnion(fingerR2, fingerR3));
legL = opSmoothUnion(legL, fingerL, 0.05);
legR = opSmoothUnion(legR, fingerR, 0.05);
float legs = opUnion(legL, legR);
frog = opSmoothUnion(frog, legs, 0.05);
res = opU(res, vec2(frog, 2.0));
res = opU(res, vec2(eyeball, 3.0));
return res;
}
vec3 calcNormal(in vec3 pos) {
vec2 e = vec2(1.0, -1.0) * 0.5773;
const float eps = 0.0005;
return normalize(e.xyy * map(pos + e.xyy * eps).x +
e.yyx * map(pos + e.yyx * eps).x +
e.yxy * map(pos + e.yxy * eps).x +
e.xxx * map(pos + e.xxx * eps).x);
}
const float NEAR_CLIPPING_PLANE = 0.01;
const float FAR_CLIPPING_PLANE = 5.0;
const int MARCHING_STEPS = 100;
const float EPSILON = 0.0001;
const float DISTANCE_BIAS = 1.0;
const vec3 LIGHT_COL = vec3(1.6);
/* We are approximating soft shadows for "free" with raymarching. */
float softshadow(vec3 ro, vec3 rd, float k) {
float res = 1.0;
float ph = 1e20;
float t = NEAR_CLIPPING_PLANE;
for(int i = 0; i < MARCHING_STEPS; i++) {
float h = map(ro + t * rd).x;
if(h < EPSILON)
return 0.0;
float y = h * h / (2.0 * ph);
float d = sqrt(h * h - y * y);
res = min(res, k * d / max(0.0, t - y));
ph = h;
t += h * DISTANCE_BIAS;
if(t > FAR_CLIPPING_PLANE)
break;
}
return res;
}
float fbm_example(vec2 p) {
float f = 0.0, scale;
for(int i = 0; i < 6; i++) {
scale = pow(pow(2.0, 4.0 / 3.0), float(i));
f += snoise(p * scale) / scale;
}
return f;
}
vec2 raymarch(vec3 ro, vec3 rd) {
const float tmax = 5.0;
vec2 t = vec2(-1, 0.0);
for(int i = 0; i < 256; i++) {
vec3 pos = ro + t.x * rd;
vec2 h = map(pos);
if(h.x < 0.0001 || t.x > tmax) {
break;
}
t.x += h.x;
t.y = h.y;
}
return t;
}
void main() {
// camera movement
float an = 1.87 - 0.01 * (1.0 - cos(2.5 * u_time));
vec3 ro = vec3(0.0, 0.0, 1.6) + 1.5 * vec3(cos(an), 0, sin(an));
vec3 ta = vec3(0.11, -0.36, 0.0);
// camera matrix
vec3 ww = normalize(ta - ro);
vec3 uu = normalize(cross(ww, vec3(0.0, 1.0, 0.0)));
vec3 vv = normalize(cross(uu, ww));
vec2 p = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y;
// create view ray
vec3 rd = normalize(p.x * uu + p.y * vv + 1.8 * ww);
vec3 tot = vec3(0, 0, 0.0);
vec2 t = raymarch(ro, rd);
vec3 LIGHT_POS = 3.0 * vec3(.6, 1.0, 2.8);
const float tmax = 5.0;
//shading/lighting
vec3 col = vec3(0.0);
if(t.x < tmax) {
vec3 pos = ro + t.x * rd;
vec3 nor = calcNormal(pos);
float dif = clamp(dot(nor, vec3(0.57703)), 0.0, 1.0);
float amb = 0.5 + 0.5 * dot(nor, vec3(0.0, 1.0, 0.0));
vec3 mat = vec3(0.1, 0.6, 0.7);
if(t.y == 1.0) {
vec2 st = pos.xy;
float p = 10.3;
mat2 rot2d = mat2(cos(p), sin(p), -sin(p), cos(p));
vec2 pos = st.xy * rot2d * vec2(7., 4.);
st.y *= u_resolution.y / u_resolution.x;
float pattern = pos.x;
vec2 pos1 = rotate2d(noise(pos) * .45) * pos;
pattern = lines(pos1, 0.3);
mat = vec3(0.33, pattern * 0.55 + 0.09, 0.21) * 0.1 + vec3(0.0, fbm_example(pos.xy * 2.24) * 0.04 + 0.03, 0.0);
}
if(t.y == 2.0) {
if(pos.x > -0.3 && pos.y < -0.23) {
if(pos.y > -0.3) {
mat = mix(vec3(0.99, 0.01, 0.01), vec3(0.001, 0.05, 0.6 * (snoise(pos.xy * 62.00) * 1.4 + 0.9)), snoise(pos.yy) * 1.95 + 0.91);
} else {
mat = vec3(0.001, 0.05, 0.6 * (snoise(pos.yx * 62.00) * 1.4 + 0.9));
}
} else if(0.7 * pos.x + pos.y < -.69) {
mat = mix(vec3(0.001, 0.05, 0.6 * (snoise(pos.xy * 62.00) * 1.4 + 0.9)), vec3(0.99, 0.01, 0.01), 1.5 * pos.x + pos.y + 1.46 + 0.12);
} else {
mat = mix(vec3(0.99, 0.01, 0.01), vec3((snoise((pos.zy + vec2(2.61, 5.4)) * 16.0) * 1.5 + 0.7), 0.01, 0.01), pos.x - pos.y * 0.4 - 0.3);
}
}
if(t.y == 3.0) {
mat = vec3(0.01);
}
col = vec3(0.2, 0.2, 0.2) * amb * 0.1 +
vec3(0.35, 0.55, 0.65) * dif * 0.1 + mat;
vec3 light_dir = normalize(LIGHT_POS - pos);
/* Shadows computed with raymarching. */
float sha = softshadow(pos + nor * 0.001, light_dir, 8.0);
/* Lighting is simple based on a point light. */
float sun = max(dot(nor, light_dir), 0.0);
vec3 lin = sun * LIGHT_COL * pow(vec3(sha), vec3(1.5));
col = col * lin;
// col=col*mat;
} else {
col = vec3(0.15, 0.12 * cnoise(p.xy * 1.2) + 0.21, 0.15);
}
// gamma
col = sqrt(col);
tot += col;
colour_out = vec4(tot, 1.0);
}
21. unknown by nagisa
More Student Works
The rest of the student works from 2022 are shown below. Note that some are very computationally expensive and may potentially cause issues with your browser. Show Other Student Works
// credit: Is
// frog: Ranitomeya amazonica
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float random(vec2 co) {
const highp float seed = 12.9898;
highp float a = seed;
highp float b = 78.233, c = 43758.5453;
highp float dt = dot(co.xy, vec2(a, b));
highp float sn = mod(dt, 3.14159265358979323846);
return fract(sin(sn) * c);
}
vec2 random2(vec2 p) { return vec2(random(p), random(p * 1000.0)); }
float stripe(vec2 st) {
float min_dist = 100.;
for (int y = -1; y <= 1; y++) {
for (int x = -1; x <= 1; x++) {
vec2 neighbor = vec2(float(x), float(y));
vec2 point = random2(floor(st) + neighbor);
point = 0.5 * sin(u_time + 8.155 * point);
min_dist =
min(min_dist, length(neighbor + point - (st - floor(st))));
}
}
return min_dist * abs(sin(st.x * 7.288));
}
float dots(vec2 st, float r) {
float min_dist = 100.;
for (int y = -1; y <= 1; y++) {
for (int x = -1; x <= 1; x++) {
vec2 neighbor = vec2(float(x), float(y));
vec2 point = random2(floor(st) + neighbor);
min_dist =
min(min_dist, length(neighbor + point - (st - floor(st))));
}
}
return step(r, min_dist);
}
float fbm_dots(in vec2 st) {
float value = 1.0;
float r = 0.208;
st *= 6.952;
st += vec2(10.0, 100.0) + u_time * 0.452;
for (int i = 0; i < 6; i++) {
value = min(value, dots(st, r));
st *= 1.312;
}
return value;
}
void main() {
vec2 st = gl_FragCoord.xy / u_resolution.xy * 0.764 - -0.116;
st = vec2(st.y, 1.0 - st.x); // rotate
float mask = 1.000;
{
// right eye
vec2 st1 = st - vec2(0.730, 0.700);
st1.x = -0.160 - st1.x;
vec2 p = vec2(-0.010, 0.000);
if (0.001 > 1.0 * pow(st1.x - p.x, 2.0) + 1.0 * pow(st1.y - p.y, 2.0)) {
colour_out = vec4(vec3(0.0), 1.0);
if (0.0001 > 1.0 * pow(st1.x - p.x + 0.01 * sin(u_time), 2.0) +
1.0 * pow(st1.y - p.y + 0.01 * sin(u_time), 2.0)) {
colour_out = vec4(vec3(1.0), 1.0);
}
return;
}
}
{
// left eye
vec2 st1 = st - vec2(0.580, 0.700);
st1.x = -0.160 - st1.x;
vec2 p = vec2(0.000, 0.000);
if (0.001 > 1.0 * pow(st1.x - p.x, 2.0) + 1.0 * pow(st1.y - p.y, 2.0)) {
colour_out = vec4(vec3(0.0), 1.0);
if (0.0001 >
1.0 * pow(st1.x - p.x - 0.01 * cos(u_time - 3.14 / 2.0), 2.0) +
1.0 * pow(st1.y - p.y + 0.01 * cos(u_time - 3.14 / 2.0),
2.0)) {
colour_out = vec4(vec3(1.0), 1.0);
}
return;
}
}
{
// body
if ((0.282 >
distance(vec2(st.x * 2.508, st.y), vec2(2.508 / 2.0, 0.5)) ||
0.178 > distance(vec2(st.x * 1.276, st.y),
vec2(1.276 / 2.0, 0.396))) &&
abs(st.x - 0.5) + st.y - 0.648 <= 0.120) {
st *= 7.616;
colour_out =
vec4(step(0.236, stripe(st)) * mix(vec3(0.865, 0.854, 0.019),
vec3(0.865, 0.383, 0.006),
abs(sin(u_time))),
1.0);
return;
}
}
{
// right back leg
vec2 st1 = st - vec2(0.110, -0.190);
mask *= step(0.003, 1.0 * pow(st1.x - 0.5, 2.000) +
1.0 * pow(st1.y - 0.5, 2.0) +
-1.320 * (st1.x - 0.5) * (st1.y - 0.5));
vec2 p1 = vec2(0.516, 0.476);
mask *= step(0.005, 2.520 * pow(st1.x - p1.x, 2.0) +
1.0 * pow(st1.y - p1.y, 2.0) +
-2.176 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.548, 0.468);
mask *= step(0.002, 1.480 * pow(st1.x - p2.x, 2.0) +
1.0 * pow(st1.y - p2.y, 2.0) +
-2.120 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.620, 0.556);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.604, 0.564);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.644, 0.556);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.636, 0.540);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// right front leg
vec2 st1 = st - vec2(0.090, 0.040);
vec2 p1 = vec2(0.508, 0.492);
mask *= step(0.005, 2.216 * pow(st1.x - p1.x, 2.0) +
2.352 * pow(st1.y - p1.y, 2.0) +
3.368 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.572, 0.508);
mask *= step(0.002, 5.400 * pow(st1.x - p2.x, 2.0) +
0.368 * pow(st1.y - p2.y, 2.0) +
0.832 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.584, 0.592);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.576, 0.600);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.6, 0.592);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.592, 0.578);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// left back leg
vec2 st1 = st - vec2(0.110, -0.190);
st1.x = 0.784 - st1.x;
mask *= step(0.003, 1.0 * pow(st1.x - 0.5, 2.000) +
1.0 * pow(st1.y - 0.5, 2.0) +
-1.320 * (st1.x - 0.5) * (st1.y - 0.5));
vec2 p1 = vec2(0.516, 0.476);
mask *= step(0.005, 2.520 * pow(st1.x - p1.x, 2.0) +
1.0 * pow(st1.y - p1.y, 2.0) +
-2.176 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.548, 0.468);
mask *= step(0.002, 1.480 * pow(st1.x - p2.x, 2.0) +
1.0 * pow(st1.y - p2.y, 2.0) +
-2.120 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.620, 0.556);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.604, 0.564);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.644, 0.556);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.636, 0.540);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
{
// left front leg
vec2 st1 = vec2(-st.x, st.y) - vec2(-0.910, 0.040);
vec2 p1 = vec2(0.508, 0.492);
mask *= step(0.005, 2.216 * pow(st1.x - p1.x, 2.0) +
2.352 * pow(st1.y - p1.y, 2.0) +
3.368 * (st1.x - p1.x) * (st1.y - p1.y));
vec2 p2 = vec2(0.572, 0.508);
mask *= step(0.002, 5.400 * pow(st1.x - p2.x, 2.0) +
0.368 * pow(st1.y - p2.y, 2.0) +
0.832 * (st1.x - p2.x) * (st1.y - p2.y));
vec2 p3 = vec2(0.584, 0.592);
mask *= step(0.0001, 1.480 * pow(st1.x - p3.x, 2.0) +
1.0 * pow(st1.y - p3.y, 2.0) +
-2.312 * (st1.x - p3.x) * (st1.y - p3.y));
vec2 p4 = vec2(0.576, 0.600);
mask *= step(0.00015, 2.800 * pow(st1.x - p4.x, 2.0) +
1.0 * pow(st1.y - p4.y, 2.0) +
-2.960 * (st1.x - p4.x) * (st1.y - p4.y));
vec2 p5 = vec2(0.6, 0.592);
mask *= step(0.00015, 0.920 * pow(st1.x - p5.x, 2.0) +
2.960 * pow(st1.y - p5.y, 2.0) +
-2.616 * (st1.x - p5.x) * (st1.y - p5.y));
vec2 p6 = vec2(0.592, 0.578);
mask *= step(0.00028, 0.544 * pow(st1.x - p6.x, 2.0) +
6.888 * pow(st1.y - p6.y, 2.0));
}
if (mask == 0.0) {
// legs
colour_out = fbm_dots(st) * vec4(vec3(0.037, 0.475, 1.000), 1.0);
return;
} else {
// leaf
colour_out =
vec4(mix(vec3(0.221, 0.560, 0.044), vec3(0.320, 0.735, 0.235),
abs(sin(st.y * 100.0 + u_time * 5.0))),
1.0);
}
}
0. Ranitomeya amazonica by Is
// credit: hosono
// frog: Dendrobates auratus
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float M_PI = 3.14159265359;
vec4 mod289(vec4 x)
{
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x)
{
return mod289(((x*34.0)+10.0)*x);
}
vec4 taylorInvSqrt(vec4 r)
{
return 1.79284291400159 - 0.85373472095314 * r;
}
vec2 fade(vec2 t) {
return t*t*t*(t*(t*6.0-15.0)+10.0);
}
// Classic Perlin noise
float cnoise(vec2 P)
{
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
vec4 gy = abs(gx) - 0.5 ;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x,gy.x);
vec2 g10 = vec2(gx.y,gy.y);
vec2 g01 = vec2(gx.z,gy.z);
vec2 g11 = vec2(gx.w,gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
float sdEllipse(vec2 p, vec2 ab)
{
p = abs(p); if( p.x > p.y ) {p=p.yx;ab=ab.yx;}
float l = ab.y*ab.y - ab.x*ab.x;
float m = ab.x*p.x/l; float m2 = m*m;
float n = ab.y*p.y/l; float n2 = n*n;
float c = (m2+n2-1.0)/3.0; float c3 = c*c*c;
float q = c3 + m2*n2*2.0;
float d = c3 + m2*n2;
float g = m + m*n2;
float co;
if( d<0.0 )
{
float h = acos(q/c3)/3.0;
float s = cos(h);
float t = sin(h)*sqrt(3.0);
float rx = sqrt( -c*(s + t + 2.0) + m2 );
float ry = sqrt( -c*(s - t + 2.0) + m2 );
co = (ry+sign(l)*rx+abs(g)/(rx*ry)- m)/2.0;
}
else
{
float h = 2.0*m*n*sqrt( d );
float s = sign(q+h)*pow(abs(q+h), 1.0/3.0);
float u = sign(q-h)*pow(abs(q-h), 1.0/3.0);
float rx = -s - u - c*4.0 + 2.0*m2;
float ry = (s - u)*sqrt(3.0);
float rm = sqrt( rx*rx + ry*ry );
co = (ry/sqrt(rm-rx)+2.0*g/rm-m)/2.0;
}
vec2 r = ab * vec2(co, sqrt(1.0-co*co));
return length(r-p) * sign(p.y-r.y);
}
float sdEquilateralTriangle(vec2 p)
{
const float k = sqrt(3.0);
p.x = abs(p.x) - 1.0;
p.y = p.y + 1.0/k;
if( p.x+k*p.y>0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
p.x -= clamp( p.x, -2.0, 0.0 );
return -length(p)*sign(p.y);
}
float sdMainBody(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.6, 0.35));
}
float sdHead(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEquilateralTriangle(5.232 * R * (P - slides)) - 0.8;
}
float sdUpperLeg(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.4, 0.1));
}
float sdLowerLeg(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.47, 0.13));
}
float sdFoot(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.3, 0.1));
}
float sdUpperArm(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.15, 0.05));
}
float sdLowerArm(vec2 P, vec2 slides, float theta) {
theta = 2.0 * M_PI * theta / 360.0;
mat2 R = mat2(cos(theta), -sin(theta), sin(theta), cos(theta));
return sdEllipse(R * (P - slides), vec2(0.23, 0.04));
}
vec3 get_bg_color(vec2 P) {
vec3 color1 = vec3(0.643,0.525,0.392);
vec3 color2 = vec3(0.447,0.474,0.514);
vec3 color3 = vec3(0.698,0.733,0.776);
float t = step(0.1, cnoise(2.0*P));
float u = step(0.3, cnoise(5.0*P));
vec3 out_color = mix(color1, mix(color2, color3, u), t);
out_color = mix(out_color, vec3(0.0), cnoise(200.0*P)*0.5);
return out_color;
}
vec3 get_frog_color(vec2 P) {
vec3 blue = vec3(0.43,0.71,0.90);
vec3 black = vec3(0.0);
float t = step(0.05, cnoise(12.0*P));
return mix(blue, black, t);
}
float get_frog_mask(vec2 P) {
P = P*2.0 - 1.0; // -1.0 <= P <= 1.0
float mask = 1.0;
mask *= step(0.0, sdMainBody(P, vec2(0.0, 0.1), -10.0));
mask *= step(0.0, sdHead(P, vec2(-0.5,0.2), 89.840));
mask *= step(0.0, sdUpperLeg(P, vec2(0.3, -0.2), 40.0));
mask *= step(0.0, sdLowerLeg(P, vec2(0.33, -0.35), 20.0));
mask *= step(0.0, sdFoot(P, vec2(0.6, -0.43), 70.0));
mask *= step(0.0, sdUpperArm(P, vec2(-0.22,-0.25), -30.0));
mask *= step(0.0, sdLowerArm(P, vec2(-0.31,-0.42), 30.0));
return mask;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec4 bg_color = vec4(get_bg_color(st), 1.0);
vec4 frog_color = vec4(get_frog_color(st), 1.0);
float mask = get_frog_mask(st.xy);
colour_out = mix(frog_color, bg_color, mask);
}
3. unknown by hosono
// credit: jenniroutine
// frog: Dendrobates_leucomelas
precision mediump float;
uniform vec2 u_resolution;
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 3.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 230.0 * dot(m, g) ;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
float mask = 1.0;
mask *= step( 0.096, distance( st.xy, vec2(0.690,0.690) ) );
mask *= step( 0.064, distance( st.xy, vec2(0.740,0.720) ) );
mask *= step( 0.056, distance( st.xy, vec2(0.660,0.740) ) );
mask *= step( 0.146, distance( st.xy, vec2(0.580,0.520) ) );
mask *= step( 0.166, distance( st.xy, vec2(0.540,0.450) ) );
mask *= step( 0.166, distance( st.xy, vec2(0.520,0.380) ) );
mask *= step( 0.082, distance( st.xy, vec2(0.370,0.280) ) );
float s = 1.048 + -0.348 * 0.864;
mask *= step( 0.072, distance( vec2(st.x*s,st.y), vec2(0.360,0.220) ) );
mask *= step( 0.064, distance( st.xy, vec2(0.570,0.150) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.510,0.110) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.470,0.100) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.430,0.100) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.390,0.110) ) );
mask *= step( 0.032, distance( st.xy, vec2(0.520,0.070) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.680,0.390) ) );
mask *= step( 0.040, distance( st.xy, vec2(0.690,0.340) ) );
mask *= step( 0.035, distance( st.xy, vec2(0.710,0.300) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.740,0.280) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.770,0.260) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.290,0.280) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.270,0.260) ) );
mask *= step( 0.033, distance( st.xy, vec2(0.260,0.250) ) );
float n = snoise( gl_FragCoord.xy / 30.0 );
n = n*0.5 + 0.5; /* Map from [-1,1] to [0,1] */
colour_out = vec4( vec2(n), 0.0, 1.0 );
if (step( 0.050, distance( st.xy, vec2(0.730,0.630) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.050, distance( st.xy, vec2(0.790,0.670) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
s = 1.024 + -0.332 * 0.936;
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.400,0.590) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.450,0.560) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.310,0.400) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
if (step( 0.082, distance( vec2(st.x*s,st.y), vec2(0.410,0.340) ) )==0.0) colour_out = vec4( vec3(0.0), 1.0 );
colour_out *= 1.0-mask;
}
5. Dendrobates leucomelas by jenniroutine
// author: wbelucky
// Dendrobates tinctorius "azureus"
// noise func from webgl-noise
//
// Description : Array and textureless GLSL 2D simplex noise function.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
float sdVesica(vec2 p, float r, float d)
{
p = abs(p);
float b = sqrt(r*r-d*d);
return ((p.y-b)*d>p.x*b) ? length(p-vec2(0.0,b))
: length(p-vec2(-d,0.0))-r;
}
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec2 p = 2. * st - vec2(1.);
const float PI = 3.14159;
float theta = PI / 3.;
mat2 r = mat2( cos(theta),-sin(theta),
sin(theta),cos(theta));
p += vec2(0.3, 0.3);
p *= 1. / 2.;
p *= r;
float n = snoise(p * 6. + 0.3 * u_time);
vec4 main_color = mix(vec4(0.001,0.537,0.870,1.000), vec4(0.140,0.140,0.140, 1.), step(0.2, n));
float is_main = step(0.5, step(sdVesica(p, 0.208, 0.344), 0.5) // body
+ step(distance(st, vec2(0.540,0.630)), 0.17)); // left eye
colour_out = mix(vec4(1.),main_color, is_main)
* step(0.094, distance(st, vec2(0.660,0.430))); // right eye
}
8. Dendrobates tinctorius "azureus" by
wbelucky
// credit: shaw
// frog: Dendrobates tinctorius Freetoast
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float hash( float n )
{
return fract(sin(n)*43758.5453);
}
float noise( vec2 x )
{
vec2 p = floor(x);
vec2 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*57.0;
return mix(mix( hash(n+ 0.0), hash(n+ 1.0),f.x),
mix( hash(n+ 57.0), hash(n+ 58.0),f.x),f.y);
}
float marbleturbulence(vec2 p) {
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(2.0, 4.0 / 3.0), float(i));
f += abs(noise( p * scale )) / scale;
}
return f;
}
mat2 m = mat2( 0.8, 0.6, -0.6, 0.8 );
float fbm( vec2 p ) {
float f = 0.0;
f += 0.5000 * noise( p ); p *= m*2.02;
f += 0.2500 * noise( p ); p *= m*2.01;
f += 0.1250 * noise( p ); p *= m*2.03;
f += 0.0625 * noise( p ); p *= m*2.04;
f /= 0.9375;
return f;
}
void main() {
vec2 p = gl_FragCoord.xy/u_resolution.xy;
float mask = 1.0;
mask *= step( 0.5, distance( p.xy, vec2(0.50,0.060) ) ); // down
mask *= step( 0.18, distance( p.xy, vec2(0.310,0.410) ) ); // right
mask *= step( 0.18, distance( p.xy, vec2(0.690,0.410) ) ); // left
vec3 background = vec3(89.0 / 255.0, 151.0 / 255.0, 30.0 / 255.0);
vec3 mouth = vec3(184.0 / 255.0, 223.0 / 255.0, 200.0 / 255.0);
// background fbm
float f = fbm(1.0 * p);
vec3 col = mix(background, vec3(0.1, 0.1, 0.1), f);
// head
vec3 head = vec3( 172.0 / 255.0, 229.0 / 255.0, 210.0 / 255.0 );
col = mix(head, col, mask);
if(mask == 0.0) {
// skin: random dots
vec2 ti = floor(9.0 + p / 0.08);
vec2 uv = fract(p / 0.08) - 0.5;
float rho = fract(111.0 * sin(1111.0 * ti.x + 1331.0 * ti.y));
rho = smoothstep(0.6, 1.1, rho)*exp(-dot(uv,uv)*24.0);
col *= mix(head, vec3(0.0), rho);
// skin: random black bars
float n = marbleturbulence(gl_FragCoord.xy / 500.0);
float t = 1.0 + sin(gl_FragCoord.x / 80.0 + 20.0 * n) / 2.0;
col = mix(col, 1.0 - vec3(t), 0.4*t);
// mouth
f = 1.0 - step(0.50, length(p - vec2(0.5, -0.25)));
col = mix(col, mouth, f);
f = 1.0 - step(0.05, length(p - vec2(0.35, 0.21)));
col = mix(col, mouth, f);
f = 1.0 - step(0.05, length(p - vec2(0.65, 0.21)));
col = mix(col, mouth, f);
// left eye
float r = length(p - vec2(0.690,0.410));
// outmost
f = 1.0 - smoothstep(0.09, 0.12, r);
col = mix(col, vec3(1.0), f);
// gray part
f = 1.0 - smoothstep(0.085, 0.1, r);
col = mix(col, vec3(0.15, 0.15, 0.15), f);
// yellow part
//f = 1.0 - smoothstep(0.03, 0.10, r);
//col = mix(col, vec3(0.9, 0.6, 0.2), f);
// center black circle
//f = 1.0 - smoothstep(0.02, 0.04, r);
//col = mix(col, vec3(0.0, 0.0, 0.0), f);
// highlight
f = 1.0 - smoothstep(0.0, 0.03, length(p - vec2(0.720, 0.420)));
col += vec3(1.0, 0.9, 0.8) * vec3(f) * 0.9;
// right eye
r = length(p - vec2(0.310,0.410));
f = 1.0 - smoothstep(0.09, 0.12, r);
col = mix(col, vec3(1.0), f);
f = 1.0 - smoothstep(0.085, 0.1, r);
col = mix(col, vec3(0.15, 0.15, 0.15), f);
f = 1.0 - smoothstep(0.0, 0.03, length(p - vec2(0.340, 0.420)));
col += vec3(1.0, 0.9, 0.8) * vec3(f) * 0.9;
}
colour_out = vec4(col, 1.0);
}
9. Dendrobates tinctorius Freetoast by
shaw
// credit: Tori
// frog: Dendrobates galactonotus
uniform vec2 u_resolution;
float myCircle( vec2 p, vec2 center, float r, float threshold )
{
return step( threshold, length( p-center ) - r );
}
float myUnevenCapsule( vec2 p, float r1, float r2, float h, float offset, float threshold )
{
p.x = abs(p.x - 0.5);
p.y -= offset;
float b = (r2-r1)/h;
float a = sqrt(1.0-b*b);
float k = dot(p,vec2(-b,a));
float val;
if( k < 0.0 )
val = length(p) - r2;
else if( k > a*h )
val = length(p-vec2(0.0,h)) - r1;
else
val = dot(p, vec2(a,b) ) - r2;
return step( threshold, val );
}
float myFrogLimb( vec2 pos, vec2 A, vec2 B, vec2 C, float threshold )
{
vec2 a = B - A;
vec2 b = A - 2.0*B + C;
vec2 c = a * 2.0;
vec2 d = A - pos;
float kk = 1.0/dot(b,b);
float kx = kk * dot(a,b);
float ky = kk * (2.0*dot(a,a)+dot(d,b)) / 3.0;
float kz = kk * dot(d,a);
float res = 0.0;
float p = ky - kx*kx;
float p3 = p*p*p;
float q = kx*(2.0*kx*kx-3.0*ky) + kz;
float h = q*q + 4.0*p3;
if( h >= 0.0 )
{
h = sqrt(h);
vec2 x = (vec2(h,-h)-q)/2.0;
vec2 uv = sign(x)*pow(abs(x), vec2(1.0/3.0));
float t = clamp( uv.x+uv.y-kx, 0.0, 1.0 );
res = dot(d + (c + b*t)*t, d + (c + b*t)*t );
}
else
{
float z = sqrt(-p);
float v = acos( q/(p*z*2.0) ) / 3.0;
float m = cos(v);
float n = sin(v)*1.732050808;
vec3 t = clamp(vec3(m+m,-n-m,n-m)*z-kx,0.0,1.0);
res = min( dot(d+(c+b*t.x)*t.x, d+(c+b*t.x)*t.x),
dot(d+(c+b*t.y)*t.y, d+(c+b*t.y)*t.y) );
}
return step( threshold, sqrt( res ) );
}
float myFrogHand( vec2 p, float r, vec2 root, float arg, float threshold )
{
arg = arg * 3.14159 / 180.0;
p -= root;
float tmp = p.x;
arg -= 1.570795;
p.x = p.x * cos( arg ) - p.y * sin( arg );
p.y = tmp * sin( arg ) + p.y * cos( arg );
p += root;
if( atan( p.x - root.x, p.y - root.y ) < 0.0 )
return 1.0;
p = abs( p - root );
float an = 3.141593/8.0;
float en = 3.141593/7.0;
vec2 acs = vec2(cos(an),sin(an));
vec2 ecs = vec2(cos(en),sin(en));
float bn = mod(atan(p.x,p.y)+0.3925,2.0*an) - an;
p = length(p)*vec2(cos(bn),abs(sin(bn)));
p -= r*acs;
p += ecs*clamp( -dot(p,ecs), 0.0, r*acs.y/ecs.y);
return step( threshold, length(p)*sign(p.x) );
}
vec3 myBodyColor( vec2 p ){
float scale = 5.0;
p *= scale;
p.x += 0.4;
p.y += ( p.x - fract( p.x ) ) * 0.4;
vec2 center = vec2( p.x - fract( p.x ) + 0.5, p.y - fract( p.y ) + 0.5 );
float mask = step( 0.4, length( center - p ) );
return mask * vec3( 0.525, 0.922, 0.204 );
}
vec3 myLimbColor( vec2 p ){
float scale = 20.0;
p *= scale;
p.y += ( p.x - fract( p.x ) ) * 0.5;
vec2 center = vec2( p.x - fract( p.x ) + 0.5, p.y - fract( p.y ) + 0.5 );
float mask = step( 0.4, length( center - p ) );
return mask * vec3( 0.204, 0.729, 0.922 );
}
vec3 myBackColor( vec2 p ){
float sum1 = 2.0 * p.x + p.y;
float sum2 = p.x + 2.0 * p.y;
float diff = p.y - p.x;
float branchMask = 1.0;
branchMask = min( branchMask, step( 0.03, abs( diff + 0.3 ) ) );
if( diff > -0.3 ){
branchMask = min( branchMask, step( 0.03, abs( sum1 - 1.3 ) ) );
branchMask = min( branchMask, step( 0.03, abs( sum1 - 0.7 ) ) );
}else{
branchMask = min( branchMask, step( 0.03, abs( sum2 - 1.5 ) ) );
branchMask = min( branchMask, step( 0.03, abs( sum2 - 0.5 ) ) );
}
return mix( vec3( 0.541, 0.431, 0.275 ), vec3( 0.518, 0.580, 0.388 ), branchMask );
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
// body
float headRadius = 0.02;
float bodyRadius = 0.10;
float bodyLength = 0.4;
float bodyOffset = 0.3;
float bodyThreshold = 0.1;
// eye
float eyeRadius = 0.025;
vec2 leftEyeCenter = vec2( 0.4, 0.8 );
vec2 rightEyeCenter = vec2( 0.6, 0.8 );
float eyeThreshold = 0.01;
// arm
float armThreshold = 0.015;
vec2 leftArmRoot = vec2( 0.375, 0.65 );
vec2 leftArmAnchor = vec2( 0.3, 0.5 );
vec2 leftArmTip = vec2( 0.3, 0.7 );
vec2 rightArmRoot = vec2( 0.64, 0.6 );
vec2 rightArmAnchor = vec2( 0.675, 0.45 );
vec2 rightArmTip = vec2( 0.8, 0.6 );
// leg
float legThreshold = 0.02;
vec2 leftLegRoot = vec2( 0.35, 0.2 );
vec2 leftLegAnchor1 = vec2( 0.2, 0.5 );
vec2 leftLegJoint = vec2( 0.29, 0.2 );
vec2 leftLegAnchor2 = vec2( 0.4, 0.0 );
vec2 leftLegTip = vec2( 0.2, 0.3 );
vec2 rightLegRoot = vec2( 0.65, 0.2 );
vec2 rightLegAnchor1 = vec2( 0.8, 0.5 );
vec2 rightLegJoint = vec2( 0.71, 0.2 );
vec2 rightLegAnchor2 = vec2( 0.6, 0.0 );
vec2 rightLegTip = vec2( 0.8, 0.2 );
// hand
float handThreshold = 0.01;
float handSize = 0.1;
vec2 leftHandRoot = vec2( 0.3, 0.7 );
float leftHandArg = -10.0;
vec2 rightHandRoot = vec2( 0.8, 0.6 );
float rightHandArg = 20.0;
// foot
float footThreshold = 0.01;
float footSize = 0.1;
vec2 leftFootRoot = vec2( 0.2, 0.3 );
float leftFootArg = -35.0;
vec2 rightFootRoot = vec2( 0.8, 0.2 );
float rightFootArg = 45.0;
// background
float backMask = 1.0;
float bodyMask = 1.0;
bodyMask = min( bodyMask, myUnevenCapsule( st, headRadius, bodyRadius, bodyLength, bodyOffset, bodyThreshold ) );
bodyMask = min( bodyMask, myCircle( st, leftEyeCenter, eyeRadius, eyeThreshold ) );
bodyMask = min( bodyMask, myCircle( st, rightEyeCenter, eyeRadius, eyeThreshold ) );
backMask = min( backMask, bodyMask );
bodyMask = 1.0 - bodyMask;
vec3 bodyColor = myBodyColor( st );
bodyColor *= bodyMask;
float limbMask = 1.0;
limbMask = min( limbMask, myFrogLimb( st, leftArmRoot, leftArmAnchor, leftArmTip, armThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightArmRoot, rightArmAnchor, rightArmTip, armThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, leftLegRoot, leftLegAnchor1, leftLegJoint, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, leftLegJoint, leftLegAnchor2, leftLegTip, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightLegRoot, rightLegAnchor1, rightLegJoint, legThreshold ) );
limbMask = min( limbMask, myFrogLimb( st, rightLegJoint, rightLegAnchor2, rightLegTip, legThreshold ) );
limbMask = min( limbMask, myFrogHand( st, handSize, leftHandRoot, leftHandArg, handThreshold ) );
limbMask = min( limbMask, myFrogHand( st, handSize, rightHandRoot, rightHandArg, handThreshold ) );
limbMask = min( limbMask, myFrogHand( st, footSize, leftFootRoot, leftFootArg, footThreshold ) );
limbMask = min( limbMask, myFrogHand( st, footSize, rightFootRoot, rightFootArg, footThreshold ) );
backMask = min( backMask, limbMask );
limbMask = 1.0 - limbMask;
vec3 limbColor = myLimbColor( st );
limbColor *= limbMask;
vec3 backColor = myBackColor( st );
colour_out = vec4( backColor * backMask, 1.0 );
colour_out += vec4( max( bodyColor, limbColor ), 1.0 );
}
11. Dendrobates galactonotus by Tori
// Name - LeeHyeonJoon
// Scientific Name of the Frog - Oophaga pumilio (strawberry poison-dart frog)
uniform vec2 u_resolution;
// Modulo 289 without a division (only multiplications)
vec3 mod289(vec3 x){
return x-floor(x*(1./289.))*289.;
}
vec2 mod289(vec2 x){
return x-floor(x*(1./289.))*289.;
}
// Modulo 7 without a division
vec3 mod7(vec3 x){
return x-floor(x*(1./7.))*7.;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec3 permute(vec3 x){
return mod289((34.*x+10.)*x);
}
// Cellular (Worley) noise, returning F1 and F2 in a vec2.
// Standard 3x3 search window for good F1 and F2 values
vec2 cellular(vec2 P){
#define K .142857142857// 1/7
#define Ko .428571428571// 3/7
#define jitter 1.0// Less gives more regular pattern
vec2 Pi=mod289(floor(P));
vec2 Pf=fract(P);
vec3 oi=vec3(-1.,0.,1.);
vec3 of=vec3(-.5,.5,1.5);
vec3 px=permute(Pi.x+oi);
vec3 p=permute(px.x+Pi.y+oi);// p11, p12, p13
vec3 ox=fract(p*K)-Ko;
vec3 oy=mod7(floor(p*K))*K-Ko;
vec3 dx=Pf.x+.5+jitter*ox;
vec3 dy=Pf.y-of+jitter*oy;
vec3 d1=dx*dx+dy*dy;// d11, d12 and d13, squared
p=permute(px.y+Pi.y+oi);// p21, p22, p23
ox=fract(p*K)-Ko;
oy=mod7(floor(p*K))*K-Ko;
dx=Pf.x-.5+jitter*ox;
dy=Pf.y-of+jitter*oy;
vec3 d2=dx*dx+dy*dy;// d21, d22 and d23, squared
p=permute(px.z+Pi.y+oi);// p31, p32, p33
ox=fract(p*K)-Ko;
oy=mod7(floor(p*K))*K-Ko;
dx=Pf.x-1.5+jitter*ox;
dy=Pf.y-of+jitter*oy;
vec3 d3=dx*dx+dy*dy;// d31, d32 and d33, squared
// Sort out the two smallest distances (F1, F2)
vec3 d1a=min(d1,d2);
d2=max(d1,d2);// Swap to keep candidates for F2
d2=min(d2,d3);// neither F1 nor F2 are now in d3
d1=min(d1a,d2);// F1 is now in d1
d2=max(d1a,d2);// Swap to keep candidates for F2
d1.xy=(d1.x<d1.y)?d1.xy:d1.yx;// Swap if smaller
d1.xz=(d1.x<d1.z)?d1.xz:d1.zx;// F1 is in d1.x
d1.yz=min(d1.yz,d2.yz);// F2 is now not in d2.yz
d1.y=min(d1.y,d1.z);// nor in d1.z
d1.y=min(d1.y,d2.x);// F2 is in d1.y, we're done.
return sqrt(d1.xy);
}
float snoise(vec2 v){
const vec4 C=vec4(.211324865405187,// (3.0-sqrt(3.0))/6.0
.366025403784439,// 0.5*(sqrt(3.0)-1.0)
-.577350269189626,// -1.0 + 2.0 * C.x
.024390243902439);// 1.0 / 41.0
// First corner
vec2 i=floor(v+dot(v,C.yy));
vec2 x0=v-i+dot(i,C.xx);
// Other corners
vec2 i1;
i1=(x0.x>x0.y)?vec2(1.,0.):vec2(0.,1.);
vec4 x12=x0.xyxy+C.xxzz;
x12.xy-=i1;
// Permutations
i=mod289(i);// Avoid truncation effects in permutation
vec3 p=permute(permute(i.y+vec3(0.,i1.y,1.))
+i.x+vec3(0.,i1.x,1.));
vec3 m=max(.5-vec3(dot(x0,x0),dot(x12.xy,x12.xy),dot(x12.zw,x12.zw)),0.);
m=m*m;
m=m*m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x=2.*fract(p*C.www)-1.;
vec3 h=abs(x)-.5;
vec3 ox=floor(x+.5);
vec3 a0=x-ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m*=1.79284291400159-.85373472095314*(a0*a0+h*h);
// Compute final noise value at P
vec3 g;
g.x=a0.x*x0.x+h.x*x0.y;
g.yz=a0.yz*x12.xz+h.yz*x12.yw;
return 130.*dot(m,g);
}
float customEllipse(vec2 p,vec2 ab,float rad,vec2 center){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
p=(inverse(H)*vec3(p,1.)).xy;
p=abs(p);if(p.x>p.y){p=p.yx;ab=ab.yx;}
float l=ab.y*ab.y-ab.x*ab.x;
float m=ab.x*p.x/l;float m2=m*m;
float n=ab.y*p.y/l;float n2=n*n;
float c=(m2+n2-1.)/3.;float c3=c*c*c;
float q=c3+m2*n2*2.;
float d=c3+m2*n2;
float g=m+m*n2;
float co;
if(d<0.)
{
float h=acos(q/c3)/3.;
float s=cos(h);
float t=sin(h)*sqrt(3.);
float rx=sqrt(-c*(s+t+2.)+m2);
float ry=sqrt(-c*(s-t+2.)+m2);
co=(ry+sign(l)*rx+abs(g)/(rx*ry)-m)/2.;
}
else
{
float h=2.*m*n*sqrt(d);
float s=sign(q+h)*pow(abs(q+h),1./3.);
float u=sign(q-h)*pow(abs(q-h),1./3.);
float rx=-s-u-c*4.+2.*m2;
float ry=(s-u)*sqrt(3.);
float rm=sqrt(rx*rx+ry*ry);
co=(ry/sqrt(rm-rx)+2.*g/rm-m)/2.;
}
vec2 r=ab*vec2(co,sqrt(1.-co*co));
return length(r-p)*sign(p.y-r.y);
}
float customUnevenCapsule(vec2 p,float r1,float r2,float h,float rad,vec2 center){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
p=(inverse(H)*vec3(p,1.)).xy;
p.x=abs(p.x);
float b=(r1-r2)/h;
float a=sqrt(1.-b*b);
float k=dot(p,vec2(-b,a));
if(k<0.)return length(p)-r1;
if(k>a*h)return length(p-vec2(0.,h))-r2;
return dot(p,vec2(a,b))-r1;
}
float customBlobbyCross(vec2 pos,float he,float rad,vec2 center,float size){
mat3 H=mat3(
cos(rad),sin(rad),0,
-sin(rad),cos(rad),0,
center.x,center.y,1);
pos=(inverse(H)*vec3(pos,1.)).xy;
pos=abs(pos)/size;
pos=vec2(abs(pos.x-pos.y),1.-pos.x-pos.y)/sqrt(2.);
float p=(he-pos.y-.25/he)/(6.*he);
float q=pos.x/(he*he*16.);
float h=q*q-p*p*p;
float x;
if(h>0.){float r=sqrt(h);x=pow(q+r,1./3.)-pow(abs(q-r),1./3.)*sign(r-q);}
else{float r=sqrt(p);x=2.*r*cos(acos(q/(p*r))/3.);}
x=min(x,sqrt(2.)/2.);
vec2 z=vec2(x,he*(1.-2.*x*x))-pos;
return length(z)*sign(z.y);
}
float colour_cellular(vec2 xy){return cellular(xy).x*2.-1.;}
void main(){
vec2 st=(gl_FragCoord.xy/u_resolution.xy)*2.-1.;
vec3 xyz=vec3(st,0);
// light blue (feet)
float light_blue=colour_cellular(xyz.xy*20.);
vec3 colour_light_blue=vec3(.3+.5*vec3(light_blue));
colour_light_blue=1.-colour_light_blue;
// blue (rear legs and the lower part of front legs)
float blue=colour_cellular(xyz.xy*20.);
vec3 colour_blue=vec3(.7+.7*vec3(blue));
colour_blue=1.-colour_blue;
// red (body and the upper part of front legs)
float red=snoise(xyz.xy*7.);
vec3 colour_red=vec3(.3+.6*vec3(red));
// background
float background=colour_cellular(xyz.xy*2.);
vec3 colour_background=vec3(.3+.4*vec3(background));
colour_out=vec4(colour_background.x-.5,colour_background.y,colour_background.z-.5,1.);
// eyes
float mask=1.;
mask*=step(.09,distance(st.xy,vec2(.15,.4)));
mask*=step(.09,distance(st.xy,vec2(-.15,.4)));
if(mask==0.){
colour_out=vec4(0.0, 0.0, 0.0, 1.0);
}
// light blue part
mask=1.;
mask*=step(0.,customBlobbyCross(st.xy,.6,.5,vec2(.55,.25),.1)-.2);// right front feet
mask*=step(0.,customBlobbyCross(st.xy,.6,-.8,vec2(-.44,.25),.1)-.2);// left front feet
mask*=step(0.,customBlobbyCross(st.xy,.6,1.,vec2(.57,-.63),.15)-.2);// right rear feet
mask*=step(0.,customBlobbyCross(st.xy,.6,1.,vec2(-.56,-.77),.15)-.2);// left rear feet
if(mask==0.){
colour_out=vec4(colour_light_blue.x-.6,colour_light_blue.y-.2,colour_light_blue.z,1.);
}
// blue part
mask=1.;
mask*=step(0.,customEllipse(st.xy,vec2(.15,.04),1.2,vec2(.5,.11)));// right front leg
mask*=step(0.,customEllipse(st.xy,vec2(.15,.04),1.5,vec2(-.45,.11)));// left front leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.11),.5,vec2(.25,-.42)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.11),-.5,vec2(-.25,-.42)));// left rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.09),1.,vec2(.33,-.5)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.25,.09),-1.,vec2(-.33,-.5)));// left rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.2,.05),.15,vec2(.38,-.66)));// right rear leg
mask*=step(0.,customEllipse(st.xy,vec2(.2,.05),.25,vec2(-.38,-.73)));// left rear leg
if(mask==0.){
colour_out=vec4(colour_blue.x-.8,colour_blue.y-.2,colour_blue.z,1.);
}
// red part
mask=1.;
mask*=step(0.,customEllipse(st.xy,vec2(.6,.25),1.55,vec2(0)));// body
mask*=step(0.,customUnevenCapsule(st.xy,.04,.05,.25,1.,vec2(.45,0.)));// right front leg
mask*=step(0.,customUnevenCapsule(st.xy,.04,.05,.25,-1.,vec2(-.45,0.)));// left front leg
mask*=step(0.,customEllipse(st.xy,vec2(.11,.09),1.8,vec2(.115,.39)));// right eyelid
mask*=step(0.,customEllipse(st.xy,vec2(.11,.09),-1.8,vec2(-.115,.39)));// left eyelid
if(mask==0.){
colour_out=vec4(colour_red.x,colour_red.y-1.,colour_red.z-1.,1.);
}
// light
colour_out.xyz+=vec3(.04/distance(st,vec2(.15,.43)));
}
13. Oophaga pumilio by LeeHyeonJoon
// credit: TATyz
// frog: Blue Poison Dart Frog
#define BLADES_SPACING 0.004
#define JITTER_MAX 0.004
// depends on size of grass blades in pixels
#define LOOKUP_DIST 5
#define HASHSCALE1 .1031
#define HASHSCALE3 vec3(.1031, .1030, .0973)
precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
float msign(in float x) { return (x<0.0)?-1.0:1.0; }
// background grass start
float hash12(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE1);
p3 += dot(p3, p3.yzx + 19.19);
return fract((p3.x + p3.y) * p3.z);
}
/// 3 out, 2 in...
vec3 hash32(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE3);
p3 += dot(p3, p3.yxz+19.19);
return fract((p3.xxy+p3.yzz)*p3.zyx);
}
/// 2 out, 2 in...
vec2 hash22(vec2 p)
{
vec3 p3 = fract(vec3(p.xyx) * HASHSCALE3);
p3 += dot(p3, p3.yzx+19.19);
return fract((p3.xx+p3.yz)*p3.zy);
}
vec3 getGrassColor(float x) {
vec3 a = vec3(0.2, 0.4, 0.3);
vec3 b = vec3(0.3, 0.5, 0.2);
vec3 c = vec3(0.2, 0.4, 0.2);
vec3 d = vec3(0.66, 0.77, 0.33);
vec3 col = a + b * cos(2. * 3.14 * (c * x + d));
return col;
}
float getGrassBlade(in vec2 position, in vec2 grassPos, out vec4 color) {
// between {-1, -1, -1} and {1, 1, 1}
vec3 grassVector3 = hash32(grassPos * 123512.41) * 2.0 - vec3(1);
// keep grass z between 0 and 0.4
grassVector3.z = grassVector3.z * 0.2 + 0.2;
vec2 grassVector2 = normalize(grassVector3.xy);
float grassLength = hash12(grassPos * 102348.7) * 0.01 + 0.012;
// take coordinates in grass blade frame
vec2 gv = position - grassPos;
float gx = dot(grassVector2, gv);
float gy = dot(vec2(-grassVector2.y, grassVector2.x), gv);
float gxn = gx / grassLength;
// TODO make gy depends to gx
if (gxn >= 0.0 && gxn <= 1.0 && abs(gy) <= 0.0008 * (1. - gxn * gxn)) {
vec3 thisGrassColor = getGrassColor(hash12(grassPos * 2631.6));
color = vec4(thisGrassColor * (0.2 + 0.8 * gxn), 1.0);
return grassVector3.z * gxn;
}
else {
color = vec4(0., 0., 0., 1.);
return -1.0;
}
}
float getPoint(in vec2 position, out vec4 color) {
int xcount = int(1. / BLADES_SPACING);
int ycount = int(1. / BLADES_SPACING);
int ox = int(position.x * float(xcount));
int oy = int(position.y * float(ycount));
float maxz = 0.0;
for (int i = -LOOKUP_DIST; i < LOOKUP_DIST; ++i) {
for (int j = -LOOKUP_DIST; j < LOOKUP_DIST; ++j) {
vec2 upos = vec2(ox + i, oy + j);
vec2 grassPos = (upos * BLADES_SPACING + hash22(upos) * JITTER_MAX);
vec4 tempColor;
float z = getGrassBlade(position, grassPos, tempColor);
if (z > maxz) {
maxz = z;
color = tempColor;
}
}
}
if (maxz == 0.0) {
color = vec4(0.);
}
return maxz;
}
// end
float sdUnion( float d1, float d2 ) {
return min( d1, d2 );
}
float sdDifference( float d1, float d2 ) {
return max( -d1, d2 ); /* Remove d1 from d2 */
}
float sdEllipse( vec2 p, in vec2 ab , in vec2 bias, in float rot)
{
//if( ab.x==ab.y ) return length(p)-ab.x;
vec2 p0 = p;
p.x = p0.x * cos(rot) - p0.y * sin(rot);
p.y = p0.x * sin(rot) + p0.y * cos(rot);
p = abs( p + bias);
if( p.x>p.y ){ p=p.yx; ab=ab.yx; }
float l = ab.y*ab.y - ab.x*ab.x;
float m = ab.x*p.x/l;
float n = ab.y*p.y/l;
float m2 = m*m;
float n2 = n*n;
float c = (m2+n2-1.0)/3.0;
float c3 = c*c*c;
float d = c3 + m2*n2;
float q = d + m2*n2;
float g = m + m *n2;
float co;
if( d<0.0 )
{
float h = acos(q/c3)/3.0;
float s = cos(h) + 2.0;
float t = sin(h) * sqrt(3.0);
float rx = sqrt( m2-c*(s+t) );
float ry = sqrt( m2-c*(s-t) );
co = ry + sign(l)*rx + abs(g)/(rx*ry);
}
else
{
float h = 2.0*m*n*sqrt(d);
float s = msign(q+h)*pow( abs(q+h), 1.0/3.0 );
float t = msign(q-h)*pow( abs(q-h), 1.0/3.0 );
float rx = -(s+t) - c*4.0 + 2.0*m2;
float ry = (s-t)*sqrt(3.0);
float rm = sqrt( rx*rx + ry*ry );
co = ry/sqrt(rm-rx) + 2.0*g/rm;
}
co = (co-m)/2.0;
float si = sqrt( max(1.0-co*co,0.0) );
vec2 r = ab * vec2(co,si);
return length(r-p) * msign(p.y-r.y);
}
float sdEgg( in vec2 p, in float ra, in float rb, in vec2 bias, in float rot)
{
const float k = sqrt(3.0);
vec2 p0 = p;
p.x = p0.x * cos(rot) - p0.y * sin(rot);
p.y = p0.x * sin(rot) + p0.y * cos(rot);
p.y = p.y + bias.y;
p.x = abs(p.x + bias.x);
float r = ra - rb;
return ((p.y<0.0) ? length(vec2(p.x, p.y )) - r :
(k*(p.x+r)<p.y) ? length(vec2(p.x, p.y-k*r)) :
length(vec2(p.x+r,p.y )) - 2.0*r) - rb;
}
float udSegment( in vec2 p, in vec2 a, in vec2 b )
{
vec2 ba = b-a;
vec2 pa = p-a;
float h =clamp( dot(pa,ba)/dot(ba,ba), 0.0, 1.0 );
return length(pa-h*ba);
}
float sdCircle( in vec2 p, in float r )
{
return length(p)-r;
}
// texture
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
vec3 body_bubble( in vec2 p , in vec2 resolution, in float time)
{
// background
//vec3 color = vec3(0.137, 0.582, 0.836);
vec3 color = vec3(0.008, 0.348, 0.590) + vec3(sin(0.5*p.x));
// bubbles
for( int i=0; i<1000; i++ )
{
// bubble seeds
float pha = sin(float(i)*546.13+5.0)*0.5 + 0.5;
float siz = pow( sin(float(i)*652.74+6.0)*0.5 + 0.5, 9.0 );
if (siz > 0.15){
continue;
}
float pox = sin(float(i)*321.55+6.1) * resolution.x / resolution.y;
// buble size, position and color
float rad = (0.04 + 0.5*siz)+0.03*sin(16.0*p.y)*abs(cos(0.5*time+0.2))-0.03*sin(15.0*p.x)*abs(sin(0.5*time-0.1)) ; // shape of all
vec2 pos = vec2( pox, -1.0-rad + (2.0+2.0*rad)*mod(pha+0.1*(0.2+0.8*siz),1.0));
float dis = length( p - pos -vec2(-.001,.001)); // control circle shape
// vec3 col = mix( vec3(0.94,0.3,0.0), vec3(0.1,0.4,0.8), 0.5+0.5*sin(float(i)*1.2+1.9));
vec3 col = vec3(0.6);
// col+= 8.0*smoothstep( rad*0.95, rad, dis );
// render
float f = length(p-pos)/rad;
f = sqrt(clamp(1.0-f*f,0.0,1.0));
color -= col.zyx *(1.0-smoothstep( rad*0.95, rad, dis )) * f;
}
// vigneting
color *= sqrt(1.5-0.8*length(p));
return color;
}
float turbulence_example( vec2 p ) {
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(1.376, 3.952/2.960), float(i) );
f += abs( snoise( p * scale ) ) / scale;
}
return f;
}
vec3 random(vec2 co, vec2 bias) {
const highp float seed = 12.9898;
highp float a = seed;
highp float b = 78.305, c = 47386.098;
highp float dt= dot(co.xy, vec2(a,b));
highp float sn= mod(dt,3.14159265358979323846);
float n = fract(sin(sn) * c)*2.0-1.0;
//vec3 colour_out = vec3(0.133,0.156,0.359)*n*3.0;
vec3 colour = vec3(0.197,0.242,0.510)*n*3.0; // basic color
return colour - 0.9*length(co+bias);
}
void main() {
float PI = 3.14159265358;
vec2 p = (2.0*gl_FragCoord.xy-u_resolution.xy)/u_resolution.y;
vec2 ra = vec2(0.6,0.3);
float d_body = sdEllipse(p, ra, vec2(0.0, 0.1), 135.0 * PI / 180.0); // draw body1
ra = vec2(0.35, 0.2);
float d_head = sdEllipse(p, ra, vec2(0.45, 0.25), 155.0 * PI / 180.0); // draw head
// right leg
float ra_egg = 0.12;
float d_leg_b = sdEgg(p, ra_egg, ra_egg*(3.9+12.9)*cos(2.0), vec2(0.39, 0.2), -90.0*PI / 180.0) - 0.06;
// left leg
ra = vec2(0.3, 0.13);
float d_leg_a = sdEllipse(p, ra, vec2(0.1, -0.53), -80.0 * PI / 180.0);
// arm
vec2 ar_v1 = vec2(0.2, 0.2);
vec2 ar_v2 = vec2(0.4, -0.1);
float d_arm1 = udSegment(p, ar_v1, ar_v2) - 0.08;
ar_v1 = vec2(0.4, -0.1);
ar_v2 = vec2(0.6, -0.1);
float d_arm2 = udSegment(p, ar_v1, ar_v2) - 0.08;
// feet
ra = vec2(0.21, 0.1);
float d_feet = sdEllipse(p, ra, vec2(0.1, 0.53), 15.0 * PI / 180.0);
// eye
float d_eye_b = sdCircle(p + vec2(-0.48, -0.45), 0.07);
float d_eye_center = sdCircle(p + vec2(-0.51+0.015*abs(sin(1.0*u_time+0.3)), -0.45+0.01*cos(1.0*u_time-0.3)), 0.02);
float d_body_com = sdUnion(d_body, d_head);
d_body_com = sdUnion(d_body_com, d_arm1);
d_body_com = sdUnion(d_body_com, d_arm2);
float d_back = sdUnion(d_body_com, d_leg_a);
d_back = sdUnion(d_back, d_leg_b);
d_back = sdUnion(d_back, d_feet);
d_body_com = sdDifference(d_leg_b, d_body_com);
d_body_com = sdDifference(d_eye_b, d_body_com);
d_leg_a = sdDifference(d_body_com, d_leg_a);
d_leg_b = sdUnion(d_leg_b, d_feet);
d_eye_b = sdDifference(d_eye_center, d_eye_b);
// draw texture
//vec3 col = sign(-d_body_com)*vec3(0.1,0.4,0.7);
vec3 col = ((sign(-d_body_com)+1.0)/2.0)*body_bubble(p, u_resolution, u_time);
//vec3 col_head = sign(-d_head)*vec3(0.5,0.4,0.7);
vec3 col_leg_b = ((sign(-d_leg_b)+1.0)/2.0) * random(p, vec2(-0.2, 0.4));
vec3 col_leg_a = ((sign(-d_leg_a)+1.0)/2.0) * random(p, vec2(0.8, 0.15));
vec3 col_eye_b = ((sign(-d_eye_b)+1.0)/2.0) * vec3(0.1,0.1,0.1);
vec3 col_eye_center = ((sign(-d_eye_center)+1.0)/2.0) * vec3(0.9,0.9,0.9);
/* leg 0.133,0.156,0.359 */
vec4 col_back;
float z_back = getPoint(gl_FragCoord.xy/vec2(8000.0, 8000.0), col_back);
col_back = ((sign(d_back)+1.0)/2.0) * col_back;
//vec3 col_back = ((sign(d_back)+1.0)/2.0)*vec3(0.2,0.2,0.2);
//col *= 1.0 - exp(-2.0*abs(d));
//col *= 0.8 + 0.2*cos(120.0*d);
//col = mix( col, vec3(1.0), 1.0 - smoothstep(0.0,0.01,abs(d)) ); // 白边
colour_out = vec4((col+col_leg_b+col_leg_a+col_eye_b+col_eye_center+col_back.xyz), 1.0);
}
16. Blue Poison Dart Frog by TATyz
// credit: Ziyang Zhang (will show up on website)
// frog: Yellow-band poison dart
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
float cro(vec2 a,vec2 b )
{
return a.x*b.y - a.y*b.x;
}
float sdUnevenCapsule(vec2 p,vec2 pa,vec2 pb,float ra,float rb )
{
p -= pa;
pb -= pa;
float h = dot(pb,pb);
vec2 q = vec2( dot(p,vec2(pb.y,-pb.x)), dot(p,pb) )/h;
//-----------
q.x = abs(q.x);
float b = ra-rb;
vec2 c = vec2(sqrt(h-b*b),b);
float k = cro(c,q);
float m = dot(c,q);
float n = dot(q,q);
if( k < 0.0 ) return sqrt(h*(n )) - ra;
else if( k > c.x ) return sqrt(h*(n+1.0-2.0*q.y)) - rb;
return m - ra;
}
float get_body_mask(vec2 p)
{
vec2 v1 = ( vec2(0.0,-0.40) + 0.0 );
vec2 v2 = ( vec2(0.0,0.10) );
float r1 = 0.45;
float r2 = 0.275;
float d = step( 0.01,sdUnevenCapsule( p, v1, v2, r1, r2 ));
return d;
}
float get_leg_mask_left(vec2 p)
{
vec2 v1 = ( vec2(-0.5,-0.40) + 0.0 );
vec2 v2 = vec2(-0.9,0);
float r1 = 0.22;
float r2 = 0.1;
vec2 p2 = vec2(p.x - 0.2f,p.y + 0.3f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_leg_mask_right(vec2 p)
{
vec2 v1 = ( vec2(0.5,-0.40) + 0.0 );
vec2 v2 = vec2(0.9,0);
float r1 = 0.22;
float r2 = 0.1;
vec2 p2 = vec2(p.x + 0.2f,p.y + 0.3f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_body_right(vec2 p)
{
vec2 v1 = ( vec2(0.1,0.30) + 0.0 );
vec2 v2 = vec2(0.35,0);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x - 0.05f,p.y + 0.2f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_body_left(vec2 p)
{
vec2 v1 = ( vec2(-0.1,0.30) + 0.0 );
vec2 v2 = vec2(-0.35,0);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x + 0.05f,p.y + 0.2f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_right(vec2 p)
{
vec2 v1 = ( vec2(0.1,0.40) + 0.0 );
vec2 v2 = vec2(0.35,0.75);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x - 0.15f,p.y + 0.55f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_arm_left(vec2 p)
{
vec2 v1 = ( vec2(-0.1,0.40) + 0.0 );
vec2 v2 = vec2(-0.35,0.75);
float r1 = 0.1;
float r2 = 0.05;
vec2 p2 = vec2(p.x + 0.15f,p.y + 0.55f);
float d = step( 0.01,sdUnevenCapsule( p2, v1, v2, r1, r2 ));
return d;
}
float get_mask(vec2 st, vec2 p)
{
float mask = 1.0;
mask *= step( 0.055, distance( st.xy, vec2(0.6, 0.65) ) );
mask *= step( 0.055, distance( st.xy, vec2(0.4, 0.65) ) );
mask *= get_body_mask(p);
mask *= get_leg_mask_left(p);
mask *= get_leg_mask_right(p);
mask *= get_arm_body_right(p);
mask *= get_arm_body_left(p);
mask *= get_arm_right(p);
mask *= get_arm_left(p);
return mask;
}
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec3 permute(vec3 x) {
return mod289(((x*34.0)+10.0)*x);
}
float snoise(vec2 v)
{
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy) );
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
+ i.x + vec3(0.0, i1.x, 1.0 ));
vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
m = m*m ;
m = m*m ;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
float marbleturbulence( vec2 p )
{ /* Same as the turbulence before. */
float f = 0.0, scale;
for (int i=0; i<4; i++) {
scale = pow( pow(2.0, 4.0/3.0), float(i) );
f += abs( snoise( p * scale ) ) / scale; }
return f;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
vec2 p = st * 2.0f - 1.0f;
float mask = get_mask(st,p);
vec4 leg_c = vec4( 0.94, 0.78, 0.329, 1.0 ) * 0.95f;
leg_c.a = 1.0f;
colour_out = vec4( 0.94, 0.78, 0.329, 1.0 );
colour_out *= 1.0-mask;
float n = marbleturbulence( st );
float t = step(1.0,1.0 + sin( (st.y * u_resolution.y) / 18.556 + 3.2528 * n ) / 2.0);
colour_out *= vec4( vec3(t), 1.0 );
float dot_mask = snoise(st * 9.75f - u_time * 0.1f);
dot_mask = step(0.3 , dot_mask*0.5 + 0.5);
colour_out *= dot_mask;
dot_mask = 1.0f - snoise(st * 1.75f * (5.0f+cos(u_time)));
dot_mask = step(0.5,dot_mask);
float cmask_l = get_leg_mask_left(p);
colour_out *= cmask_l;
colour_out += (1.0f - cmask_l) * leg_c * dot_mask;
float cmask_r = get_leg_mask_right(p);
colour_out *= cmask_r;
colour_out += (1.0f - cmask_r) * leg_c* dot_mask;
colour_out *= step( 0.035, distance( st.xy, vec2(0.6, 0.675) ) );
colour_out *= step( 0.035, distance( st.xy, vec2(0.4, 0.675) ) );
colour_out += 1.0 - step( 0.0085, distance( st.xy, vec2(0.61, 0.6795) ) );
colour_out += 1.0 - step( 0.0085, distance( st.xy, vec2(0.41, 0.6795) ) );
colour_out.a = 1.0f;
//colour_out = vec4(dot_mask,dot_mask,dot_mask,1);
colour_out += step(1.0,mask) * vec4(1,1,1,1);
}
18. Yellow-band poison dart frog by
Ziyang Zhang
//by nagisa
uniform vec2 u_resolution;
uniform float u_time;
vec2 mod289(vec2 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 mod289(vec4 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec4 permute(vec4 x) {
return mod289((34.0 * x + 10.0) * x);
}
vec3 mod289(vec3 x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
// Permutation polynomial: (34x^2 + 6x) mod 289
vec3 permute(vec3 x) {
return mod289((34.0 * x + 10.0) * x);
}
float snoise(vec2 v) {
const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0
0.366025403784439, // 0.5*(sqrt(3.0)-1.0)
-0.577350269189626, // -1.0 + 2.0 * C.x
0.024390243902439); // 1.0 / 41.0
// First corner
vec2 i = floor(v + dot(v, C.yy));
vec2 x0 = v - i + dot(i, C.xx);
// Other corners
vec2 i1;
//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
vec4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
m = m * m;
m = m * m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
vec3 x = 2.0 * fract(p * C.www) - 1.0;
vec3 h = abs(x) - 0.5;
vec3 ox = floor(x + 0.5);
vec3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt( a0*a0 + h*h );
m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
// Compute final noise value at P
vec3 g;
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * x12.xz + h.yz * x12.yw;
return 130.0 * dot(m, g);
}
vec4 taylorInvSqrt(vec4 r) {
return 1.79284291400159 - 0.85373472095314 * r;
}
vec2 fade(vec2 t) {
return t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
}
// Classic Perlin noise
float cnoise(vec2 P) {
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0;
vec4 gy = abs(gx) - 0.5;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x, gy.x);
vec2 g10 = vec2(gx.y, gy.y);
vec2 g01 = vec2(gx.z, gy.z);
vec2 g11 = vec2(gx.w, gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
float random(in vec2 st) {
return fract(sin(dot(st.xy, vec2(12.9898, 78.233))) * 43758.5453123);
}
// Value noise by Inigo Quilez - iq/2013
// https://www.shadertoy.com/view/lsf3WH
float noise(vec2 st) {
vec2 i = floor(st);
vec2 f = fract(st);
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(mix(random(i + vec2(0.0, 0.0)), random(i + vec2(1.0, 0.0)), u.x), mix(random(i + vec2(0.0, 1.0)), random(i + vec2(1.0, 1.0)), u.x), u.y);
}
mat2 rotate2d(float angle) {
return mat2(cos(angle), -sin(angle), sin(angle), cos(angle));
}
float lines(in vec2 pos, float b) {
float scale = 1.2;
pos *= scale;
return smoothstep(0.1, .5 + b * .5, abs((sin(pos.x * 3.1415) + b * 2.0)) * .5);
}
float dot2(in vec3 v) {
return dot(v, v);
}
float opUnion(float d1, float d2) {
return min(d1, d2);
}
float opSmoothUnion(float d1, float d2, float k) {
float h = clamp(0.5 + 0.5 * (d2 - d1) / k, 0.0, 1.0);
return mix(d2, d1, h) - k * h * (1.0 - h);
}
float sdSphere(vec3 p, float s) {
return length(p) - s;
}
float sdCapsule(vec3 p, vec3 a, vec3 b, float r) {
vec3 pa = p - a, ba = b - a;
float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
return length(pa - ba * h) - r;
}
float sdRoundCone(vec3 p, vec3 a, vec3 b, float r1, float r2) {
// sampling independent computations (only depend on shape)
vec3 ba = b - a;
float l2 = dot(ba, ba);
float rr = r1 - r2;
float a2 = l2 - rr * rr;
float il2 = 1.0 / l2;
// sampling dependant computations
vec3 pa = p - a;
float y = dot(pa, ba);
float z = y - l2;
float x2 = dot2(pa * l2 - ba * y);
float y2 = y * y * l2;
float z2 = z * z * l2;
// single square root!
float k = sign(rr) * rr * rr * x2;
if(sign(z) * a2 * z2 > k)
return sqrt(x2 + z2) * il2 - r2;
if(sign(y) * a2 * y2 < k)
return sqrt(x2 + y2) * il2 - r1;
return (sqrt(x2 * a2 * il2) + y * rr) * il2 - r1;
}
float sdCappedCylinder(vec3 p, vec3 a, vec3 b, float r) {
vec3 ba = b - a;
vec3 pa = p - a;
float baba = dot(ba, ba);
float paba = dot(pa, ba);
float x = length(pa * baba - ba * paba) - r * baba;
float y = abs(paba - baba * 0.5) - baba * 0.5;
float x2 = x * x;
float y2 = y * y * baba;
float d = (max(x, y) < 0.0) ? -min(x2, y2) : (((x > 0.0) ? x2 : 0.0) + ((y > 0.0) ? y2 : 0.0));
return sign(d) * sqrt(abs(d)) / baba;
}
float sdEllipsoid(vec3 p, vec3 r) {
float k0 = length(p / r);
float k1 = length(p / (r * r));
return k0 * (k0 - 1.0) / k1;
}
vec2 opU(vec2 d1, vec2 d2) {
return (d1.x < d2.x) ? d1 : d2;
}
vec2 map(vec3 pos) {
vec2 res = vec2(2.0, 0.0);
float tree = sdCappedCylinder(pos, vec3(-5.0, 3.0, -3.75), vec3(3.9, -5.0, 2.4), 1.2);
res = opU(res, vec2(tree, 1.0));
float body = sdRoundCone(pos, vec3(0, 0.15, 0.5), vec3(-0.67, 0.04, 0.12), 0.23, 0.28);
float eyes = opUnion(sdSphere(pos - vec3(.10, 0.32, 0.40), 0.14), sdSphere(pos - vec3(-.05, 0.17, 0.63), 0.14));
float eyeball = sdEllipsoid(pos - vec3(-.06, 0.18, 0.70), vec3(0.1, 0.08, 0.11));
float p = 130.0 * 3.1415 / 180.0;
mat3 rotx = mat3(1.0, 0.0, 0.0, 0, cos(p), sin(p), 0, -sin(p), cos(p));
p = -10.0 * 3.1415 / 180.0;
mat3 rotz = mat3(cos(p), sin(p), 0, -sin(p), cos(p), 0, 0, 0, 1);
p = 20.0 * 3.1415 / 180.0;
mat3 roty = mat3(cos(p), 0, -sin(p), 0, 1, 0, sin(p), 0, cos(p));
float mouth = sdEllipsoid(rotx * roty * rotz * (pos - vec3(0.0, 0.15, 0.61)), vec3(0.3, 0.13, 0.18));
p = 80.0 * 3.1415 / 180.0;
rotx = mat3(1.0, 0.0, 0.0, 0, cos(p), sin(p), 0, -sin(p), cos(p));
p = 10.0 * 3.1415 / 180.0;
rotz = mat3(cos(p), sin(p), 0, -sin(p), cos(p), 0, 0, 0, 1);
p = 50.0 * 3.1415 / 180.0;
roty = mat3(cos(p), 0, -sin(p), 0, 1, 0, sin(p), 0, cos(p));
float naka = sdEllipsoid(rotx * roty * rotz * (pos - vec3(-0.46, 0.11, 0.3)), vec3(0.2, 0.22, 0.25));
body = opSmoothUnion(body, naka, 0.14);
body = opSmoothUnion(opSmoothUnion(body, eyes, 0.0001), mouth, 0.05);
float frog = opSmoothUnion(body, eyes, 0.0001);
float legL1 = sdCapsule(pos, vec3(-0.83, -0.1, 0.2), vec3(-.81, -.3, 0.5), 0.07);
float legL2 = sdCapsule(pos, vec3(-.83, -0.31, 0.5), vec3(-1.05, -0.13, 0.27), 0.06);
float legL3 = sdCapsule(pos, vec3(-1.05, -0.1, 0.32), vec3(-.96, -0.43, 0.37), 0.04);
float legR1 = sdCapsule(pos, vec3(-0.2, -0.1, 0.5), vec3(-.26, -0.3, 0.7), 0.04);
float legR2 = sdCapsule(pos, vec3(-.26, -0.33, 0.7), vec3(-.21, -0.6, 0.6), 0.04);
float legL = opSmoothUnion(legL1, opSmoothUnion(legL2, legL3, 0.02), 0.02);
float legR = opSmoothUnion(legR1, legR2, 0.02);
float fingerL1 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.79, -.52, 0.4), 0.02);
float fingerL2 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.76, -.56, 0.6), 0.02);
float fingerL3 = sdCapsule(pos, vec3(-.98, -0.43, 0.36), vec3(-.91, -.55, 0.55), 0.02);
float fingerR1 = sdCapsule(pos, vec3(-.21, -0.63, 0.57), vec3(-.10, -.57, 0.6), 0.02);
float fingerR2 = sdCapsule(pos, vec3(-.21, -0.6, 0.6), vec3(-.01, -.67, 0.6), 0.02);
float fingerR3 = sdCapsule(pos, vec3(-.21, -0.63, 0.6), vec3(-.12, -.72, 0.67), 0.02);
float fingerL = opUnion(fingerL1, opUnion(fingerL2, fingerL3));
float fingerR = opUnion(fingerR1, opUnion(fingerR2, fingerR3));
legL = opSmoothUnion(legL, fingerL, 0.05);
legR = opSmoothUnion(legR, fingerR, 0.05);
float legs = opUnion(legL, legR);
frog = opSmoothUnion(frog, legs, 0.05);
res = opU(res, vec2(frog, 2.0));
res = opU(res, vec2(eyeball, 3.0));
return res;
}
vec3 calcNormal(in vec3 pos) {
vec2 e = vec2(1.0, -1.0) * 0.5773;
const float eps = 0.0005;
return normalize(e.xyy * map(pos + e.xyy * eps).x +
e.yyx * map(pos + e.yyx * eps).x +
e.yxy * map(pos + e.yxy * eps).x +
e.xxx * map(pos + e.xxx * eps).x);
}
const float NEAR_CLIPPING_PLANE = 0.01;
const float FAR_CLIPPING_PLANE = 5.0;
const int MARCHING_STEPS = 100;
const float EPSILON = 0.0001;
const float DISTANCE_BIAS = 1.0;
const vec3 LIGHT_COL = vec3(1.6);
/* We are approximating soft shadows for "free" with raymarching. */
float softshadow(vec3 ro, vec3 rd, float k) {
float res = 1.0;
float ph = 1e20;
float t = NEAR_CLIPPING_PLANE;
for(int i = 0; i < MARCHING_STEPS; i++) {
float h = map(ro + t * rd).x;
if(h < EPSILON)
return 0.0;
float y = h * h / (2.0 * ph);
float d = sqrt(h * h - y * y);
res = min(res, k * d / max(0.0, t - y));
ph = h;
t += h * DISTANCE_BIAS;
if(t > FAR_CLIPPING_PLANE)
break;
}
return res;
}
float fbm_example(vec2 p) {
float f = 0.0, scale;
for(int i = 0; i < 6; i++) {
scale = pow(pow(2.0, 4.0 / 3.0), float(i));
f += snoise(p * scale) / scale;
}
return f;
}
vec2 raymarch(vec3 ro, vec3 rd) {
const float tmax = 5.0;
vec2 t = vec2(-1, 0.0);
for(int i = 0; i < 256; i++) {
vec3 pos = ro + t.x * rd;
vec2 h = map(pos);
if(h.x < 0.0001 || t.x > tmax) {
break;
}
t.x += h.x;
t.y = h.y;
}
return t;
}
void main() {
// camera movement
float an = 1.87 - 0.01 * (1.0 - cos(2.5 * u_time));
vec3 ro = vec3(0.0, 0.0, 1.6) + 1.5 * vec3(cos(an), 0, sin(an));
vec3 ta = vec3(0.11, -0.36, 0.0);
// camera matrix
vec3 ww = normalize(ta - ro);
vec3 uu = normalize(cross(ww, vec3(0.0, 1.0, 0.0)));
vec3 vv = normalize(cross(uu, ww));
vec2 p = (2.0 * gl_FragCoord.xy - u_resolution.xy) / u_resolution.y;
// create view ray
vec3 rd = normalize(p.x * uu + p.y * vv + 1.8 * ww);
vec3 tot = vec3(0, 0, 0.0);
vec2 t = raymarch(ro, rd);
vec3 LIGHT_POS = 3.0 * vec3(.6, 1.0, 2.8);
const float tmax = 5.0;
//shading/lighting
vec3 col = vec3(0.0);
if(t.x < tmax) {
vec3 pos = ro + t.x * rd;
vec3 nor = calcNormal(pos);
float dif = clamp(dot(nor, vec3(0.57703)), 0.0, 1.0);
float amb = 0.5 + 0.5 * dot(nor, vec3(0.0, 1.0, 0.0));
vec3 mat = vec3(0.1, 0.6, 0.7);
if(t.y == 1.0) {
vec2 st = pos.xy;
float p = 10.3;
mat2 rot2d = mat2(cos(p), sin(p), -sin(p), cos(p));
vec2 pos = st.xy * rot2d * vec2(7., 4.);
st.y *= u_resolution.y / u_resolution.x;
float pattern = pos.x;
vec2 pos1 = rotate2d(noise(pos) * .45) * pos;
pattern = lines(pos1, 0.3);
mat = vec3(0.33, pattern * 0.55 + 0.09, 0.21) * 0.1 + vec3(0.0, fbm_example(pos.xy * 2.24) * 0.04 + 0.03, 0.0);
}
if(t.y == 2.0) {
if(pos.x > -0.3 && pos.y < -0.23) {
if(pos.y > -0.3) {
mat = mix(vec3(0.99, 0.01, 0.01), vec3(0.001, 0.05, 0.6 * (snoise(pos.xy * 62.00) * 1.4 + 0.9)), snoise(pos.yy) * 1.95 + 0.91);
} else {
mat = vec3(0.001, 0.05, 0.6 * (snoise(pos.yx * 62.00) * 1.4 + 0.9));
}
} else if(0.7 * pos.x + pos.y < -.69) {
mat = mix(vec3(0.001, 0.05, 0.6 * (snoise(pos.xy * 62.00) * 1.4 + 0.9)), vec3(0.99, 0.01, 0.01), 1.5 * pos.x + pos.y + 1.46 + 0.12);
} else {
mat = mix(vec3(0.99, 0.01, 0.01), vec3((snoise((pos.zy + vec2(2.61, 5.4)) * 16.0) * 1.5 + 0.7), 0.01, 0.01), pos.x - pos.y * 0.4 - 0.3);
}
}
if(t.y == 3.0) {
mat = vec3(0.01);
}
col = vec3(0.2, 0.2, 0.2) * amb * 0.1 +
vec3(0.35, 0.55, 0.65) * dif * 0.1 + mat;
vec3 light_dir = normalize(LIGHT_POS - pos);
/* Shadows computed with raymarching. */
float sha = softshadow(pos + nor * 0.001, light_dir, 8.0);
/* Lighting is simple based on a point light. */
float sun = max(dot(nor, light_dir), 0.0);
vec3 lin = sun * LIGHT_COL * pow(vec3(sha), vec3(1.5));
col = col * lin;
// col=col*mat;
} else {
col = vec3(0.15, 0.12 * cnoise(p.xy * 1.2) + 0.21, 0.15);
}
// gamma
col = sqrt(col);
tot += col;
colour_out = vec4(tot, 1.0);
}
20. unknown by nagisa
// credit: NemoSencho (will show up on website)
// frog: Bumblebee Dart Frog
uniform vec2 u_resolution;
uniform vec2 u_mouse;
uniform float u_time;
//
// GLSL textureless classic 2D noise "cnoise",
// with an RSL-style periodic variant "pnoise".
// Author: Stefan Gustavson (stefan.gustavson@liu.se)
// Version: 2011-08-22
//
// Many thanks to Ian McEwan of Ashima Arts for the
// ideas for permutation and gradient selection.
//
// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
// Distributed under the MIT license. See LICENSE file.
// https://github.com/stegu/webgl-noise
//
vec4 mod289(vec4 x)
{
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
vec4 permute(vec4 x)
{
return mod289(((x*34.0)+10.0)*x);
}
vec4 taylorInvSqrt(vec4 r)
{
return 1.79284291400159 - 0.85373472095314 * r;
}
vec2 fade(vec2 t) {
return t*t*t*(t*(t*6.0-15.0)+10.0);
}
// Classic Perlin noise
float cnoise(vec2 P)
{
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
vec4 gy = abs(gx) - 0.5 ;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x,gy.x);
vec2 g10 = vec2(gx.y,gy.y);
vec2 g01 = vec2(gx.z,gy.z);
vec2 g11 = vec2(gx.w,gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
// Classic Perlin noise, periodic variant
float pnoise(vec2 P, vec2 rep)
{
vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0);
vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0);
Pi = mod(Pi, rep.xyxy); // To create noise with explicit period
Pi = mod289(Pi); // To avoid truncation effects in permutation
vec4 ix = Pi.xzxz;
vec4 iy = Pi.yyww;
vec4 fx = Pf.xzxz;
vec4 fy = Pf.yyww;
vec4 i = permute(permute(ix) + iy);
vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ;
vec4 gy = abs(gx) - 0.5 ;
vec4 tx = floor(gx + 0.5);
gx = gx - tx;
vec2 g00 = vec2(gx.x,gy.x);
vec2 g10 = vec2(gx.y,gy.y);
vec2 g01 = vec2(gx.z,gy.z);
vec2 g11 = vec2(gx.w,gy.w);
vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, vec2(fx.x, fy.x));
float n10 = dot(g10, vec2(fx.y, fy.y));
float n01 = dot(g01, vec2(fx.z, fy.z));
float n11 = dot(g11, vec2(fx.w, fy.w));
vec2 fade_xy = fade(Pf.xy);
vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x);
float n_xy = mix(n_x.x, n_x.y, fade_xy.y);
return 2.3 * n_xy;
}
void main() {
vec2 st = gl_FragCoord.xy/u_resolution.xy;
float mask = 1.0;
float PI = 3.141592;
vec2 LL_coord = st*4.0 + u_time;
float pn1 = cnoise(LL_coord);
float pn2 = cnoise(LL_coord);
float pn = (pn1 + pn2) / 2.0;
pn *= pow((1.0 + sin((LL_coord.x+LL_coord.y)*PI)) / 2.0, 2.0);
if (sqrt(pn) > 0.07 && sqrt(pn) < 0.55) {
mask = 0.0;
} else {
mask = 1.0;
}
colour_out = vec4( 1.0, 0.95, 0.1, 1.0 );
colour_out *= 1.0-mask;
}
22. Bumblebee Dart Frog by NemoSencho