Transforms into shader library

Renames the project to reflect its new purpose as a shader library.

Adds an SDF library with functions from iq's website.

Updates the build settings and README files accordingly.

Author: raganmd

README.md

@@ -1,10 +1,15 @@
-# name-of-tox here
+# Shader Lib
 
 ## Summary
-Summary of tox behvior here
+A collection of shader libraries assembled for easy access in TouchDesigner.
+
 
 ## TDM Installation
 If you are using the [TouchDesigner Dependency Manager](https://github.com/SudoMagicCode/TouchDesigner-Dependency-Manager) you can add this component to your local project with a `add package` command.
 ```shell
-tdm add package {{repo_url_without_https://}}
+tdm add package github.com/SudoMagicCode/sudo_td_shader_lib
 ``` 
+
+## Credits
+SDF Lib - Inigo Quilez
+from https://iquilezles.org/articles/distfunctions/

TouchDesigner/README.md

@@ -1 +1 @@
-# td-tox-builder-template
+# tdShaderLib

TouchDesigner/project.toe

@@ -0,0 +1,350 @@
+// authoring credit to inigo Quilez
+// from https://iquilezles.org/articles/distfunctions/
+
+
+// Sphere - exact   (https://www.shadertoy.com/view/Xds3zN)
+float sdSphere( vec3 p, float s )
+{
+  return length(p)-s;
+}
+
+
+// Box - exact   (Youtube Tutorial with derivation: https://www.youtube.com/watch?v=62-pRVZuS5c)
+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);
+}
+
+
+// Round Box - exact
+float sdRoundBox( vec3 p, vec3 b, float r )
+{
+  vec3 q = abs(p) - b;
+  return length(max(q,0.0)) + min(max(q.x,max(q.y,q.z)),0.0) - r;
+}
+
+
+// Box Frame - exact   (https://www.shadertoy.com/view/3ljcRh)
+float sdBoxFrame( vec3 p, vec3 b, float e )
+{
+  p = abs(p  )-b;
+  
+  vec3 q = abs(p+e)-e;
+  
+  return min(min(
+      length(max(vec3(p.x,q.y,q.z),0.0))+min(max(p.x,max(q.y,q.z)),0.0),
+      length(max(vec3(q.x,p.y,q.z),0.0))+min(max(q.x,max(p.y,q.z)),0.0)),
+      length(max(vec3(q.x,q.y,p.z),0.0))+min(max(q.x,max(q.y,p.z)),0.0));
+}
+
+
+// Torus - exact
+float sdTorus( vec3 p, vec2 t )
+{
+  vec2 q = vec2(length(p.xz)-t.x,p.y);
+  return length(q)-t.y;
+}
+
+
+// Capped Torus - exact   (https://www.shadertoy.com/view/tl23RK)
+float sdCappedTorus( vec3 p, vec2 sc, float ra, 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;
+}
+
+
+// Link - exact   (https://www.shadertoy.com/view/wlXSD7)
+float sdLink( vec3 p, float le, float r1, float r2 )
+{
+  vec3 q = vec3( p.x, max(abs(p.y)-le,0.0), p.z );
+  return length(vec2(length(q.xy)-r1,q.z)) - r2;
+}
+
+
+// Infinite Cylinder - exact
+float sdCylinderExact( vec3 p, vec3 c )
+{
+  return length(p.xz-c.xy)-c.z;
+}
+
+
+// Cone - exact
+float sdConeExact( vec3 p, vec2 c, float h )
+{
+  // c is the sin/cos of the angle, h is height
+  // Alternatively pass q instead of (c,h),
+  // which is the point at the base in 2D
+  vec2 q = h*vec2(c.x/c.y,-1.0);
+    
+  vec2 w = vec2( length(p.xz), p.y );
+  vec2 a = w - q*clamp( dot(w,q)/dot(q,q), 0.0, 1.0 );
+  vec2 b = w - q*vec2( clamp( w.x/q.x, 0.0, 1.0 ), 1.0 );
+  float k = sign( q.y );
+  float d = min(dot( a, a ),dot(b, b));
+  float s = max( k*(w.x*q.y-w.y*q.x),k*(w.y-q.y)  );
+  return sqrt(d)*sign(s);
+}
+
+
+// Cone - bound (not exact!)
+float sdConeBound( vec3 p, vec2 c, float h )
+{
+  float q = length(p.xz);
+  return max(dot(c.xy,vec2(q,p.y)),-h-p.y);
+}
+
+
+// Infinite Cone - exact
+float sdConeInfiniteExact( vec3 p, vec2 c )
+{
+    // c is the sin/cos of the angle
+    vec2 q = vec2( length(p.xz), -p.y );
+    float d = length(q-c*max(dot(q,c), 0.0));
+    return d * ((q.x*c.y-q.y*c.x<0.0)?-1.0:1.0);
+}
+
+
+// Plane - exact
+float sdPlane( vec3 p, vec3 n, float h )
+{
+  // n must be normalized
+  return dot(p,n) + h;
+}
+
+
+// Hexagonal Prism - exact
+float sdHexPrism( vec3 p, vec2 h )
+{
+  const vec3 k = vec3(-0.8660254, 0.5, 0.57735);
+  p = abs(p);
+  p.xy -= 2.0*min(dot(k.xy, p.xy), 0.0)*k.xy;
+  vec2 d = vec2(
+      length(p.xy-vec2(clamp(p.x,-k.z*h.x,k.z*h.x), h.x))*sign(p.y-h.x),
+      p.z-h.y );
+  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
+}
+
+
+// Triangular Prism - bound
+float sdTriPrism( vec3 p, vec2 h )
+{
+  vec3 q = abs(p);
+  return max(q.z-h.y,max(q.x*0.866025+p.y*0.5,-p.y)-h.x*0.5);
+}
+
+
+// Capsule / Line - exact
+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;
+}
+
+
+// Capsule / Line - exact
+float sdVerticalCapsule( vec3 p, float h, float r )
+{
+  p.y -= clamp( p.y, 0.0, h );
+  return length( p ) - r;
+}
+
+
+// Vertical Capped Cylinder - exact   (https://www.shadertoy.com/view/wdXGDr)
+float sdCappedCylinder( vec3 p, float h, float r )
+{
+  vec2 d = abs(vec2(length(p.xz),p.y)) - vec2(r,h);
+  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
+}
+
+
+// Arbitrary Capped Cylinder - exact   (https://www.shadertoy.com/view/wdXGDr)
+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;
+}
+
+
+// Rounded Cylinder - exact
+float sdRoundedCylinder( vec3 p, float ra, float rb, float h )
+{
+  vec2 d = vec2( length(p.xz)-2.0*ra+rb, abs(p.y) - h );
+  return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rb;
+}
+
+
+// Capped Cone - exact   (https://www.shadertoy.com/view/tsSXzK)
+float sdCappedCone( vec3 p, vec3 a, vec3 b, float ra, float rb )
+{
+  float rba  = rb-ra;
+  float baba = dot(b-a,b-a);
+  float papa = dot(p-a,p-a);
+  float paba = dot(p-a,b-a)/baba;
+  float x = sqrt( papa - paba*paba*baba );
+  float cax = max(0.0,x-((paba<0.5)?ra:rb));
+  float cay = abs(paba-0.5)-0.5;
+  float k = rba*rba + baba;
+  float f = clamp( (rba*(x-ra)+paba*baba)/k, 0.0, 1.0 );
+  float cbx = x-ra - f*rba;
+  float cby = paba - f;
+  float s = (cbx<0.0 && cay<0.0) ? -1.0 : 1.0;
+  return s*sqrt( min(cax*cax + cay*cay*baba,
+                    cbx*cbx + cby*cby*baba) );
+}
+
+
+// Solid Angle - exact   (https://www.shadertoy.com/view/wtjSDW)
+float sdSolidAngle( vec3 p, vec2 c, float ra )
+{
+  // c is the sin/cos of the angle
+  vec2 q = vec2( length(p.xz), p.y );
+  float l = length(q) - ra;
+  float m = length(q - c*clamp(dot(q,c),0.0,ra) );
+  return max(l,m*sign(c.y*q.x-c.x*q.y));
+}
+
+
+// Cut Sphere - exact   (https://www.shadertoy.com/view/stKSzc)
+float sdCutSphere( vec3 p, float r, float h )
+{
+  // sampling independent computations (only depend on shape)
+  float w = sqrt(r*r-h*h);
+
+  // sampling dependant computations
+  vec2 q = vec2( length(p.xz), p.y );
+  float s = max( (h-r)*q.x*q.x+w*w*(h+r-2.0*q.y), h*q.x-w*q.y );
+  return (s<0.0) ? length(q)-r :
+        (q.x<w) ? h - q.y     :
+        length(q-vec2(w,h));
+}
+
+
+// Cut Hollow Sphere - exact   (https://www.shadertoy.com/view/7tVXRt)
+float sdCutHollowSphere( vec3 p, float r, float h, float t )
+{
+  // sampling independent computations (only depend on shape)
+  float w = sqrt(r*r-h*h);
+  
+  // sampling dependant computations
+  vec2 q = vec2( length(p.xz), p.y );
+  return ((h*q.x<w*q.y) ? length(q-vec2(w,h)) : 
+                          abs(length(q)-r) ) - t;
+}
+
+
+// Death Star - exact   (https://www.shadertoy.com/view/7lVXRt)
+float sdDeathStar( vec3 p2, float ra, float rb, float d )
+{
+  // sampling independent computations (only depend on shape)
+  float a = (ra*ra - rb*rb + d*d)/(2.0*d);
+  float b = sqrt(max(ra*ra-a*a,0.0));
+	
+  // sampling dependant computations
+  vec2 p = vec2( p2.x, length(p2.yz) );
+  if( p.x*b-p.y*a > d*max(b-p.y,0.0) )
+    return length(p-vec2(a,b));
+  else
+    return max( (length(p            )-ra),
+              -(length(p-vec2(d,0.0))-rb));
+}
+
+
+// Round cone - exact
+float sdRoundCone( vec3 p, float r1, float r2, float h )
+{
+  // sampling independent computations (only depend on shape)
+  float b = (r1-r2)/h;
+  float a = sqrt(1.0-b*b);
+
+  // sampling dependant computations
+  vec2 q = vec2( length(p.xz), p.y );
+  float k = dot(q,vec2(-b,a));
+  if( k<0.0 ) return length(q) - r1;
+  if( k>a*h ) return length(q-vec2(0.0,h)) - r2;
+  return dot(q, vec2(a,b) ) - r1;
+}
+
+
+// Ellipsoid - bound (not exact!)   (https://www.shadertoy.com/view/tdS3DG)
+float sdEllipsoid( vec3 p, vec3 r )
+{
+  float k0 = length(p/r);
+  float k1 = length(p/(r*r));
+  return k0*(k0-1.0)/k1;
+}
+
+
+// Revolved Vesica - exact)   (https://www.shadertoy.com/view/Ds2czG)
+float sdVesicaSegment( in vec3 p, in vec3 a, in vec3 b, in float w )
+{
+    vec3  c = (a+b)*0.5;
+    float l = length(b-a);
+    vec3  v = (b-a)/l;
+    float y = dot(p-c,v);
+    vec2  q = vec2(length(p-c-y*v),abs(y));
+    
+    float r = 0.5*l;
+    float d = 0.5*(r*r-w*w)/w;
+    vec3  h = (r*q.x<d*(q.y-r)) ? vec3(0.0,r,0.0) : vec3(-d,0.0,d+w);
+ 
+    return length(q-h.xy) - h.z;
+}
+
+// Octahedron - exact   (https://www.shadertoy.com/view/wsSGDG)
+float sdOctahedronExact( vec3 p, float s )
+{
+  p = abs(p);
+  float m = p.x+p.y+p.z-s;
+  vec3 q;
+       if( 3.0*p.x < m ) q = p.xyz;
+  else if( 3.0*p.y < m ) q = p.yzx;
+  else if( 3.0*p.z < m ) q = p.zxy;
+  else return m*0.57735027;
+    
+  float k = clamp(0.5*(q.z-q.y+s),0.0,s); 
+  return length(vec3(q.x,q.y-s+k,q.z-k)); 
+}
+
+
+// Octahedron - bound (not exact)
+float sdOctahedron( vec3 p, float s)
+{
+  p = abs(p);
+  return (p.x+p.y+p.z-s)*0.57735027;
+}
+
+
+// Pyramid - exact   (https://www.shadertoy.com/view/Ws3SDl)
+float sdPyramid( vec3 p, float h )
+{
+  float m2 = h*h + 0.25;
+    
+  p.xz = abs(p.xz);
+  p.xz = (p.z>p.x) ? p.zx : p.xz;
+  p.xz -= 0.5;
+
+  vec3 q = vec3( p.z, h*p.y - 0.5*p.x, h*p.x + 0.5*p.y);
+   
+  float s = max(-q.x,0.0);
+  float t = clamp( (q.y-0.5*p.z)/(m2+0.25), 0.0, 1.0 );
+    
+  float a = m2*(q.x+s)*(q.x+s) + q.y*q.y;
+  float b = m2*(q.x+0.5*t)*(q.x+0.5*t) + (q.y-m2*t)*(q.y-m2*t);
+    
+  float d2 = min(q.y,-q.x*m2-q.y*0.5) > 0.0 ? 0.0 : min(a,b);
+    
+  return sqrt( (d2+q.z*q.z)/m2 ) * sign(max(q.z,-p.y));
+}

TouchDesigner/td-shaders/sdfLib.glsl

@@ -2,6 +2,6 @@
     "BUILD": "TRUE",
     "TD_VERSION": "2023.12230",
     "PROJECT_FILE": "./TouchDesigner/project.toe",
-    "REPO": "https://github.com/SudoMagicCode/td-tox-builder-template",
-    "COMP_NAME": "Empty"
+    "REPO": "https://github.com/SudoMagicCode/sudo_td_shader_lib",
+    "COMP_NAME": "shaderLib"
 }