rahix
/
visualizer-ggparty-2019
1
0
Fork 0
Code Issues Releases Activity

Import into git

Browse Source
main
rahix 7 years ago
commit 8d9498939f
16 changed files with 2848 additions and 0 deletions
Show Stats Download Patch File Download Diff File

2
.gitignore vendored
Unescape View File

@ -0,0 +1,2 @@
/target
**/*.rs.bk

1858
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

21
Cargo.toml
Unescape View File

@ -0,0 +1,21 @@
[package]
authors = ["Rahix <rahix@rahix.de>"]
edition = "2018"
name = "ggparty-2019"
version = "0.1.0"
[dependencies]
glium = "0.22.0"
image = "0.20.1"
log = "0.4.6"
nalgebra = "0.16.9"
rand = "0.6.0-pre.1"
ezconf = "0.3.0"
[dependencies.vis-core]
git = "https://github.com/Rahix/visualizer2"
rev = "a237bb423e3a278a29a25649a7274d3430815596"
features = ["cpalrecord", "pulseaudio"]
[profile.release]
debug=1

12
colorconv.py
Unescape View File

@ -0,0 +1,12 @@
import sys
import math
def hex2flt(h: str):
c_u8 = [int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)]
c_flt = [x / 255 for x in c_u8]
c_srgb = [x**2 for x in c_flt]
c_str = ", ".join(f"{x:7.5f}" for x in c_srgb)
print(f"[{c_str}]")
if __name__ == "__main__":
hex2flt(sys.argv[1])

BIN
src/logo.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.7 KiB

651
src/main.rs
Unescape View File

@ -0,0 +1,651 @@
#[macro_use]
extern crate log;
#[macro_use]
extern crate glium;
extern crate nalgebra as na;
use glium::glutin;
use vis_core::analyzer;
macro_rules! shader_program {
// {{{
($display:expr, $vert_file:expr, $frag_file:expr) => {{
// Use this for debug
#[cfg(debug_assertions)]
{
let vert_src = {
use std::io::Read;
let mut buf = String::new();
let mut f = std::fs::File::open(format!("src/{}", $vert_file)).unwrap();
f.read_to_string(&mut buf).unwrap();
buf
};
let frag_src = {
use std::io::Read;
let mut buf = String::new();
let mut f = std::fs::File::open(format!("src/{}", $frag_file)).unwrap();
f.read_to_string(&mut buf).unwrap();
buf
};
glium::Program::from_source($display, &vert_src, &frag_src, None).unwrap()
}
// Use this for release
#[cfg(not(debug_assertions))]
glium::Program::from_source(
$display,
include_str!($vert_file),
include_str!($frag_file),
None,
)
.unwrap()
}};
} // }}}
#[derive(Copy, Clone)]
struct Vertex {
position: [f32; 4],
color_id: u16,
}
glium::implement_vertex!(Vertex, position, color_id);
#[derive(Debug, Clone)]
pub struct VisInfo {
beat: u64,
beat_volume: f32,
volume: f32,
analyzer: analyzer::FourierAnalyzer,
spectrum: analyzer::Spectrum<Vec<f32>>,
}
fn main() {
#[cfg(debug_assertions)]
vis_core::default_config();
#[cfg(not(debug_assertions))]
vis_core::CONFIG.init(
[ezconf::Source::Memory(include_str!("../visualizer.toml"))].iter()
).unwrap();
vis_core::default_log();
let mut frames = {
// Analyzer {{{
let mut beat = analyzer::BeatBuilder::new().build();
let mut beat_num = 0;
let analyzer = analyzer::FourierBuilder::new().plan();
vis_core::Visualizer::new(
VisInfo {
beat: 0,
beat_volume: 0.0,
volume: 0.0,
spectrum: analyzer::Spectrum::new(vec![0.0; analyzer.buckets()], 0.0, 1.0),
analyzer,
},
move |info, samples| {
if beat.detect(&samples) {
beat_num += 1;
}
info.beat = beat_num;
info.beat_volume = beat.last_volume();
info.volume = samples.volume(0.3);
info.analyzer.analyze(&samples);
info.spectrum.fill_from(&info.analyzer.average());
info
},
)
.async_analyzer(vis_core::CONFIG.get_or("audio.conversions", 300))
.frames()
// }}}
};
// Config {{{
// Window
let window_width = vis_core::CONFIG.get_or("window.width", 1280);
let window_height = vis_core::CONFIG.get_or("window.height", 720);
let aspect = window_width as f32 / window_height as f32;
// Columns
let rows = vis_core::CONFIG.get_or("noa.cols.rows", 50);
let cols = vis_core::CONFIG.get_or("noa.cols.num", 30);
let nrow = cols * 4;
let cols_per_note = vis_core::CONFIG.get_or("noa.cols.note_width", 6);
let notes_num = cols * 2 / cols_per_note;
let width = vis_core::CONFIG.get_or("noa.cols.width", 10.0);
let depth = vis_core::CONFIG.get_or("noa.cols.depth", 30.0);
let rowsize = depth / rows as f32;
let mid_dist = vis_core::CONFIG.get_or("noa.cols.mid_dist", 0.1);
let base_height = vis_core::CONFIG.get_or("noa.cols.base_height", 0.2);
let base_speed = vis_core::CONFIG.get_or("noa.cols.speed", 0.1);
let slowdown = vis_core::CONFIG.get_or("noa.cols.slowdown", 0.995);
let speed_deviation = vis_core::CONFIG.get_or("noa.cols.speed_deviation", 50.0);
let ampli_top = vis_core::CONFIG.get_or("noa.cols.amp_top", 0.7);
let ampli_bottom = vis_core::CONFIG.get_or("noa.cols.amp_bottom", 0.2);
let frame_time =
std::time::Duration::from_micros(1000000 / vis_core::CONFIG.get_or("noa.fps", 30));
// Colors
let colors: Vec<[f32; 4]> = vis_core::CONFIG.get_or(
"noa.cols.colors",
vec![
[0.30142, 0.01884, 0.00886, 1.0],
[0.13589, 0.30142, 0.17280, 1.0],
[0.28444, 0.42378, 0.13589, 1.0],
[0.56103, 0.49275, 0.12457, 1.0],
[0.90064, 0.59079, 0.12457, 1.0],
[0.90064, 0.59079, 0.12457, 1.0],
[0.56103, 0.49275, 0.12457, 1.0],
[0.28444, 0.42378, 0.13589, 1.0],
[0.13589, 0.30142, 0.17280, 1.0],
[0.30142, 0.01884, 0.00886, 1.0],
],
);
let note_roll_size = vis_core::CONFIG.get_or("noa.cols.note_roll", 20) as f32;
// Camera
let cam_height = vis_core::CONFIG.get_or("noa.camera.height", 1.0);
let cam_look = vis_core::CONFIG.get_or("noa.camera.look_height", 0.8);
// }}}
// Window Initialization {{{
let mut events_loop = glutin::EventsLoop::new();
let window = glutin::WindowBuilder::new()
.with_dimensions(glutin::dpi::LogicalSize::new(
window_width as f64,
window_height as f64,
))
.with_maximized(true)
.with_decorations(false)
.with_fullscreen(Some(events_loop.get_primary_monitor()))
.with_title("Visualizer2 - NoAmbition");
let context = glutin::ContextBuilder::new()
.with_gl(glutin::GlRequest::Specific(glutin::Api::OpenGl, (4, 1)))
.with_gl_profile(glutin::GlProfile::Core)
.with_multisampling(0);
let display = glium::Display::new(window, context, &events_loop).unwrap();
// }}}
// Framebuffer Initialization {{{
let tex1 = glium::texture::Texture2d::empty_with_format(
&display,
glium::texture::UncompressedFloatFormat::F32F32F32F32,
glium::texture::MipmapsOption::NoMipmap,
window_width,
window_height,
)
.unwrap();
let depth1 = glium::texture::DepthTexture2d::empty_with_format(
&display,
glium::texture::DepthFormat::F32,
glium::texture::MipmapsOption::NoMipmap,
window_width,
window_height,
)
.unwrap();
let mut framebuffer1 =
glium::framebuffer::SimpleFrameBuffer::with_depth_buffer(&display, &tex1, &depth1).unwrap();
let tex2 = glium::texture::Texture2d::empty_with_format(
&display,
glium::texture::UncompressedFloatFormat::F32F32F32F32,
glium::texture::MipmapsOption::NoMipmap,
window_width,
window_height,
)
.unwrap();
let depth2 = glium::texture::DepthTexture2d::empty_with_format(
&display,
glium::texture::DepthFormat::F32,
glium::texture::MipmapsOption::NoMipmap,
window_width,
window_height,
)
.unwrap();
let mut framebuffer2 =
glium::framebuffer::SimpleFrameBuffer::with_depth_buffer(&display, &tex2, &depth2).unwrap();
// }}}
// Shader Initialization {{{
let prepass_program = shader_program!(&display, "shaders/prepass.vert", "shaders/prepass.frag");
let background_program =
shader_program!(&display, "shaders/pp.vert", "shaders/background.frag");
// let fxaa_program = shader_program!(&display, "shaders/pp.vert", "shaders/fxaa.frag");
let apply_alpha_program = shader_program!(&display, "shaders/pp.vert", "shaders/apply_alpha.frag");
let chromatic_program = shader_program!(&display, "shaders/pp.vert", "shaders/chromatic.frag");
let bokeh_program = shader_program!(&display, "shaders/pp.vert", "shaders/bokeh.frag");
let color_program = shader_program!(&display, "shaders/pp.vert", "shaders/color.frag");
// }}}
// Buffers {{{
// Quad {{{
let quad_verts = {
#[derive(Copy, Clone)]
struct Vertex {
position: [f32; 4],
texcoord: [f32; 2],
}
glium::implement_vertex!(Vertex, position, texcoord);
glium::VertexBuffer::new(
&display,
&[
Vertex {
position: [-1.0, -1.0, 0.0, 1.0],
texcoord: [0.0, 0.0],
},
Vertex {
position: [1.0, -1.0, 0.0, 1.0],
texcoord: [1.0, 0.0],
},
Vertex {
position: [1.0, 1.0, 0.0, 1.0],
texcoord: [1.0, 1.0],
},
Vertex {
position: [-1.0, 1.0, 0.0, 1.0],
texcoord: [0.0, 1.0],
},
],
)
.unwrap()
};
let quad_inds = glium::IndexBuffer::new(
&display,
glium::index::PrimitiveType::TrianglesList,
&[0u16, 1, 2, 0, 2, 3],
)
.unwrap();
// }}}
// Lines {{{
let (mut lines_verts, mut lines_colors) = {
let colsmax = (cols - 1) as f32 / width * 2.0;
let rowsmax = (rows - 1) as f32 / depth;
let h = base_height / 2.0;
let mut v_buf = Vec::with_capacity(rows * cols * 4);
for row in 0..rows {
let y = row as f32 / rowsmax;
// Left
for col in 0..cols {
let x = -(col as f32 / colsmax) - mid_dist;
let cid = (cols - col - 1) / cols_per_note;
v_buf.push(Vertex {
position: [x, y, -h, 1.0],
color_id: cid as u16,
});
v_buf.push(Vertex {
position: [x, y, h, 1.0],
color_id: cid as u16,
});
}
// Right
for col in 0..cols {
let x = (col as f32 / colsmax) + mid_dist;
let cid = col / cols_per_note + notes_num / 2;
v_buf.push(Vertex {
position: [x, y, -h, 1.0],
color_id: cid as u16,
});
v_buf.push(Vertex {
position: [x, y, h, 1.0],
color_id: cid as u16,
});
}
}
let mut colors_buf = [[1.0, 0.0, 0.0, 1.0]; 32];
for (buf, color) in colors_buf.iter_mut().zip(colors.iter()) {
*buf = *color;
}
let lines_colors =
glium::uniforms::UniformBuffer::persistent(&display, colors_buf).unwrap();
(
glium::VertexBuffer::persistent(&display, &v_buf).unwrap(),
lines_colors,
)
};
// }}}
// Points {{{
let points_colors = {
let mut colors_buf = [[1.0, 0.0, 0.0, 1.0]; 32];
for (buf, color) in colors_buf.iter_mut().zip(colors.iter()) {
*buf = *color;
}
glium::uniforms::UniformBuffer::persistent(&display, colors_buf).unwrap()
};
// }}}
// Lightning {{{
// }}}
// }}}
// Image {{{
let image = image::load(
std::io::Cursor::new(&include_bytes!("logo.png")[..]),
image::PNG,
)
.unwrap()
.to_rgba();
let image_dims = image.dimensions();
let image = glium::texture::RawImage2d::from_raw_rgba_reversed(&image.into_raw(), image_dims);
let c3_texture = glium::texture::CompressedSrgbTexture2d::new(&display, image).unwrap();
// }}}
let mut previous_time = 0.0;
let mut previous_offset = 0.0;
let mut rolling_volume = 0.0;
let mut write_row = rows * 3 / 4;
let mut last_beat = -100.0;
let mut notes_spectrum = analyzer::Spectrum::new(vec![0.0; notes_num], 220.0, 660.0);
let mut notes_rolling_buf = vec![0.0; notes_num];
let mut row_buf = Vec::with_capacity(nrow);
let mut row_spectrum = vec![0.0; cols];
let mut beat_rolling = 0.0;
let mut last_beat_num = 0;
let mut maxima_buf = [(0.0, 0.0); 8];
'main: for frame in frames.iter() {
use glium::Surface;
let start = std::time::Instant::now();
let delta = frame.time - previous_time;
trace!("Delta: {}s", delta);
// Audio Info Retrieval {{{
let (volume, maxima, notes_rolling_spectrum, base_volume) = frame.info(|info| {
rolling_volume = info.volume.max(rolling_volume * slowdown);
if info.beat != last_beat_num {
last_beat = frame.time;
last_beat_num = info.beat;
}
let notes_spectrum = info.spectrum.fill_spectrum(&mut notes_spectrum);
for (n, s) in notes_rolling_buf.iter_mut().zip(notes_spectrum.iter()) {
*n = (*n * (note_roll_size - 1.0) + s) / note_roll_size;
}
let notes_rolling_spectrum = vis_core::analyzer::Spectrum::new(
&mut *notes_rolling_buf,
notes_spectrum.lowest(),
notes_spectrum.highest(),
);
let maxima = notes_rolling_spectrum.find_maxima(&mut maxima_buf);
(
info.volume,
maxima,
notes_rolling_spectrum,
info.beat_volume,
)
});
// }}}
// GL Matrices {{{
let view = na::Matrix4::look_at_rh(
&na::Point3::new(0.0, -1.0, cam_height),
&na::Point3::new(0.0, 10.0, cam_look),
&na::Vector3::new(0.0, 0.0, 1.0),
);
let perspective =
na::Matrix4::new_perspective(aspect, std::f32::consts::FRAC_PI_4, 0.001, 100.0);
// }}}
// Grid {{{
let speed = base_speed + rolling_volume * speed_deviation;
let offset = (previous_offset + delta * speed) % rowsize;
let model_grid =
na::Translation3::from(na::Vector3::new(0.0, -offset, 0.0)).to_homogeneous();
// Color Notes {{{
{
let mut color_buf = lines_colors.map();
for color in color_buf.iter_mut() {
color[3] = 0.05;
}
for (f, _) in maxima.iter().take(4) {
let note = notes_rolling_spectrum.freq_to_id(*f);
color_buf[note][3] = 1.0;
}
}
// }}}
// Spectral Grid {{{
if previous_offset > offset {
let mut lines_buf = lines_verts.map();
// We jumped right here
// Save last rows y coordinate
row_buf.clear();
let last_row_offset = lines_buf.len() - nrow;
for i in 0..nrow {
row_buf.push(lines_buf[last_row_offset + i].position[1]);
}
// Copy y coordinate of each line to the next
for i in (nrow..(lines_buf.len())).rev() {
lines_buf[i].position[1] = lines_buf[i - nrow].position[1];
}
// Write saved info to first row (cycle rows)
for i in 0..nrow {
lines_buf[i].position[1] = row_buf[i];
}
// Write spectral information
frame.info(|info| {
let left = info
.analyzer
.left()
.slice(100.0, 800.0)
.fill_buckets(&mut row_spectrum[..]);
let row_offset = nrow * write_row;
let max = left.max() + 0.0001;
for (i, v) in left.iter().enumerate() {
lines_buf[row_offset + i * 2 + 1].position[2] =
base_height / 2.0 + v / max * ampli_top;
lines_buf[row_offset + i * 2].position[2] =
-base_height / 2.0 - v / max * ampli_bottom;
}
let right = info
.analyzer
.right()
.slice(100.0, 800.0)
.fill_buckets(&mut row_spectrum[..]);
let row_offset = nrow * write_row + cols * 2;
let max = right.max() + 0.0001;
for (i, v) in right.iter().enumerate() {
lines_buf[row_offset + i * 2 + 1].position[2] =
base_height / 2.0 + v / max * ampli_top;
lines_buf[row_offset + i * 2].position[2] =
-base_height / 2.0 - v / max * ampli_bottom;
}
});
write_row = (write_row + 1) % rows;
}
// }}}
// }}}
// Drawing {{{
let draw_params = glium::DrawParameters {
line_width: Some(1.0),
point_size: Some(2.0),
blend: glium::Blend {
color: glium::BlendingFunction::Addition {
source: glium::LinearBlendingFactor::SourceAlpha,
destination: glium::LinearBlendingFactor::OneMinusSourceAlpha,
},
alpha: glium::BlendingFunction::Addition {
source: glium::LinearBlendingFactor::One,
destination: glium::LinearBlendingFactor::One,
},
constant_value: (1.0, 1.0, 1.0, 1.0),
},
..Default::default()
};
framebuffer1.clear_color_and_depth((0.0, 0.0, 0.0, 0.0), 1.0);
framebuffer2.clear_color_and_depth((0.0, 0.0, 0.0, 0.0), 1.0);
let (ref mut fa, ref mut fb) = (&mut framebuffer1, &mut framebuffer2);
// Lines {{{
let uniforms = uniform! {
perspective_matrix: Into::<[[f32; 4]; 4]>::into(perspective),
view_matrix: Into::<[[f32; 4]; 4]>::into(view),
model_matrix: Into::<[[f32; 4]; 4]>::into(model_grid),
Colors: &lines_colors,
volume: rolling_volume,
};
fa.draw(
&lines_verts,
&glium::index::NoIndices(glium::index::PrimitiveType::LinesList),
&prepass_program,
&uniforms,
&draw_params,
)
.unwrap();
// }}}
// Points {{{
let uniforms = uniform! {
perspective_matrix: Into::<[[f32; 4]; 4]>::into(perspective),
view_matrix: Into::<[[f32; 4]; 4]>::into(view),
model_matrix: Into::<[[f32; 4]; 4]>::into(model_grid),
Colors: &points_colors,
volume: rolling_volume,
};
fa.draw(
&lines_verts,
&glium::index::NoIndices(glium::index::PrimitiveType::Points),
&prepass_program,
&uniforms,
&draw_params,
)
.unwrap();
// }}}
// Post-Processing {{{
beat_rolling = (beat_rolling * 0.95f32).max(base_volume);
let (fa, fb) = (fb, fa);
let ua = uniform! {
previous: tex1.sampled().wrap_function(glium::uniforms::SamplerWrapFunction::Mirror),
c3: c3_texture.sampled(),
aspect: aspect,
time: frame.time,
volume: volume,
last_beat: frame.time - last_beat,
beat: beat_rolling,
};
let ub = uniform! {
previous: tex2.sampled().wrap_function(glium::uniforms::SamplerWrapFunction::Mirror),
c3: c3_texture.sampled(),
aspect: aspect,
time: frame.time,
volume: volume,
last_beat: frame.time - last_beat,
beat: beat_rolling,
};
fa.draw(&quad_verts, &quad_inds, &background_program, &ua, &draw_params)
.unwrap();
// Apply alpha
let (fa, ua, fb, ub) = (fb, ub, fa, ua);
fa.draw(&quad_verts, &quad_inds, &apply_alpha_program, &ua, &draw_params)
.unwrap();
// Do final passes which don't require alpha information anymore
let (fa, ua, fb, ub) = (fb, ub, fa, ua);
fa.draw(&quad_verts, &quad_inds, &bokeh_program, &ua, &draw_params)
.unwrap();
let (fa, ua, fb, ub) = (fb, ub, fa, ua);
fa.draw(&quad_verts, &quad_inds, &color_program, &ua, &draw_params)
.unwrap();
let (fa, ua, fb, ub) = (fb, ub, fa, ua);
fa.draw(&quad_verts, &quad_inds, &chromatic_program, &ua, &draw_params)
.unwrap();
#[allow(unused_variables)]
let (fa, ua, fb, ub) = (fb, ub, fa, ua);
// }}}
// Finalizing / Draw to screen {{{
let target = display.draw();
let dims = target.get_dimensions();
target.blit_from_simple_framebuffer(
&fb,
&glium::Rect {
left: 0,
bottom: 0,
width: window_width,
height: window_height,
},
&glium::BlitTarget {
left: 0,
bottom: 0,
width: dims.0 as i32,
height: dims.1 as i32,
},
glium::uniforms::MagnifySamplerFilter::Linear,
);
target.finish().unwrap();
// }}}
// }}}
// Events {{{
let mut closed = false;
events_loop.poll_events(|ev| match ev {
glutin::Event::WindowEvent { event, .. } => match event {
glutin::WindowEvent::CloseRequested => closed = true,
glutin::WindowEvent::KeyboardInput {
input:
glutin::KeyboardInput {
virtual_keycode: Some(glutin::VirtualKeyCode::Escape),
..
},
..
} => closed = true,
_ => (),
},
_ => (),
});
if closed {
break 'main;
}
// }}}
previous_time = frame.time;
previous_offset = offset;
let end = std::time::Instant::now();
let dur = end - start;
if dur < frame_time {
let sleep = frame_time - dur;
std::thread::sleep(sleep);
}
}
}

16
src/shaders/apply_alpha.frag
Unescape View File

@ -0,0 +1,16 @@
#version 410
uniform sampler2D previous;
uniform sampler2D c3;
uniform float last_beat;
uniform float beat;
uniform float volume;
uniform float aspect;
smooth in vec2 frag_position;
smooth in vec2 frag_texcoord;
void main() {
vec4 color = texture(previous, frag_texcoord);
gl_FragColor = vec4(color.rgb * color.a, 1.0);
}

38
src/shaders/background.frag
Unescape View File

@ -0,0 +1,38 @@
#version 410
uniform sampler2D previous;
uniform sampler2D c3;
uniform float last_beat;
uniform float beat;
uniform float volume;
uniform float aspect;
smooth in vec2 frag_position;
smooth in vec2 frag_texcoord;
vec3 background() {
vec2 p = frag_position;
p.y *= 512.0 / 203.0;
float t = -2.0 / (last_beat*1.5+1.0)+3.0;
p.x = p.x * aspect + 0.5;
p.y -= 0.8;
p -= vec2(0.5);
p = p * t;
p += vec2(0.5);
if(p.x > 1.0 || p.x < 0.0 || p.y > 1.0 || p.y < 0.0){
return vec3(0.0);
}
return texture(c3, p).rgb;
}
void main() {
vec4 prev_color = texture(previous, frag_texcoord);
vec3 bg_color = background();
gl_FragColor = vec4(prev_color.rgb + (1.0 - prev_color.a) * bg_color, 1.0);
}

52
src/shaders/bokeh.frag
Unescape View File

@ -0,0 +1,52 @@
#version 410
uniform sampler2D previous;
uniform sampler2D c3;
uniform float last_beat;
uniform float beat;
uniform float volume;
uniform float aspect;
smooth in vec2 frag_position;
smooth in vec2 frag_texcoord;
// Bokeh disc.
// by David Hoskins.
// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
// The Golden Angle is (3.-sqrt(5.0))*PI radians, which doesn't precompiled for some reason.
// The compiler is a dunce I tells-ya!!
#define GOLDEN_ANGLE 2.39996
#define ITERATIONS 32
mat2 rot = mat2(cos(GOLDEN_ANGLE), sin(GOLDEN_ANGLE), -sin(GOLDEN_ANGLE), cos(GOLDEN_ANGLE));
//-------------------------------------------------------------------------------------------
vec3 bokeh(sampler2D tex, vec2 uv, float radius)
{
vec3 acc = vec3(0.0), div = acc;
float r = 1.0;
vec2 vangle = vec2(0.0,radius*0.01 / sqrt(float(ITERATIONS)));
for (int j = 0; j < ITERATIONS; j++)
{
// the approx increase in the scale of sqrt(0, 1, 2, 3...)
r += 1. / r;
vangle = rot * vangle;
vec3 col = texture(tex, uv + (r-1.0) * vangle).xyz; /// ... Sample the image
vec3 bokeh = pow(col, vec3(4.0));
acc += col * bokeh;
div += bokeh;
}
return acc / div;
}
void main() {
float blend = 1.0 / (last_beat * 5.0 + 1.0) * 0.2;
blend *= pow(1.0 - frag_texcoord.y, 2);
vec4 real_color = texture(previous, frag_texcoord);
vec4 bokeh_color = vec4(bokeh(previous, frag_texcoord, blend), 1.0);
gl_FragColor = max(real_color, bokeh_color);
}

64
src/shaders/chromatic.frag
Unescape View File

@ -0,0 +1,64 @@
#version 410
uniform sampler2D previous;
uniform sampler2D c3;
uniform float last_beat;
uniform float beat;
uniform float volume;
uniform float aspect;
smooth in vec2 frag_position;
smooth in vec2 frag_texcoord;
// Chromatic Abberation shader
// https://github.com/spite/Wagner/blob/master/fragment-shaders/chromatic-aberration-fs.glsl
vec2 barrelDistortion(vec2 coord, float amt) {
vec2 cc = coord - 0.5;
float dist = dot(cc, cc);
return coord + cc * dist * amt;
}
float sat( float t )
{
return clamp( t, 0.0, 1.0 );
}
float linterp( float t ) {
return sat( 1.0 - abs( 2.0*t - 1.0 ) );
}
float remap( float t, float a, float b ) {
return sat( (t - a) / (b - a) );
}
vec4 spectrum_offset( float t ) {
vec4 ret;
float lo = step(t,0.5);
float hi = 1.0-lo;
float w = linterp( remap( t, 1.0/6.0, 5.0/6.0 ) );
ret = vec4(lo,1.0,hi, 1.) * vec4(1.0-w, w, 1.0-w, 1.);
return pow( ret, vec4(1.0/2.2) );
}
const int num_iter = 20;
const float reci_num_iter_f = 1.0 / float(num_iter);
void main()
{
float max_distort = 0.5;
vec4 sumcol = vec4(0.0);
vec4 sumw = vec4(0.0);
for ( int i=0; i<num_iter;++i )
{
float t = float(i) * reci_num_iter_f;
vec4 w = spectrum_offset( t );
sumw += w;
sumcol += w * texture( previous, barrelDistortion(frag_texcoord, .6 * max_distort*t ) );
}
gl_FragColor = sumcol / sumw;
}

50
src/shaders/color.frag
Unescape View File

@ -0,0 +1,50 @@
#version 410
uniform sampler2D previous;
uniform sampler2D c3;
uniform float last_beat;
uniform float beat;
uniform float volume;
uniform float aspect;
smooth in vec2 frag_position;
smooth in vec2 frag_texcoord;
// RGB/HSV Conversion
// Taken from http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
vec3 rgb2hsv(vec3 c)
{
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
vec3 hsv2rgb(vec3 c)
{
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
void main() {
vec4 prev_color = texture(previous, frag_texcoord);
// if (frag_texcoord.x < 0.5) {
// gl_FragColor = prev_color;
// return;
// }
// gl_FragColor = mat4(
// 1.0, 0.0, 0.0, 0.0,
// 0.0, 1.0, -0.1, 0.0,
// 0.0, -0.3, 1.0, 0.0,
// 0.0, 0.0, 0.0, 1.0
// ) * prev_color;
gl_FragColor = prev_color;
}

0
src/shaders/fxaa.frag
Unescape View File

13
src/shaders/pp.vert
Unescape View File

@ -0,0 +1,13 @@
#version 410
in vec4 position;
in vec2 texcoord;
smooth out vec2 frag_position;
smooth out vec2 frag_texcoord;
void main() {
frag_texcoord = texcoord;
frag_position = position.xy;
gl_Position = position;
}

8
src/shaders/prepass.frag
Unescape View File

@ -0,0 +1,8 @@
#version 410
smooth in vec4 frag_position;
smooth in vec4 frag_color;
void main() {
gl_FragColor = frag_color;
}

23
src/shaders/prepass.vert
Unescape View File

@ -0,0 +1,23 @@
#version 410
uniform mat4 perspective_matrix;
uniform mat4 view_matrix;
uniform mat4 model_matrix;
layout(std140) uniform Colors {
vec4 colors[32];
};
uniform float volume;
in vec4 position;
in uint color_id;
smooth out vec4 frag_position;
smooth out vec4 frag_color;
void main() {
frag_position = model_matrix * position;
frag_position.z += exp(-pow(frag_position.y / 5.0 - 4.0, 2.0)) * (pow(frag_position.x / 8.0, 2.0) * 2.0 + 0.1) * (volume * 30.0 + 0.1);
frag_color = colors[color_id];
frag_color.a = frag_color.a * (1.0 - smoothstep(15.0, 25.0, frag_position.y));
gl_Position = perspective_matrix * view_matrix * frag_position;
}

40
visualizer.toml
Unescape View File

@ -0,0 +1,40 @@
[audio]
window = "nuttall"
conversions = 50
rate = 8000
read_size = 256
recorder = "cpal"
[noa]
fps = 40
[noa.cols]
rows = 50
num = 30
depth = 30.0
mid_dist = 0.1
speed = 0.1
slowdown = 0.995
speed_deviation = 50.0
width = 10.0
note_width = 6
colors = [
[0.30142, 0.01884, 0.00886, 1.0],
[0.13589, 0.30142, 0.17280, 1.0],
[0.28444, 0.42378, 0.13589, 1.0],
[0.56103, 0.49275, 0.12457, 1.0],
[0.90064, 0.59079, 0.12457, 1.0],
[0.90064, 0.59079, 0.12457, 1.0],
[0.56103, 0.49275, 0.12457, 1.0],
[0.28444, 0.42378, 0.13589, 1.0],
[0.13589, 0.30142, 0.17280, 1.0],
[0.30142, 0.01884, 0.00886, 1.0],
]
amp_top = 0.7
amp_bottom = 0.2
[noa.camera]
height = 1.0
look_height = 0.8
Write Preview
Loading…
Cancel
Save