Skip to content

Instantly share code, notes, and snippets.

@solsarratea

solsarratea/cheatsheet.frag

Last active September 7, 2020 16:25
Show Gist options
  • Save solsarratea/21e130223b0f0806ffe87d88f2974b95 to your computer and use it in GitHub Desktop.
Save solsarratea/21e130223b0f0806ffe87d88f2974b95 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
cheatsheet.frag
//Repeticiones en el espacio
// Funciones sacadas http://mercury.sexy/hg_sdf/
// Rota alrededor de un eje
void pR(inout vec2 p, float a) {
p = cos(a)*p + sin(a)*vec2(p.y, -p.x);
}
// Repite en 3D
vec3 pMod3(inout vec3 p, vec3 size) {
vec3 c = floor((p + size*0.5)/size);
p = mod(p + size*0.5, size) - size*0.5;
return c;
}
vec3 op_repeat(vec3 p, vec3 c) {
return mod(p, c) - 0.5 * c;
}
// Repite en 2D
vec2 pMod2(inout vec2 p, vec2 size) {
vec2 c = floor((p + size*0.5)/size);
p = mod(p + size*0.5,size) - size*0.5;
return c;
}
// Repite y espeja
vec2 pModMirror2(inout vec2 p, vec2 size) {
vec2 halfsize = size*0.5;
vec2 c = floor((p + halfsize)/size);
p = mod(p + halfsize, size) - halfsize;
p *= mod(c,vec2(2))*2. - vec2(1);
return c;
}
float pModPolar(inout vec2 p, float repetitions) {
float angle = 2.*PI/repetitions;
float a = atan(p.y, p.x) + angle/2.;
float r = length(p);
float c = floor(a/angle);
a = mod(a,angle) - angle/2.;
p = vec2(cos(a), sin(a))*r;
if (abs(c) >= (repetitions/2.)) c = abs(c);
return c;
}
//////////////////////////////////////////////////////////
// Beats por minuto ( metronomo )
float getBPMVis(float bpm, float q, float intensity){
// para visualizar bpm https://www.desmos.com/calculator/6lvbxrudxu
float bps = 60./bpm; // beats por segundo
float bpmVis = tan((time*PI/(2. * q))/bps);
bpmVis = min(abs(bpmVis),1.) * intensity;
return bpmVis;
}
//////////////////////////////////////////////////////////
// SDF - 3D
https://www.iquilezles.org/www/articles/distfunctions/distfunctions.htm
float sdTorus( vec3 p, vec2 t )
{
vec2 q = vec2(length(p.xz)-t.x,p.y);
return length(q)-t.y;
}
float sdBox( vec3 p, vec3 b )
{
vec3 q = abs(p) - b;
return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0);
}
float sdSphere( vec3 p, float s )
{
return length(p)-s;
}
float sdOctahedron( vec3 p, float s)
{
p = abs(p);
return (p.x+p.y+p.z-s)*0.57735027;
}
//////////////////////////////////////////////////////////
// Multiplicacion complejos - Clase 3
vec2 multC(vec2 a, vec2 b){
float re = a.x*b.x - a.y*b.y;
float im = a.x*b.y + a.y*b.x;
return vec2(re,im);
}
//////////////////////////////////////////////////////////
// Simetrias - Clase 2
float reflection(inout vec2 pos, float angle){
vec2 normal = vec2(cos(angle),sin(angle));
float d = dot(pos, normal);
pos -= normal*min(0.,d)*2.;
return smoothstep(0.1,0.,abs(d));
}
//////////////////////////////////////////////////////////
// Paleta de Colores - Clase 1
vec3 rgb2hsb( in vec3 c ){
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = mix(vec4(c.bg, K.wz),
vec4(c.gb, K.xy),
step(c.b, c.g));
vec4 q = mix(vec4(p.xyw, c.r),
vec4(c.r, p.yzx),
step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)),
d / (q.x + e),
q.x);
}
// Funcion de Iñigo Quiles
// https://www.shadertoy.com/view/MsS3Wc
vec3 hsb2rgb( in vec3 c ){
vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),
6.0)-3.0)-1.0,
0.0,
1.0 );
rgb = rgb*rgb*(3.0-2.0*rgb);
return c.z * mix(vec3(1.0), rgb, c.y);
}
//http://erkaman.github.io/glsl-cos-palette/
//https://www.iquilezles.org/www/articles/palettes/palettes.htm
vec3 cosPalette( float t, vec3 a, vec3 b, vec3 c, vec3 d ){
return a + b*cos( 6.28318*(c*t+d) );
}
//Mapeo a arcoiris
vec3 spectralGems (float x) {
vec3 rgb = vec3(4. * (x - 0.7), // Red
4. * (x - 0.5), // Green
4. * (x - 0.23) // Blue
);
vec3 bump3 = vec3(1.,1.,1.) - rgb *rgb;
return max(bump3,vec3(0.));
}
//////////////////////////////////////////////////////////
// Funciones SDF 2D - Clase 0
//https://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm
float sdCircle( vec2 p, float r )
{
return length(p) - r;
}
float sdBox( in vec2 p, in vec2 b )
{
vec2 d = abs(p)-b;
return length(max(d,vec2(0))) + min(max(d.x,d.y),0.0);
}
float sdEquilateralTriangle( in 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 sdPentagon( in vec2 p, in float r )
{
const vec3 k = vec3(0.809016994,0.587785252,0.726542528);
p.x = abs(p.x);
p -= 2.0*min(dot(vec2(-k.x,k.y),p),0.0)*vec2(-k.x,k.y);
p -= 2.0*min(dot(vec2( k.x,k.y),p),0.0)*vec2( k.x,k.y);
return length(p-vec2(clamp(p.x,-r*k.z,r*k.z),r))*sign(p.y-r);
}
float sdCross( in vec2 p, in vec2 b, float r )
{
p = abs(p); p = (p.y>p.x) ? p.yx : p.xy;
vec2 q = p - b;
float k = max(q.y,q.x);
vec2 w = (k>0.0) ? q : vec2(b.y-p.x,-k);
return sign(k)*length(max(w,0.0)) + r;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment