I've had a number of ideas over the past couple months regarding variations on the Buddhabrot.

I don't have a ton of time today to go over the finer points of exactly how each of these work, but they all relate to a common concept: What does it look like as each complex point moves linearly between each of its iterations?

Naming:

If this is in fact a new idea I kind've like the term "Projectilebrot", with each of my current examples being under the sub-category of "Linear Projectilebrot".

Other ideas:

"Particlebrot" (I really like this one, but feel like it should be reserved for something else.)

"Trajectorybrot" (Unweildy.)

"Laserbrot" (Only works if the movement is linear, and although all of my implementations are linear, they don't have to be.)

For the time being, all implementations that involve drawing lines will be called "Laserbrots", and animations showing step-by-step movement are called "Particlebrots".

Explanations:

Particlebrot (animation-exclusive): Move all points ([frame #]/[#of frames])% of the way to their destination each frame.

I have evidence that this isn't an entirely original idea. I recently found someone who had done something like this before, but they used non-linear movement.

https://www.youtube.com/watch?v=yH9QZ_c3R3QLaserbrot: For each iteration, imagine drawing a line between \( Z_{n} \) and \( Z_n+1 \). For each bucket the line passes through, calculate the distance the line travels through that particular bucket and add that distance to that bucket.

Riemann Laserbrot: Construct a sphere from voxels. The voxels will act as our buckets. Convert your \( Z_{n} \) and \( Z_n+1 \) coordinates to coordinates on the Riemann sphere. Imagine drawing a line between each point DIRECTLY THROUGH the sphere. For each voxel-bucket the line passes through, calculate the distance the line travels through that particular voxel-bucket and add that distance to that voxel-bucket.

Examples:

Note All of my implementations are still a little buggy. Also, I only very recently added the ability for my program to distinguish between Normal and Anti-Buddhabrots, so most of these examples are Normal+Anti.

(Attached) Laserbrot (Normal + Anti) - Kinda looks like Buddha's rib cage.

Particlebrot (Normal + Anti) - This is one I created early on. I have since made a change to the algorithm that fades in the first iteration and fades out the last one, which makes the animation loop smoother. There's still a bug with it, so it doesn't work as intended all the time.

Riemann Anti-Laserbrot - I just completed this last night. This animation cycles through the XY, ZY, and ZX cross-sections of the sphere. The next thing I want to do is render the whole thing in 3D (See Future Ideas).

Other Examples:

Particlebrot (Not a Mandelbrot, will add equation later.) (Normal + Anti) - This is my favorite Particlebrot.

https://media.giphy.com/media/oNTKF9FfzGJOXxrRH0/giphy.gifLaserbrot Animation (Not a Mandelbrot, will add equation later.) (Normal + Anti) - Cycling through a series of Julias.

https://media.giphy.com/media/1lyN7GySu1FwP6nDs6/giphy.gifFuture ideas not yet implemented:

The Riemann Laserbrot is incomplete. I want to render it in 3D, but on top of that I have a few ideas regarding some rendering effects.

1. Normal render.

2. Value-based opacity. All voxels are white, but their opacity is based on their value.

3. Perspective-based brightness. Recompute the brightness of each pixel based on the angle you're looking at the sphere, adding the obscured voxels values to the values of the voxels in front of them.

I'd also like to do the same thing with plain-old Buddhabrots on the Riemann Sphere. Also, I'd like to make an iteration-layer based version of the Buddhabrot on the Riemann Sphere, just like I've done before with fractals:

https://media.giphy.com/media/xUA7b2tiISfH8Jw47K/giphy.gifI'd also like to explore more non-linear movements. After all, \( {Z_{n}}^2+C \) is a rotation and then a translation (or vice-versa). Showing how those two ideas work together could also result in something cool.

Final note:

I wrote this all in a 2.5-hour rush so I know I missed something or could have explained something better (Like why would fading in the first and fading out the last iteration on a Particlebrot make an animation loop more smoothly?). I also want to add some more examples that I either don't have rendered or don't have good renders of.