Recent Posts

Pages: [1] 2 3 ... 10
Share a fractal / fediverse instance sizes
« Last post by claude on Today at 01:00:09 AM »
The fediverse is a collection of intercommunicating ("federated") social networks.  There is some discourse about too much centralization, with a few big instances dominating (I read an article that claimed the largest 3 had more than 1/2 the total users).  I analysed some data from  and found the instance size is quite close to a power law distribution, very approximately:
\[ active\_users = 30000 rank^{-1.3} \]
where rank=1 is the largest instance

data from: (with my API token, retrieved tonight)

piped through:
Code: [Select]
tr "," "\n" |
grep active_users |
sed "s/.*://g" |
sed "s/}.*//g" |
sort -nr |
grep -v null > instances.dat

log-log plotted with gnuplot, the line of fit is guesstimated by hand because I still haven't figured out how to get gnuplot to do loglog curve fitting with (in?)appropriate weighting of data
Mandelbulb Maniacs / Re: Render Farm for Mandelbulb 3d?
« Last post by WAUthethird on Today at 12:56:22 AM »
you can take a look at this:

The question was for Mandelbulb3D, not Mandelbulber, but cool stuff anyways.

You may be able to request that MB3D be used when reserving renderfarm time for certain renderfarms, which has been done in the past. Keep in mind, though, that requests like these may make it even more expensive to render.
Color Snippets / Method for introducing new vec3 color options
« Last post by mclarekin on Today at 12:55:23 AM »
Method for adding new vec3 color (sabine62 baseColor hack)

//tell FragM to use custom colours
#define providesColor 

 //add required uniforms to the Coloring-tab
#group Coloring

Code: [Select]
#group Coloring                                         
//multiplier for the division
uniform vec3 LVI; slider[(-1,-1,-1),(0,0,0),(1,1,1)]       
//added to LLI to give more possibilities
uniform vec3 LVI2; slider[(-1,-1,-1),(0,0,0),(1,1,1)]     
//determines for how many iterations the difference between the vectors should be calculated
uniform int LightIter; slider[0,1,100]                     
//choose between lightold/lightnew or lightnew/lightold
uniform bool RevertDiv; checkbox[false]                     
//in some cases/formulas I found it beneficial to add this
uniform bool AddOrbitStrength; checkbox[false]
//previous vector         
vec3 lightold;
 //current vector                                             
vec3 lightnew;

// add in code to extract values required to generate color
Code: [Select]
vec3 pos = z;
lightold=z;                                 //initialize lightold, necessary in some formulas
float DF = 1.0;

for (int i = 0; i < Box_Iterations ; i++)
if (i<LightIter) {lightold=z;} else {lightold=lightold;};        //get old vector, stop at LightIter-value = clamp(, -fold, fold)*2. -;
float r =dot2(z);
if (r< 0.001 || r> 1000.) break;
DF/= r;
z+=(Julia ? JuliaC : pos);
if (i<LightIter) {lightnew=z;} else {lightnew=lightnew;};            //get new vector, stop at LightIter-value
// Use vec3 baseColor to introduce the new color   

Code: [Select]
vec3 baseColor(vec3 p, vec3 q){
  if (RevertDiv) {q=abs(lightnew/lightold);} else {q=abs(lightold/lightnew);};
if (AddOrbitStrength) q+=OrbitStrength;
   return q;
Programming / Re: Endless Mandelbrot zoom
« Last post by claude on Yesterday at 11:01:42 PM »
None of these are truly endless, but you may be interested in these that can go pretty deep using perturbation techniques: Java, the original (cross-platform) C++, the all-rounder (Windows, WINE) Java, C++, Assembly, the fastest (Windows) Haskell that generates C, an experimental project of mine that is my current focus (*nix)

of historical interest only: C, an experimental project of mine that is mostly abandoned by now (*nix) C/C++, GLSL, an experimental project of mine that is abandoned since years (*nix) C++, OpenCL, an experimental project of mine that is abandoned since years (*nix)

I heard UltraFractal can now do deep zooms with perturbation too, but I don't have a license and it's not open source.

Here's an "endless" one, rendered with FragM: C++, GLSL
Image Threads / Re: Wheels
« Last post by pauldelbrot on Yesterday at 10:18:31 PM »
Spring Growth
Programming / Endless Mandelbrot zoom
« Last post by cveld on Yesterday at 10:04:50 PM »
Dear community,

I am looking for a source code example of an endless zoom engine. Can someone help me? Ideally in c#.

Regards, Carl
Thank you claude  for all the time you spend on this
It is very much apreciated by all FragM fans  :yes:
Alternatively it might be possible to `setenv()` from within FragM before initialisation of the GUI, which might just "make it work"
The issue as I understand it is to do with Qt's display widget and OpenGL profiles.

FragM requests a "compatibility" profile context, but Mesa only provides OpenGL 3 in compatibility profile, requiring "core" profile to use OpenGL 4.  Core profile removes a lot of stuff from the API, which would require rewriting a whole bunch of stuff (including the shaders, and there are loads of shaders out there in the wild that might not work any longer), which makes this not a serious option for FragM, at least in the short term.

FragM crashes because it has an OpenGL 3 compatibility context when it was hoping for an OpenGL 4 compatibility context, which means that some function pointers are null - AFAICT this happens inside Qt code when it initialises the display widget, so there's not much FragM can do about it.  There are some issues with Qt maybe requiring OpenGL version to be specified at compile time (via C++ inheritance ?), which adds to the pain.  There might be a workaround, I'll try to research this too.

But what I'm thinking of doing for the short term is adding a `signal()` handler for SIGSEGV (segmentation fault) that would print out a short message saying "oh no! maybe bad OpenGL version, see this page for possible solutions: URL GOES HERE" before aborting, and remove the signal handler after successful initialisation so that debugging with gdb is still possible.  This would be for Linux (and maybe OS X) only, Windows is a bit different.  Alternatively it might be possible to `setenv()` from within FragM before initialisation of the GUI, which might just "make it work", but would need a command line flag to turn it off for debugging, and is a grotesque hack all around...
Here I have Debian Buster GNU/Linux, AMD RX580, amdgpu.dc=0 kernel option (otherwise my display is not detected).  FragM works provided I set an environment variable to make Mesa lie about its capabilities when launching it, I use this script because I also get some weird issues if the current working directory is not set to the FragM directory:

Code: [Select]
pushd $HOME/opt/fragm/Fragmentarium-2.5.0
./Fragmentarium-2.5.0 "$@"

without the OVERRIDE I get a segmentation fault at startup; maybe I'll look into a way for FragM to print a better error message with a link to a forum thread or wiki page with troubleshooting information.

This override also works with Debian Buster on NVIDIA G105M laptop (ancient, doesn't support OpenGL 4 for sure) with the Free/Libre nouveau driver.  Just don't try to actually use the missing features like double precision.

YESSSSS !  :thumbs: :))

That was driving me NUTZ ! Anything for the Fractals, eh ?

So I suppose the next thing is to find out why your version string is needed at all ?

BTW this was using the latest build pulled from Github on Kubuntu with the AMD drivers. In fact I do not have the very latest AMD driver installed so should probably try that as well. I also turned off both the Nvidia extension and OpenEXR at build time, but I don't know if that helped or not.
Pages: [1] 2 3 ... 10