Welcome to Fractal Forums

final int MAXITER = 16;
final int MAXSTEP = 255;
final float p=8.0;
final color white = color(255);

float[][] pts = new float[MAXITER+1][3];
int count = 0;
float x,y,z;


void setup() {
  size(800,800,P2D);
  frameRate(1000);
  background(0);
  stroke(255);
}

void draw() {
  loadPixels();
  count++;
  if(count > 10000) {
    count=0;
    randomSeed(millis());
  }
  for(int i = 0; i < 1000; i++) {
  x = random(-1.5,1.5);
  y = random(-1.5,1.5);
  z = -4.0;
  float dr = 1.0;
  int step =0;

  for(step = 0; step < MAXSTEP; step++) {
  int iter = 0;
  float r = 0.0;
  float nx = x;
  float ny = y;
  float nz = z;
  r=sqrt(x*x+y*y+z*z);
  float th=atan(y/x)*p;
  float ph=asin(z/r)*p;
  float u,v;

    while(iter < MAXITER && r<2.0  ) {
      float r2p = pow(r,p);
      th=atan(ny/nx)*p;
      ph=asin(nz/r)*p;
      nx=r2p*cos(ph)*cos(th)+x;
      ny=r2p*cos(ph)*sin(th)+y;
      nz=r2p*sin(ph)+z;
      r=sqrt(nx*nx+ny*ny+nz*nz);
      dr=dr*p*pow(r,p-1.0)+1.0;
      iter++; 
    }
    //println(dr);
    if(r<2.0) {
        u =  x * 6.0 / (z + 4.0);
        v = y  * 6.0 / (z + 4.0);
        u = (2.0 + u) / 4.0 * width;
        v = (2.0 + v) / 4.0 * height;
        if(u > 0 && u < width && v > 0 && v < height) {
          pixels[(int)((int)u + (int)v * width)] = color(step*1,step*1,step*1);
        }
        break;
    } else {
      step++;
      z+=0.1;//*log(r)*r/dr;
    }
  }
  }  
  updatePixels();
}  

  

final int MAXITER = 16;
final int MAXSTEP = 255;
final float p=8.0;
final color white = color(255);

float[][] pts = new float[MAXITER+1][3];
int count = 0;
float x,y,z;


void setup() {
  size(800,800,P2D);
  frameRate(1000);
  background(0);
  stroke(255);
}

void draw() {
  loadPixels();
  count++;
  if(count > 10000) {
    count=0;
    randomSeed(millis());
  }
  for(int i = 0; i < 1000; i++) {
  x = random(-1.5,1.5);
  y = random(-1.5,1.5);
  z = -4.0;
  
  int step =0;

  for(step = 0; step < MAXSTEP; step++) {
  int iter = 0;
  float r = 0.0;
  float dr = 1.0;
  float nx = x;
  float ny = y;
  float nz = z;
  r=sqrt(x*x+y*y+z*z);
  float th=atan(y/x)*p;
  float ph=asin(z/r)*p;
  float u,v;
  
    while(iter < MAXITER /*&& r<2.0*/  ) {
      float r2p = pow(r,p);
      th=atan2(ny,nx)*p;
      ph=asin(nz/r)*p;
      nx=r2p*cos(ph)*cos(th)+x;
      ny=r2p*cos(ph)*sin(th)+y;
      nz=r2p*sin(ph)+z;
      r=sqrt(nx*nx+ny*ny+nz*nz);
      dr=dr*p*pow(r,p-1.0)+1.0;  
      iter++; 
    }
    
    if(r<2.0) {
        println(dr);
        u =  x * 6.0 / (z + 4.0);
        v = y  * 6.0 / (z + 4.0);
        u = (2.0 + u) / 4.0 * width;
        v = (2.0 + v) / 4.0 * height;
        if(u > 0 && u < width && v > 0 && v < height) {
          pixels[(int)((int)u + (int)v * width)] = color(step*1,step*1,step*1);
        }
        break;
    } else {
      step++;
      z+=0.1;
      z+=0.5*log(r)*r/dr; //<-nothing
    }
  }
  }  
  updatePixels();
}  

final int MAXITER = 16;
final int MAXSTEP = 255;
final float p=8.0;
final color white = color(255);

float[][] pts = new float[MAXITER+1][3];
int count = 0;
float x,y,z;


void setup() {
  size(800,800,P2D);
  frameRate(1000);
  background(0);
  stroke(255);
}

void draw() {
  loadPixels();
  count++;
  if(count > 10000) {
    count=0;
    randomSeed(millis());
  }
  for(int i = 0; i < 10000; i++) {
  x = random(-1.5,1.5);
  y = random(-1.5,1.5);
  z = -4.0;
  
  int step =0;

  for(step = 0; step < MAXSTEP && z < 4.0; step++) {
  int iter = 0;
  float r = 0.0;
  float dr = 1.0;
  float nx = x;
  float ny = y;
  float nz = z;
  r=sqrt(x*x+y*y+z*z);
  float th=atan(y/x)*p;
  float ph=asin(z/r)*p;
  float u,v;
  
    while(iter < MAXITER && r<2.0  ) {
      float r2p = pow(r,p);
      th=atan2(ny,nx)*p;
      ph=asin(nz/r)*p;
      nx=r2p*cos(ph)*cos(th)+x;
      ny=r2p*cos(ph)*sin(th)+y;
      nz=r2p*sin(ph)+z;
      dr=dr*p*pow(r,p-1.0)+1.0;  
      r=sqrt(nx*nx+ny*ny+nz*nz);
      iter++; 
    }
    
    if(0.5*log(r)*r/dr < 0.00001) {
        
        u =  x * 6.0 / (z + 4.0);
        v = y  * 6.0 / (z + 4.0);
        u = (2.0 + u) / 4.0 * width;
        v = (2.0 + v) / 4.0 * height;
        if(u > 0 && u < width && v > 0 && v < height) {
          pixels[(int)((int)u + (int)v * width)] = color(step*1,step*1,step*1);
        }
        break;
    } else {
      step++;
      z+=0.5*log(r)*r/dr;
    }
  }
  }  
  updatePixels();
}  

  

 for(y = 0; y < Y; y++) 
  for(x = 0; x < X; x++) {
   xx = 2.0* ((float)x/(float)X) -1.0;
   yy = 2.0* ((float)y/(float)Y) -1.0;
   zz = -4.0;

 
xx = 2.0* ((float)x/(float)X) -1.0;
yy = 2.0* ((float)y/(float)Y) -1.0;

 
xx = 4.0* ((float)x/(float)X) -2.0;
yy = 4.0* ((float)y/(float)Y) -2.0;

 
xx = 8.0* ((float)x/(float)X) -4.0;
yy = 8.0* ((float)y/(float)Y) -4.0;

void yFractal::GetFractalColor999() 
{
	static float x, y, z, r, dr, nx, ny, nz, th, ph, r2p, cr1, cr2, cr4, max_z, mag;
	static int iter, step;

	cr1 = float(m_CustomRange1);
	cr2 = float(m_CustomRange2); 
	max_z = float(m_CustomRange3);  
	cr4 = float(m_CustomRange4); 
	mag = float(m_Magnitude)/1000.0f;

	x = float(m_StartX);
	y = float(m_StartY);
	z = -max_z;

	for(step=0; step<m_Iterations && z<max_z; step++) 
	{
		iter=0;
		r=0.0f;
		dr=1.0f;
		nx=x;
		ny=y;
		nz=z;
		r=sqrtf(x*x + y*y + z*z);
		th=atanf(y/x) * cr2;
		ph=asinf(z/r) * cr2;

		while(iter<cr1 && r<4.0f) 
		{
			r2p=powf(r, cr2);

			th=atan2f(ny, nx) * cr2;
			ph=asinf(nz/r) * cr2;
				
			nx=r2p*cosf(ph)*cosf(th) + x;
			ny=r2p*cosf(ph)*sinf(th) + y;
			nz=r2p*sinf(ph) + z;
				
			dr=dr*cr2*powf(r, cr2-1.0f) + 1.0f;  
			r=sqrtf(nx*nx + ny*ny + nz*nz);
				
			iter++; 
		}

		if(0.001f*logf(r)*r/dr < mag) 
		{
			m_C=int( float(step) * m_ColorPerIteration ); // Return color index from range 0 to (m_NumColors-1)
			return;
		} 
		else 
		{
			step++;
			z+=cr4*logf(r)*r/dr;
		}

	} //for(step=0; step<m_Iterations && z<max_z; step++) 

	m_C=0;
}

float xmin = -2;
float ymin = -2;
float zmin = -2;
float wh = 4;
int maxIterations = 6;
int power = 8;
int screenSize = 200;

void setup() {
  size(screenSize, screenSize, P3D);
  noStroke();
  noLoop();
}

void draw() {
  background(255);
  translate(0, screenSize/2, 0);
  rotateX(-HALF_PI);
  translate(0, -screenSize/2, -screenSize/2);
  float xmax = xmin+wh;
  float ymax = ymin+wh;
  float zmax = zmin+wh;
  float dx = (xmax-xmin)/screenSize;
  float dy = (ymax-ymin)/screenSize;
  float dz = (zmax-zmin)/screenSize;
  int count = 0;
  float x = xmin;
  for (int i = 0; i < screenSize; i++) {
    float y = ymin;
    for (int j = 0; j < screenSize; j++) {
      float z = zmin;
      for (int k = 0; k < screenSize; k++) {
        float nx = x;
        float ny = y;
        float nz = z;
        int n = 0;
        while (n < maxIterations) {
          float rad = pow(sqrt(nx*nx+ny*ny+nz*nz), power);
          float theta = atan2(sqrt(nx*nx+ny*ny), nz)*power;
          float phi = atan2(ny, nx)*power;
          nx = sin(theta)*cos(phi)*rad+x;
          ny = sin(theta)*sin(phi)*rad+y;
          nz = cos(theta)*rad+z;
          if (nx*nx+ny*ny+nz*nz > 16) break;
          n++;
        }
        if (n == maxIterations) {
          float distE = sqrt(x*x+y*y+z*z);
          float cr = 98*(abs(x)+distE);
          float cg = 98*(abs(y)+distE);
          float cb = 98*(abs(z)+distE);
          fill(cr, cg, cb);
          translate(i, j, k);
          box(1);
          translate(-i, -j, -k);
        }
        z += dz;
      }
      y += dy;
    }
    x += dx;
    println((float(count)/screenSize*100)+"%");
    count++;
  }
  println("Time: "+millis());
  saveFrame("result.png");
}

nx=r2p*cos(ph)*cos(th)+dx;
ny=r2p*cos(ph)*sin(th)+dy;
nz=r2p*sin(ph)+dz;

    
    parameter int antialiasing
  <
    minValue:int(1);
    maxValue:int(3);
    defaultValue:int(1);
    description: "The antialiasing level.";
  >;
  
    parameter int size
  <
    minValue:int(100);
    maxValue:int(2048);
    defaultValue:int(200);
    description: "The output size in pixels.";
  >;
  
  	parameter float ambientOcclusion
	<
		minValue:0.0;
		maxValue:1.0;
		defaultValue:0.8;
		description: "Enable fake ambient occlusion factor based on the orbit trap.";
	>;
    
    parameter float power
	<
		minValue:1.0;
		maxValue:16.0;
		defaultValue:8.0;
		description: "Power.";
	>;
    
        parameter int MAXITER
	<
		minValue:1;
		maxValue:32;
		defaultValue:16;
		description: "Iterations";
	>;
    
    region generated()
  {
    return region(float4(0, 0, size, size));
  }
    output float4 dst;
    
    
	// Calculate the output colour for each input pixel
	float4 renderPixel(float2 pixel)
	{
    float4 color = float4(0, 0, 0, 0);
    float ao;
    float min_dist = 4.0;
    int MAXSTEP = 255;
    int step = 0;
    float dx = 2.0 * pixel.x / float(size) - 1.0;
    float dy = -2.0 * pixel.y / float(size) + 1.0;
    float dz = -4.0;
                       
                                  
  for (step = 0; step < MAXSTEP && dz < 4.0; step++)
  {
  int iter = 0;
  //float r = 0.0;
  float dr = 1.0;
  float nx = dx;
  float ny = dy;
  float nz = dz;
  float r=sqrt(dx*dx+dy*dy+dz*dz);
  float th=atan(dy/dx)*power;
  float ph=asin(dz/r)*power;
  if (r < min_dist) min_dist = r;
  float u,v;
 
  
      while(iter < MAXITER && r < 2.0  ) 
      {
      float r2p = pow(r,power);
      th=atan(ny,nx)*power;
      ph=asin(nz/r)*power;
      nx=r2p*cos(ph)*cos(th)+dx;
      ny=r2p*cos(ph)*sin(th)+dy;
      nz=r2p*sin(ph)+dz;
      dr=dr*power*pow(r,power-1.0)+1.0;  
      r=sqrt(nx*nx+ny*ny+nz*nz);
      iter++;  
      }
      
      if (r < min_dist) min_dist = r;
      
        if(0.5*log(r)*r/dr < 0.00001) 
        {
        ao	= 1.0 - clamp(1.0 - min_dist * min_dist, 0.0, 1.0) * ambientOcclusion;
        //color = (255-step,255-step,255-step,255);
        //dst = float4(255-step,255-step,255-step,255);
        //dst.rgb=float3( float(255-step) / 255.0, float(255-step) / 255.0 , float(255-step) / 255.0);
        //dst.a = 1.0;
        break;
        }
        else
        {
        step++;
        dz+=0.5*log(r)*r/dr;
        }

 
        }
            color = float4( float(255-step) / 255.0, float(255-step) / 255.0 , float(255-step) / 255.0, 1.0); 
            ao *= 1.0 - (float(step) / float(MAXSTEP)) * 0.58 * 2.0;
            color.rgb *= ao;

            //return float4( float(255-step) / 255.0, float(255-step) / 255.0 , float(255-step) / 255.0, 1.0); 
            return clamp(color, 0.0, 1.0);
    }
    
    

	// The main loop
	void evaluatePixel()
	{
		float4 color = float4(0, 0, 0, 0);
        float sampleStep = 1.0 / float(antialiasing);
        float sampleContribution = 1.0 / pow(float(antialiasing), 2.0);     
    
		if (antialiasing > 1) {
			// Average antialiasing^2 points per pixel
			for (float i = 0.0; i < 1.0; i += sampleStep)
				for (float j = 0.0; j < 1.0; j += sampleStep)
					color += sampleContribution * renderPixel(float2(outCoord().x + i, outCoord().y + j));
		} else {
			color = renderPixel(outCoord());
		}

		// Return the final color which is still the background color if we didn't hit anything.
		dst = color;
	}
    
}

int compact = 4;
int maxIterations = 5;
int power = 8;
int screenSize = 400;
float xmin = -1.5;
float ymin = -1.5;
float zmin = -1.5;
float wh = 3.0;
float toAdd = wh/(screenSize*compact);

void setup() {
  size(screenSize, screenSize, P2D);
  background(0);
  noLoop();
}

void draw() {
  loadPixels();
  float x = xmin;
  for (int i = 0; i < screenSize*compact; i++) {
    float y = ymin;
    for (int j = 0; j < screenSize*compact; j++) {
      float z = zmin;
      for (int step = 255; step > 0 && z < -1*zmin; step--) {
        float dr = 1.0;
        float nx = x;
        float ny = y;
        float nz = z;
        float r = sqrt(x*x+y*y+z*z);
        int n = 0;
        while (n < maxIterations && r < 2) {
          float r2p = pow(r, power);
          float th = atan2(ny, nx)*power;
          float ph = asin(nz/r)*power;
          nx = r2p*cos(ph)*cos(th)+x;
          ny = r2p*cos(ph)*sin(th)+y;
          nz = r2p*sin(ph)+z;
          dr = dr*power*pow(r, power-1)+1;
          r = sqrt(nx*nx+ny*ny+nz*nz);
          n++;
        }
        if (0.5*log(r)*r/dr < 0.00001) {
          float u = x*6/(z+4);
          float v = y*6/(z+4);
          u = (2+u)/4*width;
          v = (2+v)/4*height;
          if (u > 0 && u < width && v > 0 && v < height) {
            pixels[(int)u+(int)v*width] = (step<<16)+(step<<8)+step;
          }
          break;
        }
        else {
          step--;
          z += 0.5*log(r)*r/dr;
        }
      }
      y += toAdd;
    }
    x += toAdd;
    println((float)i/(screenSize*compact)*100+"%");
  }
  updatePixels();
  println("Time: "+millis());
}

while(iter < MAXITER && r < 2.0  ) 

int compact = 2;
int maxIterations = 3;
int power = 8;
int screenSize = 800;
float xmin = -1.5;
float ymin = -1.5;
float zmin = -1.5;
float wh = 3;
float toAdd = wh/(screenSize*compact);

void setup() {
  size(screenSize, screenSize, P3D);
  noLoop();
}

void draw() {
  loadPixels();
  float[] pixVals = new float[screenSize*screenSize];
  int[] pixDivs = new int[screenSize*screenSize];
  float x = xmin;
  for (int i = 0; i < screenSize*compact; i++) {
    float y = ymin;
    for (int j = 0; j < screenSize*compact; j++) {
      float z = zmin;
      for (int k = 255; k > 0 && z < -1*zmin; k--) {
        float dr = 1;
        float nx = x;
        float ny = y;
        float nz = z;
        float rad = sqrt(x*x+y*y+z*z);
        int n = 0;
        while (n < maxIterations) {
          float powRad = pow(rad, power);
          float theta = atan2(sqrt(nx*nx+ny*ny), nz)*power;
          float phi = atan2(ny, nx)*power;
          nx = sin(theta)*cos(phi)*powRad+x;
          ny = sin(theta)*sin(phi)*powRad+y;
          nz = cos(theta)*powRad+z;
          dr = dr*power*pow(rad, power-1)+1;
          rad = sqrt(nx*nx+ny*ny+nz*nz);
          if (rad > 4) break;
          n++;
        }
        if (0.5*log(rad)*rad/dr < 0.00001) {
          int pixX = i/compact;
          int pixY = j/compact;
          if (pixX > 0 && pixX < screenSize && pixY > 0 && pixY < screenSize) {
            pixVals[pixX+pixY*screenSize] += k;
            pixDivs[pixX+pixY*screenSize]++;
          }
          break;
        }
        else {
          k--;
          z += 0.5*log(rad)*rad/dr;
        }
      }
      y += toAdd;
    }
    x += toAdd;
    println((float)i/(screenSize*compact)*100+"%");
  }
  for (int i = 0; i < screenSize*screenSize; i++) {
    int val = (int)((float)pixVals[i]/pixDivs[i]);
    pixels[i] = (val<<16)+(val<<8)+val;
  }
  updatePixels();
  println("Time: "+millis());
  saveFrame("result.png");
}