Inflector Gadget v0.10 released, with bugfixes to the perturbation implementation (thanks FractalLion) and support for variable wavyness everywhere:
source tarball and windows binaries available here:
https://mathr.co.uk/web/inflector-gadget.html#v010
web version available here:
example:
#InflectorGadget #MandelbrotSet #JuliaSet #Fractals #MathArt
DecemberAdventure 11th
some small experiment with buddhabrot style rendering of hopfbrot, nothing impressive due to curse of dimensionality
DecemberAdventure 12th
no code today
DecemberAdventure 13th
I fixed the perturbation code in inflector-gadget - now uses 1 reference per inflection point and 1 extra for image center. hopefully correct rendering in more circumstances now. thanks to FractalLion on fractalforums.org for the push and a test case (which previously failed, now works).
also added variable wave support to the inflected renderer, which changes appearance of old parameters (so another url update coming for the web version so as not to break existing links; will need to minor update the old versions to have options to fwd to the new).
new release coming very soon, testing appreciated especially within the next 24 hours:
git clone https : / / code.mathr.co.uk / inflector-gadget.git
and check the README.md for build instructions
Inflector Gadget 0.9 is released!
https://mathr.co.uk/web/inflector-gadget.html
The most visible change since 0.8 (among many) is a version for Web built with Emscripten. Also: wavy hybrid Julia sets.
Try it online:
Get source code and binaries for Windows and Web here:
https://mathr.co.uk/web/inflector-gadget.html#Download
#InflectorGadget #MandelbrotSet #JuliaSet #fractals #MathArt
recent #InflectorGadget updates (at home WIP, not hosted anywhere yet):
✅ fixed 8MB/render terrible memory leak in perturbation code
✅ fixed crash when parsing TOML fails (unhandled syntax error exception)
✅ minimal full-window canvas instead of the default Emscripten code
✅ copy/paste to/from system clipboard works in web version via ugly hacks (intercept Ctrl-V before it gets to SDL2; probably fails on systems that use a different shortcut)
✅ refactored shaders to avoid so much copy/paste duplication
✅ use Emscripten's libpng port
✅ use GLAD instead of GLEW to load OpenGL functions
#InflectorGadget desktop v0.7 released
inflection mapping gadget for complex quadratic polynomials, for making #MathArt #fractals #patterns
download source tarball and Windows binaries:
https://mathr.co.uk/web/inflector-gadget.html#Download
latest updates in repository as ever:
```
git clone https : / / code.mathr.co.uk / inflector-gadget.git
```
(remove the spaces, added to prevent fediverse clients obscuring full link text)
highlights of new features:
ssbo: use buffers for large data to try to avoid "too many registers" shader compiler crash
quantize: snap inflection points to node centers, toggle with Q key
one-shot: add --output=myfile.png to the command line to render, save and exit
exray out: hover over Julia set and press X to trace ray, digits printed to terminal (probably doesn't work on Windows)
crosshair: show next inflection in undo/redo
a second working example means it seems it's true: but having to tune the escape to zero radius is annoying: this one used 0.03
#InflectorGadget #maths actually seems to work with a different colouring algorithm. not sure if real or coincidence...
```glsl
#version 300 es
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
out vec4 fragColor;
uniform vec2 resolution;
vec2 cSqr(vec2 z)
{
return vec2(z.x * z.x - z.y * z.y, 2.0 * z.x * z.y);
}
void main(void) {
vec2 z = (gl_FragCoord.xy - resolution.xy * 0.5) / resolution.x * 4.0;
vec2 c[2];
c[0] = vec2(-0.9237192701539101, 0);
c[1] = vec2(-0.8931031149745472, 0);
float m = length(z);
for (int i = 0; i < 1024; ++i)
{
float mz = length(z);
if (mz < m) m = mz;
if (mz > 25.0 || mz < 0.001)
{
break;
}
z = cSqr(z) + c[i & 1];
}
fragColor = vec4(vec3(m < 0.11), 1);
}
```
thinking about #InflectorGadget #maths - in the limit of a regular pattern of N quadratic inflections repeated forever, i think the inflection points converge to a limit cycle. what would happen if you skip all the buildup and jumped straight into the limit cycle repeated forever (or until pixel escapes)?
I'm guessing it might look like the Julia set for a particular degree 2^N polynomial whose coefficients depend on the limit cycle of inflection points.
if it looks the same as the original pattern of inflections, or close enough, that would be amazing: I do wonder how much precision would be required though?
claude
