Welcome to Fractal Forums

        bool EXTRA_TRIG_FUNCTION=false;
        
	float rxy; 
	float ratrack=pi2-pi2/folds;   //pi2 is 2*pi
	float rotadjust=-pi/folds  + FoldAdjust;     // I called folds splits in my original code...
// I called them splits because I didn't know
	float pintrack=pi/folds;      //what they were called.....
	float pi2splits=pi2/folds;
	float  i=0.0;    //why a float??  I was doing something with it...  
	
	float omega=atan(z.y,z.x); 
	if (omega<0.0) {omega+=pi2;}    //so angle goes from 0 to 2pi instead of having negative part
	
	float rotate=0;   

   //I only wanted to do the kaleidoscope rotations on specific iterations
  // doing multiple polyfolds... you can do it every iteration or whatever- for cool effects
  // only do it on specific iterations- I was making kaleidoscopes out of 2d polyfolding

	if (RotateIter==n) {rotate=Rotate;}    //only do the rotation on a specific iteration

	
	while (omega>pi2folds && i<floor(folds+1.0)) {
			i+=1.0;
			
			if (EvenFolds) {rotate*=-1;}    //if you have an even number of folds, you can do 1/2 as
                                                                 //many rotations- it's sort of cool

				if (!EXTRA_TRIG_FUNCTION) {   //that is a NOT "!"  :D 
					rotadjust+=ratrack;
					pintrack+=pi2folds;
					omega-=pi2folds;
				} else {     //with extra trig function, you don't need the above... just do the above instead
					omega-=pi2folds;
				}
			}

			if (EXTRA_TRIG_FUNCTION) {   // don't do this unless you absolutely love using transcendental functions
			 	z=length(z)*vec2(cos(omega),sin(omega));
			}

// if you don't have an even number of folds, you have to make an even number of rotations like the following:

		if (omega>pi2folds*.5 && !EvenFolds) {rotate*=-1;}

// pintrack is used to shift the fold center outwords- images follow

			vec2 z2=vec2(cos(pintrack),sin(pintrack));    

// splitrad is the distance from the center that the folds are shifted outwards
		
			z.xy-=z2*splitrad;
			 rxy=length (z.xy);   
			
// rotadjust keeps every duplicate aligned correctly.  		
	 		omega=atan(z.y,z.x)+rotadjust+rotate+FoldAdjust;
			z.xy=rxy * vec2(cos(omega),sin(omega));


	return z;

uniform bool EvenFolds; checkbox[true]
uniform bool EXTRA_TRIG_FUNCTION; checkbox[false]

uniform float folds; slider[1,4,50]
uniform float splitrad; slider[0,0,50]
uniform float FoldAdjust; slider[0,0,50]
uniform int RotateIter; slider[0,1,50]
float Rotate;
float rotate = 0.0;
int n = 0;
int i = 0;
float pi2 = 2 * M_PI_F;
float pi = M_PI_F;
float rxy;
float omega; 
float pintrack = pi / folds;
float pi2folds = pi2 / folds;	
float ratrack = pi2 - pi2folds; 
float rotadjust = -pintrack + FoldAdjust;       	 
omega = atan(z.y,z.x); 
if (omega < 0.0) {omega += pi2;}    //so angle goes from 0 to 2pi instead of having negative part
//if (RotateIter == n) {rotate = Rotate;}    //only do the rotation on a specific iteration

// Iter loop 

//14-12-16 

   //I only wanted to do the kaleidoscope rotations on specific iterations
  
	// doing multiple polyfolds... you can do it every iteration or whatever- for cool effects
  
	// only do it on specific iterations- I was making kaleidoscopes out of 2d polyfolding
	
//if (RotateIter == n) {rotate = Rotate;}    //only do the rotation on a specific iteration
	
if (omega > pi2folds && i < floor(folds + 1.0))
{

	//i += 1;
	
	if (EvenFolds == 0) 	{rotate *= -1;} 
   	{
		//if you have an even number of folds, you can do half 
		//many rotations it's sort of cool

		if (EXTRA_TRIG_FUNCTION != 0)//that is a NOT "!"  :D 
		{   
			rotadjust += ratrack;
			pintrack += pi2folds;
			omega -= pi2folds;
		}
		 else
		{     //with extra trig function, you don't need the above... just do the above instead. what????
			omega -= pi2folds;
		}
	}
			

	if (EXTRA_TRIG_FUNCTION == 0)
	{   // don't do this unless you absolutely love using transcendental functions

		//z = length(z) * (float2){(cos(omega), sin(omega));
		rxy = length(z.xy); 
		z.x = rxy * cos(omega);
		z.y = rxy * sin(omega);
	}



	// if you don't have an even number of folds, you have to make an even number of rotations like the following:
	
	if (omega > pi2folds * 0.5 && EvenFolds != 0) {rotate *= -1;} 


	// pintrack is used to shift the fold center outwords- images follow
	// splitrad is the distance from the center that the folds are shifted outwards
		//vec2 z2=vec2(cos(pintrack),sin(pintrack));  
		//z.xy-=z2*splitrad;

		z.x -= cos(pintrack) * splitrad;
		z.y -= sin(pintrack) * splitrad;
		rxy = length(z.xy);			
	// rotadjust keeps every duplicate aligned correctly.
		omega = atan(z.y/z.x) + rotadjust + rotate + FoldAdjust;
		//z.xy=rxy * vec2(cos(omega),sin(omega));
		z.x = rxy * cos(omega);
		z.y = rxy * sin(omega);

}

z = fabs( 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;



//Rotation (Mandelbox Tab, - main rotation)
z = Matrix33MulFloat3(consts->fractal.mandelbox.mainRot, z);


z *= ScaleM;	
DE *= ScaleM; // * Tweak


z.x -= OffsetM.x;

z.y -= OffsetM.y;

//
if (Enable.z == 1) // standard z.z condition for Menger Sponge 
	
//{

	if (z.z > 1.0) z.z -= OffsetM.z;

//}
//else
//{
//	z.z -= OffsetM.z;
//}	

void Poly_Fold_sym(inout dvec4 p, int order)
{
   float m = (float)order/TWOPI;
   bool cy = false; // lol... not glsl anymore

   int sector = (int)(m*(-atan(float(p.x),float(p.y))));
   if (sector&1) cy= true; // parity
   float angle = (float)sector/m;
   p.xy=rotate(p.xy,angle);
   if (cy) p.y=-p.y;
   // if ((order&1) && (sector ==0)) p.y = fabs(p.y); // more continuous?
}

	if (angleXY != 0)
	{
		tp = z;
		z.x = tp.x * cos(angleXY) + tp.y * sin(angleXY);
		z.y = tp.x * -sin(angleXY) + tp.y * cos(angleXY);
	}
	if (angleYZ != 0)
	{
		tp = z;
		z.y = tp.y * cos(angleYZ) + tp.z * sin(angleYZ);
		z.z = tp.y * -sin(angleYZ) + tp.z * cos(angleYZ);
	}
	if (angleXZ != 0)
	{
		tp = z;
		z.x = tp.x * cos(angleXZ) + tp.z * sin(angleXZ);
		z.z = tp.x * -sin(angleXZ) + tp.z * cos(angleXZ);
	}