// p5's shader filters (src/core/filterShaders.js): the GLSL p5.strands
// generates, run in WEBGL by Renderer3D.filter and for 2D canvases by
// FilterRenderer2D (src/image/filterRenderer2D.js).
///|
/// A built-in filter by p5 name ("gray", "invert", "threshold",
/// "posterize", "blur", "erode", "dilate", "opaque").
fn filter_shader(webgl2 : Bool, op : String) -> Shader? {
let (v, f) = match op {
"gray" => (filter_gray_vert, filter_gray_frag)
"invert" => (filter_invert_vert, filter_invert_frag)
"threshold" => (filter_threshold_vert, filter_threshold_frag)
"posterize" => (filter_posterize_vert, filter_posterize_frag)
"blur" => (filter_blur_vert, filter_blur_frag)
"erode" => (filter_erode_vert, filter_erode_frag)
"dilate" => (filter_dilate_vert, filter_dilate_frag)
"opaque" => (filter_opaque_vert, filter_opaque_frag)
_ => return None
}
Some(
Shader::raw(
compat_prefix(webgl2, true) + v,
compat_prefix(webgl2, false) + f,
),
)
}
///|
/// p5's `filterParamDefaults`.
pub fn filter_default_param(op : String) -> Double? {
match op {
"blur" => Some(3)
"posterize" => Some(4)
"threshold" => Some(0.5)
_ => None
}
}
// ---- WEBGL: Renderer3D.filter ----
///|
fn Renderer3D::filter_target_size(
self : Renderer3D,
) -> (Double, Double, Double) {
match self.active_fbs.last() {
Some(fb) => (fb.width, fb.height, fb.density)
None => (self.width, self.height, self.density)
}
}
///|
fn Renderer3D::match_layer(
self : Renderer3D,
layer : Framebuffer?,
) -> Framebuffer {
let (w, h, d) = self.filter_target_size()
match layer {
Some(fb) => {
if fb.width != w || fb.height != h {
fb.width = w
fb.height = h
fb.auto_sized = false
fb.recreate()
}
if fb.density != d {
fb.pixel_density(d)
}
fb
}
None => {
let fb = self.create_framebuffer(
FramebufferOptions::default(),
self.antialias,
)
if fb.width != w || fb.height != h {
fb.resize(w, h)
}
if fb.density != d {
fb.pixel_density(d)
}
fb
}
}
}
///|
/// Applies a built-in filter to the canvas or active framebuffer (`filter()`
/// in WEBGL). `style` is the sketch's current style (its fill decides
/// whether the filter quad is drawn, as in p5).
pub fn Renderer3D::filter(
self : Renderer3D,
op : String,
param : Double?,
style : Style,
user : Shader?,
) -> Unit {
let param = match param {
Some(p) => Some(p)
None => filter_default_param(op)
}
let sh = match user {
Some(s) => s
None =>
match self.filter_shaders.get(op) {
Some(s) => s
None =>
match filter_shader(@gl.version(self.gl) == 2, op) {
Some(s) => {
self.filter_shaders[op] = s
s
}
None => return
}
}
}
let target_fb = self.active_fbs.last()
let target : TexSource = match target_fb {
Some(fb) => fb.source()
None =>
{
elt: Some(self.canvas),
fb: None,
width: self.width,
height: self.height,
}
}
let (tw, th, td) = self.filter_target_size()
let fbo = self.match_layer(self.filter_layer)
self.filter_layer = Some(fbo)
fbo.draw(() => self.clear(0, 0, 0, 0))
let texel = [1.0 / (tw * td), 1.0 / (th * td)]
let pass_style = { ..style, stroke: None, blend_mode: "blend", }
let quad = () => {
self.no_lights()
let g = self.cached_geometry("plane|1|1", () => plane_geometry(1, 1))
self.draw_scaled(g, tw, th, 1, pass_style)
}
if op == "blur" && user is None {
let tmp = self.match_layer(self.filter_layer_temp)
self.filter_layer_temp = Some(tmp)
self.push()
self.set_fill_shader(Some(sh))
sh.set_uniform("texelSize", Floats(FixedArray::from_array(texel)))
sh.set_uniform("canvasSize", Floats([tw, th]))
sh.set_uniform("radius", Floats([param.unwrap_or(3).max(1)]))
tmp.draw(() => {
sh.set_uniform("direction", Floats([1, 0]))
sh.set_uniform("tex0", Tex(target))
self.clear(0, 0, 0, 0)
self.set_fill_shader(Some(sh))
quad()
})
fbo.draw(() => {
sh.set_uniform("direction", Floats([0, 1]))
sh.set_uniform("tex0", Tex(tmp.source()))
self.clear(0, 0, 0, 0)
self.set_fill_shader(Some(sh))
quad()
})
self.pop()
} else {
fbo.draw(() => {
self.set_fill_shader(Some(sh))
sh.set_uniform("tex0", Tex(target))
sh.set_uniform("texelSize", Floats(FixedArray::from_array(texel)))
sh.set_uniform("canvasSize", Floats([tw, th]))
sh.set_uniform(
"filterParameter",
Floats([param.unwrap_or(@double.not_a_number)]),
)
quad()
})
}
// draw the result back with the target's filter camera
self.push()
self.clear(0, 0, 0, 0)
self.push()
let cam = match target_fb {
Some(fb) => fb_camera(fb.width, fb.height)
None => Camera::new(self.width, self.height)
}
self.set_camera(cam)
self.reset_matrix()
self.drawing_filter = true
self.image(
fbo.source(),
0,
0,
fbo.width,
fbo.height,
-tw / 2,
-th / 2,
tw,
th,
{ ..pass_style, fill: Some([1, 1, 1, 1]), },
)
self.drawing_filter = false
self.clear_depth()
self.pop()
self.pop()
}
// ---- 2D: FilterRenderer2D ----
///|
/// Runs p5's filter shaders over a 2D canvas on a helper WebGL canvas.
pub struct Filter2D {
priv gl : @gl.GL
priv canvas : @dom.Canvas
priv shaders : Map[String, Shader]
priv vbuf : @gl.Buffer
priv tbuf : @gl.Buffer
}
///|
/// A helper of `w × h` pixels (p5 sizes it in CSS pixels).
pub fn Filter2D::new(w : Double, h : Double) -> Filter2D {
let canvas = @dom.create_canvas(w, h, 1, "", false)
let gl = @gl.create_plain_context(canvas)
let vbuf = @gl.create_buffer(gl)
@gl.array_buffer_data(gl, vbuf, [-1, -1, 1, -1, -1, 1, 1, 1])
let tbuf = @gl.create_buffer(gl)
@gl.array_buffer_data(gl, tbuf, [0, 1, 1, 1, 0, 0, 1, 0])
{ gl, canvas, shaders: Map([]), vbuf, tbuf, }
}
///|
/// One render pass: the filtered `src` (a `w × h` canvas at `density`)
/// into the helper canvas, which is returned as an image source.
pub fn Filter2D::pass(
self : Filter2D,
op : String,
param : Double?,
direction : (Double, Double),
src : @dom.ImageElement,
w : Double,
h : Double,
density : Double,
user? : Shader,
) -> @dom.ImageElement? {
let sh = match user {
Some(s) => s
None =>
match self.shaders.get(op) {
Some(s) => s
None =>
match filter_shader(@gl.version(self.gl) == 2, op) {
Some(s) => {
self.shaders[op] = s
s
}
None => return None
}
}
}
guard sh.init(self.gl) is Some(p) else { return None }
@gl.use_program(p)
if user is Some(_) {
for name, v in sh.uniforms {
match v {
Floats(data) => @gl.set_uniform(p, name, data)
Tex(t) =>
match t.elt {
Some(e) =>
@gl.set_uniform_texture(
p,
name,
@gl.texture_for(self.gl, e, "clamp", "clamp", "linear"),
)
None => ()
}
}
}
}
let param = match param {
Some(v) => v
None => filter_default_param(op).unwrap_or(@double.not_a_number)
}
let tex = @gl.texture_for(self.gl, src, "clamp", "clamp", "linear")
@gl.set_uniform_texture(p, "tex0", tex)
@gl.set_uniform(p, "texelSize", [1.0 / (w * density), 1.0 / (h * density)])
@gl.set_uniform(p, "canvasSize", [w, h])
@gl.set_uniform(p, "radius", [param.max(1)])
@gl.set_uniform(p, "filterParameter", [param])
@gl.set_uniform(p, "direction", [direction.0, direction.1])
let identity : FixedArray[Double] = [
1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1,
]
@gl.set_uniform(p, "uModelViewMatrix", identity)
@gl.set_uniform(p, "uProjectionMatrix", identity)
@gl.attrib_pointer(
self.gl,
self.vbuf,
@gl.attribute_location(p, "aPosition"),
2,
)
@gl.attrib_pointer(
self.gl,
self.tbuf,
@gl.attribute_location(p, "aTexCoord"),
2,
)
@gl.bind_textures(p, tex)
@gl.disable_other_attribs(p)
@gl.draw_arrays(self.gl, 1, 4, 1)
Some(@gl.context_canvas(self.gl))
}