265 lines
No EOL
7.7 KiB
Zig
265 lines
No EOL
7.7 KiB
Zig
const std = @import("std");
|
|
const print = std.debug.print;
|
|
const SoundNode = @import("soundnode.zig").SoundNode;
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
|
|
pub const Pin = struct {
|
|
|
|
allocator: Allocator,
|
|
|
|
src_node: *SoundNode,
|
|
trg_node: *SoundNode,
|
|
|
|
src_pin: usize = 0,
|
|
trg_pin: usize = 0,
|
|
|
|
active: u8 = 0,
|
|
|
|
pub fn create(allocator: Allocator,
|
|
src_node: *SoundNode,
|
|
trg_node: *SoundNode,
|
|
src_pin: usize,
|
|
trg_pin: usize) !*Pin {
|
|
|
|
const pin = try allocator.create(Pin);
|
|
|
|
pin.* = .{
|
|
.allocator = allocator,
|
|
.src_node = src_node,
|
|
.trg_node = trg_node,
|
|
.src_pin = src_pin,
|
|
.trg_pin = trg_pin,
|
|
.active = 0,
|
|
};
|
|
|
|
return pin;
|
|
}
|
|
|
|
pub fn propagate(self: *Pin) void {
|
|
|
|
switch (self.src_pin) {
|
|
|
|
0 => {
|
|
switch (self.trg_pin) {
|
|
0 => {self.trg_node.in_wire += self.src_node.r_amp; },
|
|
1 => {
|
|
const current_tick = self.src_node.fab.current_tick;
|
|
|
|
const dist: f64 = self.trg_node.distance(self.src_node);
|
|
var b_sample_tick: u32 = 0;
|
|
var n_sample_tick: u32 = 0;
|
|
const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
|
|
|
|
if (tck > 0) {
|
|
|
|
b_sample_tick = @intFromFloat( @floor(tck) );
|
|
n_sample_tick = b_sample_tick + 1;
|
|
|
|
const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
|
|
|
|
const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
|
|
const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
|
|
|
|
const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
|
|
const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
|
|
|
|
self.trg_node.in_air += relayed_r_amp;
|
|
}
|
|
|
|
},
|
|
6 => {self.trg_node.in6 += self.src_node.r_amp; },
|
|
7 => {self.trg_node.in7 += self.src_node.r_amp; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
1 => {
|
|
switch (self.trg_pin) {
|
|
0 => {self.trg_node.in_wire += self.src_node.out1; },
|
|
1 => {
|
|
const current_tick = self.src_node.fab.current_tick;
|
|
const dist: f64 = self.trg_node.distance(self.src_node);
|
|
var b_sample_tick: u32 = 0;
|
|
var n_sample_tick: u32 = 0;
|
|
const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
|
|
|
|
if (tck > 0) {
|
|
|
|
b_sample_tick = @intFromFloat( @floor(tck) );
|
|
n_sample_tick = b_sample_tick + 1;
|
|
|
|
const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
|
|
|
|
const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
|
|
const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
|
|
|
|
const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
|
|
const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
|
|
|
|
self.trg_node.in_air += relayed_r_amp;
|
|
}
|
|
|
|
},
|
|
6 => {self.trg_node.in6 += self.src_node.out1; },
|
|
7 => {self.trg_node.in7 += self.src_node.out1; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
6 => {
|
|
switch (self.trg_pin) {
|
|
0 => {self.trg_node.in_wire += self.src_node.out6; },
|
|
1 => {
|
|
const current_tick = self.src_node.fab.current_tick;
|
|
const dist: f64 = self.trg_node.distance(self.src_node);
|
|
var b_sample_tick: u32 = 0;
|
|
var n_sample_tick: u32 = 0;
|
|
const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
|
|
|
|
if (tck > 0) {
|
|
|
|
b_sample_tick = @intFromFloat( @floor(tck) );
|
|
n_sample_tick = b_sample_tick + 1;
|
|
|
|
const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
|
|
|
|
const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
|
|
const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
|
|
|
|
const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
|
|
const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
|
|
|
|
self.trg_node.in_air += relayed_r_amp;
|
|
}
|
|
|
|
},
|
|
6 => {self.trg_node.in6 += self.src_node.out6; },
|
|
7 => {self.trg_node.in7 += self.src_node.out6; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
7 => {
|
|
switch (self.trg_pin) {
|
|
0 => {self.trg_node.in_wire += self.src_node.out7; },
|
|
1 => {
|
|
const current_tick = self.src_node.fab.current_tick;
|
|
const dist: f64 = self.trg_node.distance(self.src_node);
|
|
var b_sample_tick: u32 = 0;
|
|
var n_sample_tick: u32 = 0;
|
|
const tck = @as(f64, @floatFromInt(current_tick)) - (128.571428 * dist);
|
|
|
|
if (tck > 0) {
|
|
|
|
b_sample_tick = @intFromFloat( @floor(tck) );
|
|
n_sample_tick = b_sample_tick + 1;
|
|
|
|
const attenuation: f64 = @as(f64, std.math.exp(-(dist / 100.0)));
|
|
|
|
const b_r_amp = self.src_node.fab.get_r_amp(b_sample_tick);
|
|
const n_r_amp = self.src_node.fab.get_r_amp(n_sample_tick);
|
|
|
|
const tick_diff = tck - @as(f64, @floatFromInt(b_sample_tick));
|
|
const relayed_r_amp = (b_r_amp + (tick_diff * (n_r_amp - b_r_amp))) * attenuation;
|
|
|
|
self.trg_node.in_air += relayed_r_amp;
|
|
}
|
|
|
|
},
|
|
6 => {self.trg_node.in6 += self.src_node.out7; },
|
|
7 => {self.trg_node.in7 += self.src_node.out7; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
2 => {
|
|
switch (self.trg_pin) {
|
|
2 => {self.trg_node.in_gain += self.src_node.gain; },
|
|
3 => {self.trg_node.in_basephase += self.src_node.gain; },
|
|
4 => {self.trg_node.in_phase += self.src_node.gain; },
|
|
8 => {self.trg_node.in8 += self.src_node.gain; },
|
|
9 => {self.trg_node.in9 += self.src_node.gain; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
3 => {
|
|
switch (self.trg_pin) {
|
|
2 => {self.trg_node.in_gain += self.src_node.basephase; },
|
|
3 => {self.trg_node.in_basephase += self.src_node.basephase; },
|
|
4 => {self.trg_node.in_phase += self.src_node.basephase; },
|
|
8 => {self.trg_node.in8 += self.src_node.basephase; },
|
|
9 => {self.trg_node.in9 += self.src_node.basephase; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
4 => {
|
|
switch (self.trg_pin) {
|
|
2 => {self.trg_node.in_gain += self.src_node.phase; },
|
|
3 => {self.trg_node.in_basephase += self.src_node.phase; },
|
|
4 => {self.trg_node.in_phase += self.src_node.phase; },
|
|
8 => {self.trg_node.in8 += self.src_node.phase; },
|
|
9 => {self.trg_node.in9 += self.src_node.phase; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
8 => {
|
|
switch (self.trg_pin) {
|
|
2 => {self.trg_node.in_gain += self.src_node.out8; },
|
|
3 => {self.trg_node.in_basephase += self.src_node.out8; },
|
|
4 => {self.trg_node.in_phase += self.src_node.out8; },
|
|
8 => {self.trg_node.in8 += self.src_node.out8; },
|
|
9 => {self.trg_node.in9 += self.src_node.out8; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
9 => {
|
|
switch (self.trg_pin) {
|
|
2 => {self.trg_node.in_gain += self.src_node.out9; },
|
|
3 => {self.trg_node.in_basephase += self.src_node.out9; },
|
|
4 => {self.trg_node.in_phase += self.src_node.out9; },
|
|
8 => {self.trg_node.in8 += self.src_node.out9; },
|
|
9 => {self.trg_node.in9 += self.src_node.out9; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
|
|
5 => {
|
|
switch (self.trg_pin) {
|
|
5 => {self.trg_node.in_basefreq += self.src_node.basefreq; },
|
|
10 => {self.trg_node.in10 += self.src_node.basefreq; },
|
|
11 => {self.trg_node.in11 += self.src_node.basefreq; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
10 => {
|
|
switch (self.trg_pin) {
|
|
5 => {self.trg_node.in_basefreq += self.src_node.out10; },
|
|
10 => {self.trg_node.in10 += self.src_node.out10; },
|
|
11 => {self.trg_node.in11 += self.src_node.out10; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
11 => {
|
|
switch (self.trg_pin) {
|
|
5 => {self.trg_node.in_basefreq += self.src_node.out11; },
|
|
10 => {self.trg_node.in10 += self.src_node.out11; },
|
|
11 => {self.trg_node.in11 += self.src_node.out11; },
|
|
else => {},
|
|
}
|
|
},
|
|
|
|
else => {},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}; |