Fractalforums

These are both based on the Menger_Sphere.frag from Examples/knighty's Collection
I hacked the DeltaDE code from buddhi into it and the details are amazing!

Just the menger...


Folded menger with applied domain mashup...


DarkBeam's folding code from that old frag...

add some variables for control and the bool switch for serial vs parallel...
uniform vec3 fo; slider[(0.,0,0),(0.5,0.5,0.5),(2.,2.,2.)]
uniform vec3 g; slider[(0.,0,0),(0.1,0.1,0.1),(2.,2.,2.)]
uniform bool Serial; checkbox[false]add the fold subroutines...
//DarkBeam's "fold"... reinterpreted... it's more than a fold, much more! Just awesome!
float DBFold(vec3 p, float fo, float g){
if(p.z>p.y) p.yz=p.zy;//Diagonal fold
//Tis is slightly different from the original fold in order to make it continuous in this context
float vx=p.x-2.*fo;
float vy=p.y-4.*fo;
  float v=max(abs(vx+fo)-fo,vy);
float v1=max(vx-g,p.y);
v=min(v,v1);
return min(v,p.x);
}
//the coordinates are pushed/pulled in parallel
vec3 DBFoldParallel(vec3 p, vec3 fo, vec3 g){
vec3 p1=p;
p.x=DBFold(p1,fo.x,g.x);
p.y=DBFold(p1.yzx,fo.y,g.y);
p.z=DBFold(p1.zxy,fo.z,g.z);
return p;
}
//serial version
vec3 DBFoldSerial(vec3 p, vec3 fo, vec3 g){
p.x=DBFold(p,fo.x,g.x);
p.y=DBFold(p.yzx,fo.y,g.y);
p.z=DBFold(p.zxy,fo.z,g.z);
return p;
}
...then, before the iteration loop...
//Apply pull transformation
vec3 signs=sign(p);//Save the original signs
p=abs(p);
if(Serial) p=DBFoldSerial(p,fo,g);
else p=DBFoldParallel(p,fo,g);
p*=signs;//restore signs: this way the mandelbrot set won't extend in negative directions... and if you put the above code inside the iteration loop...

this should work with any fractal formula?

Linkback: https://fractalforums.org/code-snippets-fragments/74/folding-menger-the-db-way/2405/

for more example settings and a complete frag goto https://fractalforums.org/image-threads/25/folding-menger-the-db-way-a-study-of-structures/2416/msg11698

cool, i had lost that link, thanks

  that was part of my tests re:board blocking, so it's quite new, this is the first time I've used the image threads board, it could be handy for this sort of thing,
 we'll see how things unfold    yes, I actually said that

I thought I had replied here already

3Dickulus, again great stuff to have, thanks for posting here!
Reminds me that I have some transforms still lying around that can be used as pre-post-and normal transforms that I mean to post here but keep forgetting... 

here are some more folding functions...
void sphereFold(inout vec3 z, inout float dz) {
float r2 = dot(z,z);
if (r2< minRadius2) {
float temp = (fixedRadius2/minRadius2);
z*= temp;
dz*=temp;
} else if (r2<fixedRadius2) {
float temp =(fixedRadius2/r2);
z*=temp;
dz*=temp;
}
}
void boxFold(inout vec3 z, inout float dz) {
z = clamp(z, -foldingLimit, foldingLimit) * 2.0 - z;
}
void boxFold3(inout vec3 z, inout float dz) {
if (z.x>foldingLimit) { z.x = foldingValue-z.x; }  else if (z.x<-foldingLimit) z.x = -foldingValue-z.x;
if (z.y>foldingLimit)  { z.y = foldingValue-z.y;  } else if (z.y<-foldingLimit) z.y = -foldingValue-z.y;
if (z.z>foldingLimit)  { z.z = foldingValue-z.z ; } else if (z.z<-foldingLimit) z.z = -foldingValue-z.z;
}
void mengerFold(inout vec3 z, inout float dz) {
z = abs(z);
if (z.x<z.y){ z.xy = z.yx;}
if (z.x< z.z){ z.xz = z.zx;}
if (z.y<z.z){ z.yz = z.zy;}
z = Scale*z-Offset*(Scale-1.0);
if( z.z<-0.5*Offset.z*(Scale-1.0))  z.z+=Offset.z*(Scale-1.0);
dz*=Scale;

}
void octo(inout vec3 z, inout float dz) {
if (z.x+z.y<0.0) z.xy = -z.yx;
if (z.x+z.z<0.0) z.xz = -z.zx;
if (z.x-z.y<0.0) z.xy = z.yx;
if (z.x-z.z<0.0) z.xz = z.zx;
z = z*Scale2 - Offset2*(Scale2-1.0);
dz*= Scale2;
}

the attached frag is only one way of mixing these up definitely not the only way

edit: easingcurves are used for fade-in and fade-out needs 240 seconds (also works just fine without the easing curves)

  Great folding options and I very much enjoyed the animation, thank you, Dick!

tha script ArtOfFolding is experimental unfinished alpha, just for mucking about with combining routines