Welcome to Fractal Forums

procedure MengerIFSsmooth(var x, y, z, w: Double; PIteration3D: TPIteration3D);
var
  t: Double;
  sc, sc1, sc2: Double;
  Cx, Cy, Cz: Double;
  s: Double;

begin
  sc := 3.0;
  sc1 := sc-1.0;
  sc2 := sc1/sc;
  Cx := 1.0; Cy := 1.0; Cz := 0.5;
  t := 9999999.0;
  s := 0.005;

  x := sqrt(x*x+s); y := sqrt(y*y+s); z := sqrt(z*z+s);

  t:=x-y; t:= 0.5*(t-sqrt(t*t+s));
  x:=x-t; y:= y+t;

  t:=x-z; t:= 0.5*(t-sqrt(t*t+s));
  x:=x-t; z:= z+t;

  t:=y-z; t:= 0.5*(t-sqrt(t*t+s));
  y:=y-t; z:= z+t;

  z := z - Cz*sc2;
  z := - sqrt(z*z+s);
  z := z + Cz*sc2;

  x := sc*x-Cx*sc1; 
  y := sc*y-Cy*sc1; 
  z := sc*z;
  w := sc*w; // w is the de scale starts as 1
end;

uniform vec3 bscale; slider[(-2,-2,-2),(0.5,0.5,0.5),(2,2,2)]
uniform vec3 boffset; slider[(-2,-2,-2),(0.5,0.5,0.5),(2,2,2)]

float Cx = 0.816496580927726;
float Cy = 0.5773502691896258;
float Cz = 0.7071067811865475;

void BenesiFold(inout vec3 b) {
// STEP1: "Benesi fold 1"
float tx=(b.x*Cx-b.z*Cy)*Cz;
b.z=abs(b.x*Cy + b.z*Cx);
b.x=abs(tx-b.y*Cz);
b.y=abs(tx+b.y*Cz);

tx=b.x*Cz+b.y*Cz;
b.y=-b.x*Cz+b.y*Cz;
b.x=tx*Cx+b.z*Cy;
b.z=-tx*Cy+b.z*Cx;

b.x=bscale.x*b.x-boffset.x;  //scale =2    offset=2
b.y=bscale.y*b.y-boffset.y;
b.z=bscale.z*b.z-boffset.z;
}

void BenesiPine(inout vec3 b) {
// STEP2: "Benesi pinetree"
float xt = b.x*b.x; float yt = b.y*b.y; float zt = b.z*b.z;
float t = 2.0*b.x/sqrt(yt+zt);
b.x = xt-yt-zt+Cx;
b.z = t*(yt-zt)+Cy;
b.y = 2.0*t*b.y*b.z+Cz;
}

// keep scale values the same for each variable, for a more orderly fractal
uniform vec3 bscale; slider[(-5,-5,-5),(2,2,2),(5,5,5)]
//only use x component, for a more orderly fractal
uniform vec3 boffset; slider[(-5,-5,-5),(2,0,0),(5,5,5)]

// just use x pixel, for most orderly fractal... I like order.  Don't ever alter this ever, or the fractal will
// come to life, seek out fluffy bunnies, and explode.  So if you face the Rabbit of Caerbannog.. well.
// this fractal can help, if you don't have the HHGoA.  
uniform vec3 PixelMult;slider[(-2,-2,-2),(1,0,0),(2,2,2)]

  //I'd multiply the pixel outside of the loop or function call, so you don't have to do it a bunch of times... so do it here:
Cx=Cx*PixelMult.x;
Cy=Cy*PixelMult.y;
Cz=Cz*PixelMult.z;

void BenesiPine(inout vec3 b) {
// STEP2: "Benesi pinetree"
float xt = b.x*b.x; float yt = b.y*b.y; float zt = b.z*b.z;
float t = 2.0*b.x/sqrt(yt+zt);
b.x = xt-yt-zt+Cx;
b.y = 2.0*t*b.y*b.z+Cz;  //  was b.z = t*(yt-zt)+Cy;      had to switch these because b.z is used in this.. so cannot
b.z = t*(yt-zt)+Cy;  //   was   b.y = 2.0*t*b.y*b.z+Cz;    change before it is calculated.  y and z are still switched
}                                                  // mathematically... just not in the formula    so I'd leave a comment so people know

float Cx = 0.816496580927726;
float Cy = 0.5773502691896258;
float Cz = 0.7071067811865475;

CVector3 temp = z;
    z *= z;
    double t = 2 * temp.x/sqrt(z.y + z.z);
    c *= benesiFastPwr2PineTree.constantMultiplierVect;  // possibly move to IC
    z.x = (z.x - z.y - z.z) + c.x ;
    z.z = (t * (z.y - z.z)) + c.y ;
    z.y = (2 * t * temp.y * temp.z) + c.z;

#define NVIDIAGL4PLUS

#define providesInside
#define providesInit
//#include "DE-Raytracer.frag"
#include "Fast-Raytracer.frag"
//#include "DE-Kn2.frag"

HF_Fallof = 0.25
HF_Const = 0.001
HF_Intensity = 0.01
HF_Dir = 1,0,0
HF_Offset = 10
HF_Color = 1,1,1,0
HF_Scatter = 10
HF_Anisotropy = 0.6862745,0.4784314,0.1137255
HF_FogIter = 16
HF_CastShadow = true

GaussianWeight = 6
AntiAliasScale = 2
Bloom = true
BloomIntensity = 0.16
BloomPow = 1.173913
BloomTaps = 2

sq_r := sqrt(x*x+y*y+z*z)
sq_xz := sqrt(x*x+z*z)
r:= sq_r ^ Power

theta  = atan2( sq_xz , y) * P
zangle = atan2(x,z)  * zAP

x := sin(zangle)*sin(theta)*r+Cx   =====    4xyz /sqrt (x^2 + z^2)        //divide by sqrt(x^2+z^2)  not multiply!
y := cos(theta)            *r+Cy   ======     y^2 - x^2 + z^2
z := sin(theta)*cos(zangle)*r+Cz   ====     2y * (x^2 - y^2)  / sqrt (y^2 + z^2)     //same here!!!!

Setting texture to: C:/Documents and Settings/Amintor/Desktop/Fragmentarium-1.0.13-Qt_5_3_2_MinGW/glitter_glow_texture_ix_by_hauntingmewithstock.jpg
Setting texture to: C:/Documents and Settings/Amintor/Desktop/Fragmentarium-1.0.13-Qt_5_3_2_MinGW/original.jpg
Camera: Use W/S to fly. 1/3 adjusts speed. Q/E rolls. Click on 3D window for key focus. See Help Menu for more.
Created front and back buffers as RGBA32F
Maximum texture size: 8192x8192
Could not locate sampler2D uniform: htex
Found texture in cache: C:/Documents and Settings/Amintor/Desktop/Fragmentarium-1.0.13-Qt_5_3_2_MinGW/glitter_glow_texture_ix_by_hauntingmewithstock.jpg
Could not locate sampler2D uniform: htex
Found texture in cache: C:/Documents and Settings/Amintor/Desktop/Fragmentarium-1.0.13-Qt_5_3_2_MinGW/glitter_glow_texture_ix_by_hauntingmewithstock.jpg
Compiled script in 2266 ms.

    int l = shaderProgram->uniformLocation(textureName);
        if (l != -1) { // found named texture in shader program
    ....
        } else WARNING("Could not locate sampler2D uniform: " + textureName);

rmin=minRadius;
	r=sqr(sx- 1) + sqr(sy- 1) + sqr (sz- 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=1 ; sz2=1 ;
	}
	r=sqr(sx) + sqr(sy- 1) + sqr (sz- 1);
	if (r<rmin) {
	rmin=r; sx2=0 ; sy2=1 ; sz2=1 ;
	}
	r=sqr(sx+1) + sqr(sy- 1) + sqr (sz- 1 );
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=1 ; sz2=1 ;					/* third one  */
	}
	r=sqr(sx- 1) + sqr(sy) + sqr (sz- 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=0 ; sz2=1 ;
	}
	
	r=sqr(sx+1) + sqr(sy) + sqr (sz- 1 );  
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=0 ; sz2=1 ;
	}
	
	r=sqr(sx- 1) + sqr(sy+1) + sqr (sz- 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=-1 ; sz2=1 ;
	}
	r=sqr(sx) + sqr(sy+1) + sqr (sz- 1);
	if (r<rmin) {
	rmin=r; sx2=0 ; sy2=-1 ; sz2=1 ;
	}
	r=sqr(sx+1) + sqr(sy+1) + sqr (sz- 1 );   /* 9  */
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=-1 ; sz2=1 ;
	}
	/* next set  */
	r=sqr(sx+ 1) + sqr(sy- 1) + sqr (sz );
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=1 ; sz2=0 ;
	}
	
	r=sqr(sx+1) + sqr(sy+ 1) + sqr (sz );
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=-1 ; sz2=0 ;					/* third one  */
	}
	r=sqr(sx- 1) + sqr(sy+1) + sqr (sz );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=-1 ; sz2=0 ;
	}
	
	r=sqr(sx-1) + sqr(sy-1) + sqr (sz );   /*  6    */
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=1 ; sz2=0 ;
	}
			/* -z set  */
	 r=sqr(sx- 1) + sqr(sy- 1) + sqr (sz+ 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=1 ; sz2=-1 ;
	}
	r=sqr(sx) + sqr(sy- 1) + sqr (sz+ 1);
	if (r<rmin) {
	rmin=r; sx2=0 ; sy2=1 ; sz2=-1 ;
	}
	r=sqr(sx+1) + sqr(sy- 1) + sqr (sz+ 1 );
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=1 ; sz2=-1 ;					/* third one  */
	}
	r=sqr(sx- 1) + sqr(sy) + sqr (sz+ 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=0 ; sz2=-1 ;
	}

	r=sqr(sx+1) + sqr(sy) + sqr (sz+ 1 );  
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=0 ; sz2=-1 ;
	}
	
	r=sqr(sx- 1) + sqr(sy+1) + sqr (sz+ 1 );
	if (r<rmin) {
	rmin=r; sx2=1 ; sy2=-1 ; sz2=-1 ;
	}
	r=sqr(sx) + sqr(sy+1) + sqr (sz+1);
	if (r<rmin) {
	rmin=r; sx2=0 ; sy2=-1 ; sz2=-1 ;
	}
	r=sqr(sx+1) + sqr(sy+1) + sqr (sz+ 1 );   /* 9  */
	if (r<rmin) {
	rmin=r; sx2=-1 ; sy2=-1 ; sz2=-1 ;
	}
	
	if (juliaMode) {
	sx= cr+ scalef*sx-sx2*scalef2;
	sy= ci+ scalef*sy-sy2*scalef2;
	sz= cj+ scalef*sz-sz2*scalef2;
	} else {
	sx= pixelr+ scalef*sx-sx2*scalef2;
	sy= pixeli+ scalef*sy-sy2*scalef2;
	sz= pixelj+ scalef*sz-sz2*scalef2;
	}
	z=quaternion(sx,sy,sz,sqrt(sqr(sx)+sqr(sy)+sqr(sz)));
	//bailout = sqrt(scalef2);
	if (skmode) {
	if (abs(sx)>abs(sy) && abs(sx)>abs(sz)) {
	bail=abs(sx);
	
	} else if (abs(sy)>abs(sz)) {
	bail= abs(sy);
	} else {
	bail=abs(sz);
	} } else  {
	bail = sqr(sx)+sqr(sy)+sqr(sz);
	}