use std::cell::{Cell, RefCell};
use std::collections::HashSet;
use std::rc::Rc;
use crate::core::ObjectRef;
use crate::materials::MeshBasicNodeMaterial;
use crate::math::Color;
use crate::nodes::node::{SettableValue, TextureSource, Type};
use crate::nodes::tsl::{
block, depth_texture_sample, exp, float, int, length, loop_options, min_of,
perspective_depth_to_view_z, position_view, screen_uv, texture, texture_size, texture_uv,
texture_with_uv, to_var, uniform_settable, uniform_value, uv, vec2, vec2_join, vec3, vec3_join,
vec4, vec4_join,
};
use crate::nodes::{NodeRef, NodeUpdate, NodeUpdateType};
use crate::objects::QuadMesh;
use crate::renderer::{
CameraRef, OutlineSelection, RenderTarget, RenderTargetOptions, Renderer, SceneRef,
};
use crate::textures::{DepthTexture, Texture, TextureType};
const MAX_RADIUS: f64 = 4.0;
pub struct OutlineParams {
pub selected_objects: Vec<ObjectRef>,
pub edge_thickness: NodeRef,
pub edge_glow: NodeRef,
pub down_sample_ratio: f64,
}
impl Default for OutlineParams {
fn default() -> Self {
Self {
selected_objects: Vec::new(),
edge_thickness: float(1.0),
edge_glow: float(0.0),
down_sample_ratio: 2.0,
}
}
}
pub fn outline(scene: SceneRef, camera: CameraRef, params: OutlineParams) -> OutlineNode {
OutlineNode::new(scene, camera, params)
}
#[derive(Clone)]
pub struct OutlineNode(Rc<OutlineState>);
impl std::ops::Deref for OutlineNode {
type Target = OutlineState;
fn deref(&self) -> &OutlineState {
&self.0
}
}
pub struct OutlineState {
scene: SceneRef,
camera: CameraRef,
selected_objects: RefCell<Vec<ObjectRef>>,
down_sample_ratio: f64,
depth_buffer: RenderTarget,
mask_buffer: RenderTarget,
mask_down_sample_buffer: RenderTarget,
edge_buffer1: RenderTarget,
edge_buffer2: RenderTarget,
blur_buffer1: RenderTarget,
blur_buffer2: RenderTarget,
composite_buffer: RenderTarget,
camera_near: SettableValue,
camera_far: SettableValue,
depth_material: Rc<MeshBasicNodeMaterial>,
depth_sprite_material: Rc<MeshBasicNodeMaterial>,
prepare_mask_material: Rc<MeshBasicNodeMaterial>,
prepare_mask_sprite_material: Rc<MeshBasicNodeMaterial>,
copy: QuadMesh,
edge_detection: QuadMesh,
blur_half: [QuadMesh; 2],
blur_quarter: [QuadMesh; 2],
composite: QuadMesh,
last_selection_count: Cell<usize>,
node: NodeRef,
}
fn orthographic_depth_to_view_z(depth: NodeRef, near: NodeRef, far: NodeRef) -> NodeRef {
near.clone().sub(far).mul(depth).sub(near)
}
fn gaussian_pdf(x: NodeRef, sigma: NodeRef) -> NodeRef {
float(0.39894).mul(
exp(float(-0.5)
.mul(x.clone())
.mul(x)
.div(sigma.clone().mul(sigma.clone())))
.div(sigma),
)
}
fn inv_size(mask_down_sample: &Texture) -> NodeRef {
to_var(
None,
vec2(1.0, 1.0).div(
texture_size(TextureSource::Texture2D(mask_down_sample.clone()), int(0)).to(Type::Vec2),
),
)
}
fn edge_detection(mask_down_sample: &Texture) -> NodeRef {
let inv_size = inv_size(mask_down_sample);
let uv_offset =
vec4(1.0, 0.0, 0.0, 1.0).mul(vec4_join(vec![inv_size.clone(), inv_size.clone()]));
let uv_node = uv();
let tap = |coord: NodeRef| to_var(None, texture_with_uv(mask_down_sample, coord));
let c1 = tap(uv_node.clone().add(uv_offset.xy()));
let c2 = tap(uv_node.clone().sub(uv_offset.xy()));
let c3 = tap(uv_node.clone().add(uv_offset.swizzle("yw")));
let c4 = tap(uv_node.sub(uv_offset.swizzle("yw")));
let diff1 = c1.x().sub(c2.x()).mul(float(0.5));
let diff2 = c3.x().sub(c4.x()).mul(float(0.5));
let d = length(vec2_join(vec![diff1, diff2]));
let a1 = min_of(c1.y(), c2.y());
let a2 = min_of(c3.y(), c4.y());
let visibility_factor = min_of(a1, a2);
let edge_color = visibility_factor
.one_minus()
.greater_than(float(0.001))
.select(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0));
block(
vec![inv_size, c1, c2, c3, c4],
vec4_join(vec![edge_color, float(1.0)]).mul(d),
)
}
fn separable_blur(
mask_down_sample: &Texture,
color: &Texture,
direction: [f64; 2],
kernel_radius: NodeRef,
) -> NodeRef {
let inv_size = inv_size(mask_down_sample);
let uv_node = uv();
let sigma = to_var(None, kernel_radius.div(float(2.0)));
let weight_sum = to_var(None, gaussian_pdf(float(0.0), sigma.clone()));
let diffuse_sum = to_var(
None,
texture_with_uv(color, uv_node.clone()).mul(weight_sum.clone()),
);
let blur_direction = uniform_value(Type::Vec2, direction.to_vec());
let delta = to_var(
None,
blur_direction
.mul(inv_size.clone())
.mul(kernel_radius.clone())
.div(float(MAX_RADIUS)),
);
let uv_offset = to_var(None, delta.clone());
let sigma_var = sigma.clone();
let body = {
let (diffuse_sum, weight_sum, uv_offset, delta) = (
diffuse_sum.clone(),
weight_sum.clone(),
uv_offset.clone(),
delta.clone(),
);
move |i: &NodeRef| {
let x = kernel_radius.mul(i.to(Type::F32)).div(float(MAX_RADIUS));
let w = gaussian_pdf(x, sigma.clone());
let sample1 = texture_with_uv(color, uv_node.clone().add(uv_offset.clone()));
let sample2 = texture_with_uv(color, uv_node.sub(uv_offset.clone()));
vec![
diffuse_sum.add_assign(sample1.add(sample2).mul(w.clone())),
weight_sum.add_assign(w.mul(float(2.0))),
uv_offset.add_assign(delta),
]
}
};
let blur_loop = loop_options("i", Type::I32, int(1), int(MAX_RADIUS as i64), "<=", body);
block(
vec![
inv_size,
sigma_var,
weight_sum.clone(),
diffuse_sum.clone(),
delta,
uv_offset,
blur_loop,
],
diffuse_sum.div(weight_sum),
)
}
fn colour_target(depth_buffer: bool) -> RenderTarget {
RenderTarget::new_with_options(
1,
1,
RenderTargetOptions {
depth_buffer,
..RenderTargetOptions::default()
},
)
.expect("three-rs: an outline render target is an UnsignedByte colour type")
}
fn quad(name: &'static str, fragment: NodeRef) -> QuadMesh {
let mut material = MeshBasicNodeMaterial::new();
material.name = name;
material.fragment_node = Some(fragment);
QuadMesh::new(material)
}
impl OutlineNode {
pub fn new(scene: SceneRef, camera: CameraRef, params: OutlineParams) -> Self {
let OutlineParams {
selected_objects,
edge_thickness,
edge_glow,
down_sample_ratio,
} = params;
let depth_buffer = RenderTarget::new(1, 1);
let depth_texture = DepthTexture::new();
depth_texture
.set_type(TextureType::Float)
.expect("three-rs: FloatType is a depth type");
depth_buffer.set_depth_texture(depth_texture.clone());
let mask_buffer = RenderTarget::new(1, 1);
let mask_down_sample_buffer = colour_target(false);
let edge_buffer1 = colour_target(false);
let edge_buffer2 = colour_target(false);
let blur_buffer1 = colour_target(false);
let blur_buffer2 = colour_target(false);
let composite_buffer = colour_target(false);
let (is_perspective, near, far) = {
let camera = camera.borrow();
(camera.is_perspective_camera(), camera.near(), camera.far())
};
let (camera_near_node, camera_near) = uniform_settable(Type::F32, vec![near]);
let (camera_far_node, camera_far) = uniform_settable(Type::F32, vec![far]);
let mask = mask_buffer.texture();
let mask_down_sample = mask_down_sample_buffer.texture();
let mut depth_material = MeshBasicNodeMaterial::new();
depth_material.color_node = Some(vec3(0.0, 0.0, 0.0));
depth_material.name = "OutlineNode.depth";
let mut depth_sprite_material = MeshBasicNodeMaterial::sprite();
depth_sprite_material.color_node = Some(vec3(0.0, 0.0, 0.0));
depth_sprite_material.name = "OutlineNode.depthSprite";
let prepare_mask = || {
let depth = depth_texture_sample(&depth_texture, screen_uv());
let view_z = if is_perspective {
perspective_depth_to_view_z(
depth,
camera_near_node.clone(),
camera_far_node.clone(),
)
} else {
orthographic_depth_to_view_z(
depth,
camera_near_node.clone(),
camera_far_node.clone(),
)
};
let depth_test = position_view()
.z()
.less_than_equal(view_z)
.select(float(1.0), float(0.0));
vec3_join(vec![float(0.0), depth_test, float(1.0)])
};
let mut prepare_mask_material = MeshBasicNodeMaterial::new();
prepare_mask_material.name = "OutlineNode.prepareMask";
prepare_mask_material.color_node = Some(prepare_mask());
let mut prepare_mask_sprite_material = MeshBasicNodeMaterial::sprite();
prepare_mask_sprite_material.name = "OutlineNode.prepareMaskSprite";
prepare_mask_sprite_material.color_node = Some(prepare_mask());
let copy = quad("OutlineNode.copy", texture(&mask));
let edge_detection = quad(
"OutlineNode.edgeDetection",
edge_detection(&mask_down_sample),
);
let blur = |name, color: &Texture, direction, radius: &NodeRef| {
quad(
name,
separable_blur(&mask_down_sample, color, direction, radius.clone()),
)
};
let quarter_radius = float(MAX_RADIUS);
let blur_half = [
blur(
"OutlineNode.separableBlur",
&edge_buffer1.texture(),
[1.0, 0.0],
&edge_thickness,
),
blur(
"OutlineNode.separableBlur",
&blur_buffer1.texture(),
[0.0, 1.0],
&edge_thickness,
),
];
let blur_quarter = [
blur(
"OutlineNode.separableBlur2",
&edge_buffer1.texture(),
[1.0, 0.0],
&quarter_radius,
),
blur(
"OutlineNode.separableBlur2",
&blur_buffer2.texture(),
[0.0, 1.0],
&quarter_radius,
),
];
let edge_value =
texture(&edge_buffer1.texture()).add(texture(&edge_buffer2.texture()).mul(edge_glow));
let composite = quad("OutlineNode.composite", texture(&mask).x().mul(edge_value));
let node = texture_uv(&composite_buffer.texture(), uv());
let outline = Self(Rc::new(OutlineState {
scene,
camera,
selected_objects: RefCell::new(selected_objects),
down_sample_ratio,
depth_buffer,
mask_buffer,
mask_down_sample_buffer,
edge_buffer1,
edge_buffer2,
blur_buffer1,
blur_buffer2,
composite_buffer,
camera_near,
camera_far,
depth_material: Rc::new(depth_material),
depth_sprite_material: Rc::new(depth_sprite_material),
prepare_mask_material: Rc::new(prepare_mask_material),
prepare_mask_sprite_material: Rc::new(prepare_mask_sprite_material),
copy,
edge_detection,
blur_half,
blur_quarter,
composite,
last_selection_count: Cell::new(0),
node,
}));
crate::nodes::frame::register_texture_update(
outline.composite_buffer.texture().id(),
&outline.0,
);
outline
}
pub fn node(&self) -> NodeRef {
self.node.clone()
}
pub fn visible_edge(&self) -> NodeRef {
self.node.x()
}
pub fn hidden_edge(&self) -> NodeRef {
self.node.y()
}
#[doc(hidden)]
pub fn materials(&self) -> Vec<&MeshBasicNodeMaterial> {
vec![
&self.depth_material,
&self.depth_sprite_material,
&self.prepare_mask_material,
&self.prepare_mask_sprite_material,
&self.copy.material,
&self.edge_detection.material,
&self.blur_half[0].material,
&self.blur_half[1].material,
&self.blur_quarter[0].material,
&self.blur_quarter[1].material,
&self.composite.material,
]
}
}
impl OutlineState {
pub fn selected_objects(&self) -> Vec<ObjectRef> {
self.selected_objects.borrow().clone()
}
pub fn set_selected_objects(&self, objects: Vec<ObjectRef>) {
*self.selected_objects.borrow_mut() = objects;
}
pub fn down_sample_ratio(&self) -> f64 {
self.down_sample_ratio
}
pub fn set_size(&self, width: u32, height: u32) {
self.depth_buffer.set_size(width, height);
self.mask_buffer.set_size(width, height);
self.composite_buffer.set_size(width, height);
let resx = (f64::from(width) / self.down_sample_ratio).round();
let resy = (f64::from(height) / self.down_sample_ratio).round();
self.mask_down_sample_buffer
.set_size(resx as u32, resy as u32);
self.edge_buffer1.set_size(resx as u32, resy as u32);
self.blur_buffer1.set_size(resx as u32, resy as u32);
let resx = (resx / 2.0).round() as u32;
let resy = (resy / 2.0).round() as u32;
self.edge_buffer2.set_size(resx, resy);
self.blur_buffer2.set_size(resx, resy);
}
fn selection_cache(&self) -> HashSet<u32> {
let mut cache = HashSet::new();
for selected in self.selected_objects.borrow().iter() {
selected.traverse(&mut |object| {
let object = object.borrow();
if object.payload.is_mesh() || object.payload.is_sprite() {
cache.insert(object.id);
}
});
}
cache
}
fn render_selection(
&self,
renderer: &mut Renderer,
target: &RenderTarget,
selection: OutlineSelection,
) {
let mut renderer = renderer.save_state();
renderer.set_render_target(Some(target.clone()));
renderer.outline_selection = Some(selection);
renderer.render_shared(&self.scene.borrow(), &self.camera);
}
}
impl NodeUpdate for OutlineState {
fn update_before_type(&self) -> NodeUpdateType {
NodeUpdateType::Frame
}
fn update_before(&self, renderer: &mut Renderer) -> bool {
renderer.init_render_target(&self.composite_buffer);
let selection = self.selection_cache();
let mut renderer = renderer.reset_state();
if selection.is_empty() {
if self.last_selection_count.get() > 0 {
renderer.set_render_target(Some(self.composite_buffer.clone()));
renderer.set_clear_color(Color::from_hex(0x000000), 0.0);
renderer.clear(true, self.composite_buffer.depth_buffer());
self.last_selection_count.set(0);
}
return true;
}
self.last_selection_count.set(selection.len());
let (width, height) = renderer.drawing_buffer_size();
self.set_size(width, height);
renderer.set_clear_color(Color::from_hex(0xffffff), 1.0);
{
let camera = self.camera.borrow();
self.camera_near.set(vec![camera.near()]);
self.camera_far.set(vec![camera.far()]);
}
let selected = Rc::new(selection);
self.render_selection(
&mut renderer,
&self.depth_buffer,
OutlineSelection {
selected: selected.clone(),
draw_selected: false,
material: self.depth_material.clone(),
sprite_material: self.depth_sprite_material.clone(),
},
);
self.render_selection(
&mut renderer,
&self.mask_buffer,
OutlineSelection {
selected,
draw_selected: true,
material: self.prepare_mask_material.clone(),
sprite_material: self.prepare_mask_sprite_material.clone(),
},
);
renderer.set_render_target(Some(self.mask_down_sample_buffer.clone()));
renderer.render_quad(&self.copy);
renderer.set_render_target(Some(self.edge_buffer1.clone()));
renderer.render_quad(&self.edge_detection);
renderer.set_render_target(Some(self.blur_buffer1.clone()));
renderer.render_quad(&self.blur_half[0]);
renderer.set_render_target(Some(self.edge_buffer1.clone()));
renderer.render_quad(&self.blur_half[1]);
renderer.set_render_target(Some(self.blur_buffer2.clone()));
renderer.render_quad(&self.blur_quarter[0]);
renderer.set_render_target(Some(self.edge_buffer2.clone()));
renderer.render_quad(&self.blur_quarter[1]);
renderer.set_render_target(Some(self.composite_buffer.clone()));
renderer.render_quad(&self.composite);
drop(renderer);
true
}
}