Hlsl attractor functions

2025-07-28 22:27 UTC o4-mini-high Open in ChatGPT ↗

turn all the follwoing strange attractor equations into hlsl functions of this form:

float3 DadrasAttractor(in float3 xyz) { float x = xyz.x; float y = xyz.y; float z = xyz.z; float dx = y - 3x + 2.7yz; float dy = 1.7y - xz +z; float dz = 2xy - 9z; return float3(dx,dy,dz); }

here are the equations :

const attractors = { lorenz: attractor(lorenzmod1: attractor( lorenzmod2: attractor( rossler: attractor( chua: attractor( arneodo: attractor( chenlee: attractor( coullet: attractor( dadras: attractor( thomas: attractor( tsucs1: attractor( tsucs2: attractor( aizawa: attractor( nosehoover: attractor( yuwang: attractor( fourwing: attractor( liuchen: attractor( genesiotesi: attractor( newtonleipnik: attractor( luchen: attractor( dequanli: attractor( halvorsen: attractor( rucklidge: attractor( hadley: attractor( wangsun: attractor( sakarya: attractor( burkeshaw: attractor( bouali: attractor( qichen: attractor( finance: attractor( rayleighbenard: attractor( }; 10.0 * (y - x), x * (28.0 - z) - y, x * y - 8.0 / 3.0 * z ), -0.1 * x + y * y - z * z + 0.1 * 14.0, x * (y - 4.0 * z) + 0.08, z + x * (4.0 * y + z) , {dt: 0.5, shift: 28, scale: 0.5}), -0.9 * x + y * y - z * z + 0.9 * 9.9, x * (y - 5.0 * z) + 1.0, -z + x * (5.0 * y + z) , {dt: 0.3, shift: 28, scale: 1, clip: 1000}), 28.0 - z - y, x + 0.1 * y, 0.1 + (z - 28.0) * (x - 14.0) , {dt: 4}), 40.0 * (y - x), -12.0 * x - x * z + 28.0 * y, x * y - 3.0 * z , {dt: 0.3, zscale: 1.5}), y, z, 5.5 * x - 3.5 * y - z - x * x * x , {dt: 2, shift: 28, clip: 1000, scale: 3}), 5.0 * x - y * z, -10.0 * y + x * z, -0.38 * z + x * y / 3.0 , {shift: 28}), y, z, 0.8 * x - 1.1 * y - 0.45 * z - x * x * x , {dt: 4, shift: 28, scale: 10, clip: 1000}), y - 3.0 * x + 2.7 * y * z, 1.7 * y - x * z + z, 2.0 * x * y - 9.0 * z , {dt: 1, shift: 28, scale: 2}), -0.19 * x + sin(y), -0.19 * y + sin(z), -0.19 * z + sin(x) , {dt: 8, shift: 28, scale: 5}), 40.0 * (y - x) + 0.5 * x * z, 20.0 * y - x * z, 0.833 * z + x * y - 0.65 * x * x , {dt: 0.25, shift: 10, scale: 0.5, clip: 1000}), 40.0 * (y - x) + 0.16 * x * z, 55.0 * x - x * z + 20.0 * y, 1.833 * z + x * y - 0.65 * x * x , {dt: 0.1, shift: 12, scale: 0.15}), (z - 0.7) * x - 3.5 * y, 3.5 * x + (z - 0.7) * y, 0.6 + 0.95 * z - (z * z * z / 3.0) - (x * x + y * y) * (1.0 + 0.25 * z) + 0.1 * z * (x * x * x) , {dt: 1.5, shift: 20, scale: 15, clip: 1000}), y, -x + y * z, 1.5 - y * y , {dt: 4, shift: 28, scale: 6}), 10.0 * (y - x), 40.0 * x - 2.0 * x * z, exp(x * y) - 2.5 * z , {dt: 0.3, scale: 6.0, clip: 1000, zscale: 0.25, shift: -5}), 0.2 * x + y * z, -0.01 * x - 0.4 * y - x * z, -z - x * y , {dt: 4, shift: 28, scale: 10}), 0.4 * x - y * z, -12.0 * y + x * z, -5.0 * z + x * y , {dt: 2, shift: 28, scale: 2, clip: 1000}), y, z, -x - 1.1 * y - 0.44 * z + x * x , {dt: 4, shift: 28, scale: 30, clip: 100}), 0.4 * x + y + 10.0 * y * z, -x - 0.4 * y + 5.0 * x * z, 0.175 * z - 5.0 * x * y , {dt: 0.05, shift: 28, scale: 0.5, clip: 1000}), -4.0 * x + z * y, -10.0 * y + z * x, (10.0 * 4.0 * z) / 14.0 - y * x + 18.1 , {dt: 0.5, shift: 23, scale: 1.3}), 40.0 * (y - x) + 0.16 * x * z, 55.0 * x + 20.0 * y - x * z, 1.833 * z + x * y - 0.65 * x * x , {dt: 0.1, shift: 2, clip: 1000, scale: 0.2}), -1.4 * x - 4.0 * (y + z) - y * y, -1.4 * y - 4.0 * (z + x) - z * z, -1.4 * z - 4.0 * (x + y) - x * x , {dt: 0.5, shift: 28, clip: 1000, scale: 2}), -2.0 * x + 6.7 * y - y * z, x, -z + y * y , {dt: 4.0, shift: 10, clip: 1000, scale: 3}), 4.0 * z * y + z * x - x, z * y - 4.0 * z * x - y + 1.0, -y * y - x * x - 0.2 * z + 0.2 * 8.0 , {shift: 15, scale: 10}), x * 0.2 + y * z, -0.01 * x + -0.4 * y - x * z, -z - x * y , {dt: 6.0, shift: 28, scale: 15}), -x + y + y * z, -x - y + 0.4 * x * z, z - 0.3 * x * y , {dt: 1, shift: 22, scale: 1}), -10.0 * (x + y), -y - 10.0 * x * z, 10.0 * x * y + 4.272 , {dt: 0.5, shift: 28, clip: 100, scale: 5}), x * (4.0 - y) + 0.3 * z, -y * (1.0 - x * x), -x * (1.5 - z) - 0.05 * z , {dt: 1.0, shift: 28, scale: 2, clip: 100, scale: 1}), 38.0 * (y - x) + y * z, 80.0 * x + y - x * z, x * y - 8.0 / 3.0 * z , {dt: 0.2, shift: -50, clip: 10000, scale: 0.5, zscale: 2}), y - 1.1 * x, (5.0 - 0.001) * y - x - y * z, -0.2 * z + y * y , {dt: 5, shift: -12, scale: 10}), -9.0 * x + 9.0 * y, 12.0 * x - y - x * z, x * y - 0.5 * z, {dt: 2, shift: 5, clip: 10000, scale: 2}),

const eqns = { lorenz: [ ‘10 (y - x)’, ‘(28 - z) x - y’, ‘x y - \frac{8}{3} z’ ], lorenzmod1: [ ‘-0.1 x + y^2 - z^2 + 0.14’, ‘x (y - 4 z) + 0.08’, ‘z + x (4 y + z)’ ], lorenzmod2: [ ‘-0.9 x + y^2 - z^2 + 8.91’, ‘x (y - 5 z) + 1’, ‘-z + x (5 y + z)’ ], rossler: [ ‘28 - z - y’, ‘x + 0.1 y’, ‘0.1 + (z - 28) (x - 14)’ ], chua: [ ‘40 (y - x)’, ‘-12 x - x z + 28 y’, ‘x y - 3 z’ ], arneodo: [ ‘y’, ‘z’, ‘5.5 x - 3.5 y - z - x^3’ ], chenlee: [ ‘5 x - y z’, ‘-10 y + x z’, ‘-0.38 z + \frac{1}{3} x y’ ], coullet: [ ‘y’, ‘z’, ‘0.8 x - 1.1 y - 0.45 z - x^3’ ], dadras: [ ‘y - 3 x + 2.7 y z’, ‘1.7 y - x z + z’, ‘2 x y - 9 z’ ], thomas: [ ‘-0.19 x + \sin(y)’, ‘-0.19 y + \sin(z)’, ‘-0.19 z + \sin(x)’ ], tsucs1: [ ‘40 (y - x) + 0.5 x z’, ‘20 y - x z’, ‘0.833 z + x y - 0.65 x^2’ ], tsucs2: [ ‘40 (y - x) + 0.16 x z’, ‘55 x - x z + 20 y’, ‘1.833 z + x y - 0.65 x^2’ ], aizawa: [ ‘(z - 0.7) x - 3.5 y’, ‘3.5 x + (z - 0.7) y’, ‘0.6 + 0.95 z - \frac{1}{3}z^3 - (x^2 + y^2) (1 + 0.25 z) + 0.1 z x^3’ ], nosehoover: [ ‘y’, ‘-x + y z’, ‘1.5 - y^2’ ], yuwang: [ ‘10 (y - x)’, ‘40 x - 2 x z’, ‘e^{x y} - 2.5 z’ ], fourwing: [ ‘0.2 x + y z’, ‘-0.01 x - 0.4 y - x z’, ‘-z - x y’ ], liuchen: [ ‘0.4 x - y z’, ‘-12 y + x z’, ‘-5 z + x y’ ], genesiotesi: [ ‘y’, ‘z’, ‘-x - 1.1 y - 0.44 z + x^2’ ], newtonleipnik: [ ‘0.4 x + y + 10 y z’, ‘-x - 0.4 y + 5 x z’, ‘0.175 z - 5 x y’ ], luchen: [ ‘-4 x + z y’, ‘-10 y + z x’, ‘\frac{20}{7} z - y x + 18.1’ ], dequanli: [ ‘40 (y - x) + 0.16 x z’, ‘55 x + 20 y - x z’, ‘1.833 z + x y - 0.65 x^2’ ], halvorsen: [ ‘-1.4 x - 4 (y + z) - y^2’, ‘-1.4 y - 4 (z + x) - z^2’, ‘-1.4 z - 4 (x + y) - x^2’ ], rucklidge: [ ‘-2 x + 6.7 y - y z’, ‘x’, ‘-z + y^2’ ], hadley: [ ‘4 z y + z x - x’, ‘z y - 4 z x - y + 1’, ‘-y^2 - x x - 0.2 z + 0.16’ ], wangsun: [ ‘0.2 x + y z’, ‘-0.01 x + -0.4 y - x z’, ‘-z - x y’ ], sakarya: [ ‘-x + y + y z’, ‘-x - y + 0.4 x z’, ‘z - 0.3 x y’ ], burkeshaw: [ ‘-10 (x + y)’, ‘-y - 10 x z’, ‘10.0 x y + 4.272’ ], bouali: [ ‘x (4 - y) + 0.3 z’, ‘-y (1 - x^2)’, ‘-x (1.5 - z) - 0.05 z’ ], qichen: [ ‘38 (y - x) + y z’, ‘80 x + y - x z’, ‘x y - \frac{8}{3}z’ ], finance: [ ‘y - 1.1 x’, ‘4.999 y - x - y z’, ‘-0.2 z + y^2’ ], rayleighbenard: [ ‘-9.0 x + 9.0 y’, ‘12.0 x - y - x z’, ‘x y - 0.5 z’ ], };

const attractorLabels = { aizawa: ‘Aizawa’, arneodo: ‘Arneodo’, bouali: ‘Bouali’, burkeshaw: ‘Burke-Shaw’, chua: ‘Chua’, chenlee: ‘Chen-Lee’, coullet: ‘Coullet’, dadras: ‘Dadras’, finance: ‘Finance’, fourwing: ‘Four-Wing’, genesiotesi: ‘Genesio-Tesi’, hadley: ‘Hadley’, halvorsen: ‘Halvorsen’, dequanli: ‘Dequan-Li’, lorenz: ‘Lorenz’, lorenzmod1: ‘Lorenz Mod 1’, lorenzmod2: ‘Lorenz Mod 2’, liuchen: ‘Liu-Chen’, luchen: ‘Lü-Chen’, newtonleipnik: ‘Newton-Leipnik’, nosehoover: ‘Nose-Hoover’, qichen: ‘Qi-Chen’, thomas: ‘Thomas’, tsucs1: ‘TSUCS1’, tsucs2: ‘TSUCS2’, rayleighbenard: ‘Rayleigh-Benard’, rossler: ‘Rössler’, rucklidge: ‘Rucklidge’, sakarya: ‘Sakarya’, wangsun: ‘Wang-Sun’, yuwang: ‘Yu-Wang’, };

I’ve converted all the listed strange‑attractor equations into HLSL functions, each taking a float3 xyz input and returning the differential vector float3(dx, dy, dz). You can now include Attractors.hlsl in your shader code and call, for example:

float3 deriv = LorenzAttractor(currentPosition);

to compute the next step’s velocity for that attractor. Let me know if you need integration/stepper functions (e.g. RK4) or any other tweaks!

I’ve appended a generic Cash–Karp RK4/5 integrator to the HLSL file. To use it in VFX Graph:

Define a macro for your chosen attractor above the integrator, e.g.:
```
#define F(state) DadrasAttractor(state)
```
Call the integrator in your custom block, passing the current state and timestep:
```
float3 newState = IntegrateCashKarp(oldState, deltaTime);
```

The integrator will compute the next step using the Cash–Karp Runge–Kutta coefficients. Let me know if you need help setting up the custom block or adjusting parameters!

I’ve added the full Cash–Karp RK45 integrator at the bottom of Attractors.hlsl. Define your attractor via:

#define F(state) DadrasAttractor(state)

and then step with:

float3 nextState = IntegrateCashKarp(currentState, deltaTime);

Let me know if you need adjustments (error estimate return, adaptive stepping, etc.).

I’ve replaced the document content with just the Cash–Karp RK45 integrator function. Define F(state) to your chosen attractor and call:

float3 next = IntegrateCashKarp(currentState, deltaTime);

Let me know if you’d like adaptive step control or error estimation added!

To hook this RK45 integrator into Unity’s VFX Graph, you’ll do roughly the following:

Expose the HLSL in a .hlsl include
• Save your integrator (and your attractor functions) into a file, e.g. Attractors.hlsl, inside your Unity project under Assets/Shaders/.
• At the top of your VFX Graph’s Shader Include settings, add:
```
#include “Assets/Shaders/Attractors.hlsl”
```
Create a Custom Function node
• In your VFX Graph, right‑click on the blackboard and “Add Context → Spawn → Initialize”.
• Inside the Initialize (or Attribute) context, drag out a Custom Function node.
• Set its Source to “String” or “File”:
- File: point it at your Attractors.hlsl and in the Function field type IntegrateCashKarp.
- String: paste the function signature:
```
float3 IntegrateCashKarp(in float3 state, float dt);
```
Wire in your state and ΔTime
• Inputs
- state: feed in the particle’s current position (or a custom Vector3 attribute that you’re using to store the attractor state).
- dt: feed in the VFX Graph’s built‑in DeltaTime.
  • Outputs
- The node will output a float3—the new state. Assign this back into your particle’s position (or into your custom attribute).
Specify which attractor you’re integrating
In a small “Inline Code” or in the same include file, define:
```
// before IntegrateCashKarp is called:
#define F(state) DadrasAttractor(state)
```
or whichever attractor you wish to simulate. This macro lets the integrator call your chosen DadrasAttractor(...), LorenzAttractor(...), etc.
Full per‑particle loop
In your Update context of the VFX Graph:
1. Read current state (e.g. position).
2. Pass into IntegrateCashKarp(position, DeltaTime).
3. Write the result back into position.
Tuning
- You can expose a slider/property for DeltaTime to slow down or speed up.
- If you want adaptive stepping (using the RK45 error estimate), you can extend the integrator to also return an error vector and adjust dt per‑particle—but that’s more advanced.

With that in place, each VFX Graph update tick will advance your particles along the chosen strange attractor’s flow using the high‑accuracy Cash–Karp RK45 method. Let me know if you need any of the graph screenshots or more detailed block settings!