goldy 0.1.0

Goldy - Modern Graphics Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

# Plasma Effect

Classic demoscene plasma effect using fragment shaders.

## Run It

```bash
cargo run --example plasma --release
```

## What It Demonstrates

- Custom fragment shader
- Time-based animation
- Passing time to shader via vertex attributes
- Mathematical functions in WGSL

## The Shader

The plasma effect is entirely computed in the fragment shader:

```wgsl
@fragment
fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
    let uv = in.uv * 4.0;
    let t = in.time;
    
    // Classic plasma formula
    var v = sin(uv.x + t);
    v += sin(uv.y + t);
    v += sin(uv.x + uv.y + t);
    
    // Circular wave
    let cx = uv.x + 0.5 * sin(t / 3.0);
    let cy = uv.y + 0.5 * cos(t / 2.0);
    v += sin(sqrt(cx * cx + cy * cy + 1.0) + t);
    
    v = v / 2.0;
    
    // Color palette using phase-shifted sines
    let r = sin(v * 3.14159);
    let g = sin(v * 3.14159 + 2.094);  // +120°
    let b = sin(v * 3.14159 + 4.188);  // +240°
    
    return vec4<f32>(r * 0.5 + 0.5, g * 0.5 + 0.5, b * 0.5 + 0.5, 1.0);
}
```

## Key Techniques

### Passing Time to Shader

Without uniform buffers, we pass time through vertex attributes:

```rust
#[repr(C)]
struct PlasmaVertex {
    position: [f32; 2],
    uv: [f32; 2],
    time: f32,  // Same value for all vertices
}

fn create_quad(time: f32) -> [PlasmaVertex; 6] {
    [
        PlasmaVertex { position: [-1.0, -1.0], uv: [0.0, 1.0], time },
        PlasmaVertex { position: [1.0, -1.0], uv: [1.0, 1.0], time },
        // ...
    ]
}
```

### Full-Screen Quad

The plasma covers the entire screen using a quad from (-1,-1) to (1,1):

```rust
fn create_quad(time: f32) -> [PlasmaVertex; 6] {
    [
        PlasmaVertex { position: [-1.0, -1.0], uv: [0.0, 1.0], time },
        PlasmaVertex { position: [1.0, -1.0], uv: [1.0, 1.0], time },
        PlasmaVertex { position: [1.0, 1.0], uv: [1.0, 0.0], time },
        PlasmaVertex { position: [-1.0, -1.0], uv: [0.0, 1.0], time },
        PlasmaVertex { position: [1.0, 1.0], uv: [1.0, 0.0], time },
        PlasmaVertex { position: [-1.0, 1.0], uv: [0.0, 0.0], time },
    ]
}
```

### Color Cycling

The rainbow effect comes from phase-shifted sine waves:
- Red: `sin(v * π)`
- Green: `sin(v * π + 120°)`
- Blue: `sin(v * π + 240°)`

This creates smooth color transitions through the spectrum.

## Variations

### Different Plasma Formulas

```wgsl
// Interference pattern
v = sin(uv.x * 10.0) + sin(uv.y * 10.0);

// Spiral
let angle = atan2(uv.y - 0.5, uv.x - 0.5);
let dist = length(uv - 0.5);
v = sin(angle * 5.0 + dist * 10.0 + t);

// Ripples
v = sin(length(uv - 0.5) * 20.0 - t * 5.0);
```

### Different Color Palettes

```wgsl
// Fire palette
let r = v;
let g = v * v;
let b = v * v * v;

// Ocean palette
let r = 0.0;
let g = v * 0.5;
let b = 0.5 + v * 0.5;
```

## Full Source

See `goldy/examples/plasma.rs` for the complete code.