END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

I have been sidetracked and working backwards , by coding up mixPinski,  sierpinski4d and then finally sierpinski3D

If we take the sierpinski code from the mixPinski4D and add in a scale of default 2, and having a negative offset at default (1,1,1,1) we have a sierpinski4D.

My mixPinski UI has been updated to include a sierpinski scale set at default = 1.

Then we can add other linear types before and after this transform.

      if (p.x + p.y < 0.0) p = p.xy = -p.yx;
      if (p.x + p.z < 0.0) p = p.xz = -p.zx;
      if (p.y + p.z < 0.0) p = p.yz = -p.zy;

      if (p.x + p.w < 0.0) p = p.xw = -p.wx;
      if (p.y + p.w < 0.0) p = p.yw = -p.wy:
      if (p.z + p.w < 0.0) p = p.zw = -p.wz;

   p = p * scale2; // scale default 2
   Dd *= scale2;


   if (i >= startIter && i < stopIter)    // defaults 0 and 30?
   {
      p -= offset1111; // neg offset default ( 1,1,1,1)
   }

   //add rotation


BTW  My mixPinski UI has been updated to include a sierpinski scale set at default = 1.

Now for Sierpinski3D. I have included the code for  Darkbeams reversed full tetra-fold  as well, but I have yet to figure it out.

Sierpinski3D is fast (33 sec for this 3200x2400 render) and the DE calc quality is really good.

I have just randomly been testing combinations with other linear type transforms and it is very cool!!

BTW this is default settings looking down the MandelbulberV2 y_axis

   //Normal full tetra-fold;
   if (normalEnabled)
   {

          if (z.x - z.y < 0.0) z.xy = z.yz;
          if (z.x - z.z < 0.0) z.xz = z.zx;
          if (z.y - z.z < 0.0) z.yz = z.zy;
          if (z.x + z.y < 0.0) z.xy = -z.yx;
          if (z.x + z.z < 0.0) z.xz = -z.zx;
          if (z.y + z.z < 0.0) z.yz = -z.zy;
   }
   z = z * scale2;
   Dd *= scale2;


   if (i >= startIter && i < stopIter)
   {
      z -= offset111; // neg offset
   }

   // add rotation

   //Reversed full tetra-fold;
       /*if (z.x + z.y < 0.0) z.xy = -z.yz;
       if (z.x + z.z < 0.0) z.xz = -z.zx;
       if (z.y + z.z < 0.0) z.yz = -z.zy;
       if (z.x - z.y < 0.0) z.xy = z.yx;
       if (z.x - z.z < 0.0) z.xz = z.zx;
       if (z.y - z.z < 0.0) z.yz = z.zy;*/

@ sarbine.

Reciprocal3b , I am about  include this option in my OpenCL code.

This is the optimising (although it is not really necessary in Fragmentarium, because it is so fast)



Before the loop, we do this maths so that we do not have to do it every iteration:
double limitC = 1/Lim1 + 1/Lim2;

In the loop:
x' = sign(x)(limitC - 1/(abs(m1 * x) + Lim1 ) - 1/(m2 * x*x+ Lim2 ) )

So now I have coded the M3D Menger4, ( it is so cool!) and now I can finally see how the complete mixPinski was created.  Now I will do the 4D rotation, and i will then be finished

 (BTW DarkBeam suggested I code the MixPinski way back in June.  Good things take time )

This is the menger4D code I will use as the basis of a .frag
   float scaleM  default 3.0
   vec4 offsetM  default (1.0,1.0,0.5,0.5);
   vec4 opt1 = scaleM - 1.0;
   offsetM *= opt1;
   float opt2 = 0.5 * offsetM.z  / scaleM;

   vec4 PreAdd default (0.0,0.0,0.0,0.0);


// iteration loop
   if (i >= StartPreAdd && i < StopPreAdd)
   {
      z4D += PreAdd_vec4_0000; // offset
   }


   z4D = abs(z4D);
   vec4 temp4;

   if ( z4D.x - z4D.y < 0.0) { temp4.x = z4D.y; z4D.y = z4D.x; z4D.x = temp4.x ;}
   if ( z4D.x - z4D.z < 0.0) { temp4.x = z4D.z; z4D.z = z4D.x; z4D.x = temp4.x ;}
   if ( z4D.y - z4D.z < 0.0) { temp4.y = z4D.z; z4D.z = z4D.y; z4D.y = temp4.y ;}
   if ( z4D.x - z4D.w < 0.0) { temp4.x = z4D.w; z4D.w = z4D.x; z4D.x = temp4.x ;}
   if ( z4D.y - z4D.w < 0.0) { temp4.x = z4D.w; z4D.w = z4D.y; z4D.y = temp4.x ;}
   if ( z4D.z - z4D.w < 0.0) { temp4.y = z4D.w; z4D.w = z4D.z; z4D.z = temp4.y ;}

   // temp3D rot

   if (rot && i >= StartRot && i < StopRot)
   {
      //Temp3D rotation
   }




   z4D.x = scaleM * z4D.x - offsetM.x;
   z4D.y = scaleM * z4D.y - offsetM.y;
   z4D.w = scaleM * z4D.w - offsetM.w;
   z4D.z -= opt2;
   z4D.z = -fabs(-z4D.z);
   z4D.z += opt2;
   z4D.z *= scaleM;
   Dd *= scaleM;

   // bailout 10
   // return sqrt(x* x + y* y + z* z)*scale^(-i);

This is what I get in OpenCL

Finally happy for you and all people.
Those 4d kids except MixP were made from a formula kindly given to me by Syntopia the genius of Fragmentarium!

Image of dot modes 2,3 & 4.  It is kind of interesting. May be more so in another fractal?