+use parley::{

+ layout::Alignment,

+ style::{FontFamily, FontStack, StyleProperty},

+ FontContext, LayoutContext,

+};

+use std::borrow::Cow;

+use winit::{

+ event::{Event, WindowEvent},

+ event_loop::{ControlFlow, EventLoop},

+ window::Window,

+};

+

+use wgpu::util::DeviceExt;

+

+// new femto-like framework:

+// wgpu renderer

+// kurbo, (alternative is euclid + lyon)

+// vector math: glam? and drop euclid (glam is faster https://docs.rs/glam/latest/glam/)

+// swash + parley for text

+

+// imgref, bitflags

+// fnv, rgb

+

+// resource, image

+// usvg for svg

+

+use swash::{

+ scale::ScaleContext,

+ shape::ShapeContext,

+ text::Script,

+ zeno::{Vector, Verb},

+ Attributes, CacheKey, Charmap, FontRef,

+};

+

+use lyon::{

+ math::{point, Transform},

+ path::{builder::*, Path},

+ tessellation::{BuffersBuilder, FillOptions, FillTessellator, FillVertex, VertexBuffers},

+};

+

+use bytemuck::{Pod, Zeroable};

+

+// Vertex for lines drawn by lyon

+#[repr(C)]

+#[derive(Clone, Copy, Debug, Pod, Zeroable)]

+struct Vertex {

+ position: [f32; 2],

+ // color: [f32; 4], // Use this when I want more colors

+}

+

+#[repr(C)]

+#[derive(Clone, Copy, Debug, Pod, Zeroable)]

+struct View {

+ size: [f32; 2],

+}

+

+fn font() -> VertexBuffers<Vertex, u16> {

+ let data = std::fs::read("assets/fonts/ttf/FiraCode-Regular.ttf").unwrap();

+

+ // -- Shaping

+ // let mut context = ShapeContext::new();

+ // let mut shaper = context

+ // .builder(font)

+ // .script(Script::Latin)

+ // .size(12.)

+ // .variations(&[("wght", 400.0)])

+ // .build();

+

+ // shaper.add_str("a quick brown fox?");

+

+ // add_str with boundary analysis

+ // use swash::text::{analyze, Script};

+ // use swash::text::cluster::{CharInfo, Parser, Token};

+ // let text = "a quick brown fox?";

+ // let mut parser = Parser::new(

+ // Script::Latin,

+ // text.char_indices()

+ // // Call analyze passing the same text and zip

+ // // the results

+ // .zip(analyze(text.chars()))

+ // // Analyze yields the tuple (Properties, Boundary)

+ // .map(|((i, ch), (props, boundary))| Token {

+ // ch,

+ // offset: i as u32,

+ // len: ch.len_utf8() as u8,

+ // // Create character information from properties and boundary

+ // info: CharInfo::new(props, boundary),

+ // data: 0,

+ // }),

+ // );

+

+ // shaper.shape_with(|c| {

+ // // use the glyph cluster

+ // // c.glyphs

+ // });

+

+ // -- Scaling

+

+ // let mut scaler = scale_ctx

+ // .builder(font)

+ // .hint(true)

+ // .size(12.)

+ // .variations(&[("wght", 400.0)])

+ // .build();

+ // let glyph_id = font.charmap().map('H');

+ // let outline = scaler.scale_outline(glyph_id).unwrap();

+

+ // -- Layout

+

+ let mut font_ctx = FontContext::new();

+ let font_family = font_ctx.register_fonts(data).unwrap();

+ let mut layout_ctx: LayoutContext<[u8; 4]> = LayoutContext::new();

+

+ // Encode glyphs into lyon paths

+ let mut encoder = Path::builder();

+ let mut encoder = encoder.transformed(Transform::default());

+

+ let mut builder = layout_ctx.ranged_builder(&mut font_ctx, "fn draw_edit_box_base<T: Renderer>(canvas: &mut Canvas<T>, x: f32, y: f32, w: f32, h: f32) { ", 1.);

+ builder.push_default(&StyleProperty::FontStack(FontStack::Single(

+ FontFamily::Named(&font_family),

+ )));

+ builder.push_default(&StyleProperty::FontSize(12.));

+ builder.push_default(&StyleProperty::Brush([255, 255, 255, 255]));

+ // builder.push() with range to set styling

+ let mut layout = builder.build();

+ let max_width = None;

+ layout.break_all_lines(max_width, Alignment::Start);

+

+ let mut scale_ctx = ScaleContext::new();

+

+ for line in layout.lines() {

+ let mut last_x = 0.0;

+ let mut last_y = 0.0;

+

+ for glyph_run in line.glyph_runs() {

+ let run = glyph_run.run();

+ let color = &glyph_run.style().brush;

+ let font = run.font();

+ let font = font.as_ref();

+

+ let mut first = true;

+

+ // TODO: handle .variations(&[("wght", 400.0)])

+ let mut scaler = scale_ctx.builder(font).size(run.font_size()).build();

+

+ for glyph in glyph_run.positioned_glyphs() {

+ let delta_x = glyph.x - last_x;

+ let delta_y = glyph.y - last_y;

+

+ last_x = glyph.x;

+ last_y = glyph.y;

+

+ if first {

+ // TODO: handle underline

+ // TODO: handle strikethrough

+ }

+ first = false;

+

+ encoder.set_transform(Transform::new(

+ 1.0, 0.0, //

+ 0.0, -1.0, // invert y axis

+ glyph.x, glyph.y,

+ ));

+

+ if let Some(outline) = scaler.scale_outline(glyph.id) {

+ append_outline(&mut encoder, outline.verbs(), outline.points());

+ };

+ }

+ }

+ }

+

+ // -- Tesselation

+ let path = encoder.build();

+

+ let mut geometry: VertexBuffers<Vertex, u16> = VertexBuffers::new();

+

+ let mut tessellator = FillTessellator::new();

+ {

+ // Compute the tessellation.

+ tessellator

+ .tessellate_path(

+ &path,

+ &FillOptions::non_zero().with_tolerance(0.01), // defaults to 0.1, compare further

+ &mut BuffersBuilder::new(&mut geometry, |vertex: FillVertex| Vertex {

+ position: vertex.position().to_array(),

+ }),

+ )

+ .unwrap();

+ }

+

+ geometry

+}

+

+fn append_outline<T: lyon::path::builder::PathBuilder>(

+ encoder: &mut T,

+ verbs: &[Verb],

+ points: &[Vector],

+) {

+ let mut i = 0;

+ for verb in verbs {

+ match verb {

+ Verb::MoveTo => {

+ let p = points[i];

+ // TODO: can MoveTo appear halfway through?

+ encoder.begin(point(p.x, p.y));

+ i += 1;

+ }

+ Verb::LineTo => {

+ let p = points[i];

+ encoder.line_to(point(p.x, p.y));

+ i += 1;

+ }

+ Verb::QuadTo => {

+ let p1 = points[i];

+ let p2 = points[i + 1];

+ encoder.quadratic_bezier_to(point(p1.x, p1.y), point(p2.x, p2.y));

+ i += 2;

+ }

+ Verb::CurveTo => {

+ let p1 = points[i];

+ let p2 = points[i + 1];

+ let p3 = points[i + 2];

+ encoder.cubic_bezier_to(point(p1.x, p1.y), point(p2.x, p2.y), point(p3.x, p3.y));

+ i += 3;

+ }

+ Verb::Close => {

+ encoder.close();

+ }

+ }

+ }

+}

+

+fn create_multisampled_framebuffer(

+ device: &wgpu::Device,

+ config: &wgpu::SurfaceConfiguration,

+ sample_count: u32,

+) -> wgpu::TextureView {

+ let multisampled_texture_extent = wgpu::Extent3d {

+ width: config.width,

+ height: config.height,

+ depth_or_array_layers: 1,

+ };

+ let multisampled_frame_descriptor = &wgpu::TextureDescriptor {

+ size: multisampled_texture_extent,

+ mip_level_count: 1,

+ sample_count,

+ dimension: wgpu::TextureDimension::D2,

+ format: config.format,

+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,

+ label: None,

+ };

+

+ device

+ .create_texture(multisampled_frame_descriptor)

+ .create_view(&wgpu::TextureViewDescriptor::default())

+}

+

+async fn run(event_loop: EventLoop<()>, window: Window) {

+ let sample_count = 4;

+

+ let size = window.inner_size();

+ let instance = wgpu::Instance::new(wgpu::Backends::all());

+ let surface = unsafe { instance.create_surface(&window) };

+ let adapter = instance

+ .request_adapter(&wgpu::RequestAdapterOptions {

+ power_preference: wgpu::PowerPreference::default(), // TODO: select based on backend

+ force_fallback_adapter: false,

+ // Request an adapter which can render to our surface

+ compatible_surface: Some(&surface),

+ })

+ .await

+ .expect("Failed to find an appropriate adapter");

+

+ // Create the logical device and command queue

+ let (device, queue) = adapter

+ .request_device(

+ &wgpu::DeviceDescriptor {

+ label: None,

+ features: wgpu::Features::empty(),

+ // Make sure we use the texture resolution limits from the adapter, so we can support images the size of the swapchain.

+ limits: wgpu::Limits::downlevel_webgl2_defaults()

+ .using_resolution(adapter.limits()),

+ },

+ None,

+ )

+ .await

+ .expect("Failed to create device");

+

+ // Load the shaders from disk

+ let shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {

+ label: None,

+ source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),

+ });

+

+ // ---

+

+ let geometry = font();

+

+ let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {

+ label: Some("Vertex Buffer"),

+ contents: bytemuck::cast_slice(&geometry.vertices),

+ usage: wgpu::BufferUsages::VERTEX,

+ });

+

+ let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {

+ label: Some("Index Buffer"),

+ contents: bytemuck::cast_slice(&geometry.indices),

+ usage: wgpu::BufferUsages::INDEX,

+ });

+

+ //

+

+ // TODO: use size fetched before

+ let data = View { size: [0.0, 0.0] };

+

+ let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {

+ label: Some("Uniform Buffer"),

+ contents: bytemuck::cast_slice(&[data]),

+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,

+ });

+

+ let uniform_bind_group_layout =

+ device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {

+ entries: &[wgpu::BindGroupLayoutEntry {

+ binding: 0,

+ visibility: wgpu::ShaderStages::VERTEX,

+ ty: wgpu::BindingType::Buffer {

+ ty: wgpu::BufferBindingType::Uniform,

+ has_dynamic_offset: false,

+ min_binding_size: None,

+ },

+ count: None,

+ }],

+ label: Some("uniform_bind_group_layout"),

+ });

+

+ let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {

+ layout: &uniform_bind_group_layout,

+ entries: &[wgpu::BindGroupEntry {

+ binding: 0,

+ resource: uniform_buffer.as_entire_binding(),

+ }],

+ label: Some("uniform_bind_group"),

+ });

+

+ //

+

+ let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {

+ label: None,

+ bind_group_layouts: &[&uniform_bind_group_layout], // &texture_bind_group_layout

+ push_constant_ranges: &[], // TODO: could use push constants for uniforms but that's not available on web

+ });

+

+ let swapchain_format = surface.get_preferred_format(&adapter).unwrap();

+

+ let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {

+ label: None,

+ layout: Some(&pipeline_layout),

+ vertex: wgpu::VertexState {

+ module: &shader,

+ entry_point: "vs_main",

+ buffers: &[wgpu::VertexBufferLayout {

+ array_stride: std::mem::size_of::<Vertex>() as wgpu::BufferAddress,

+ step_mode: wgpu::VertexStepMode::Vertex,

+ attributes: &wgpu::vertex_attr_array![0 => Float32x2],

+ }],

+ },

+ fragment: Some(wgpu::FragmentState {

+ module: &shader,

+ entry_point: "fs_main",

+ targets: &[swapchain_format.into()],

+ }),

+ primitive: wgpu::PrimitiveState::default(),

+ depth_stencil: None,

+ multisample: wgpu::MultisampleState {

+ count: sample_count,

+ ..Default::default()

+ },

+ multiview: None,

+ });

+

+ let mut config = wgpu::SurfaceConfiguration {

+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT,

+ format: swapchain_format,

+ width: size.width,

+ height: size.height,

+ present_mode: wgpu::PresentMode::Mailbox,

+ };

+

+ let mut multisampled_framebuffer =

+ create_multisampled_framebuffer(&device, &config, sample_count);

+

+ surface.configure(&device, &config);

+

+ //

+

+ event_loop.run(move |event, _, control_flow| {

+ // Have the closure take ownership of the resources.

+ // `event_loop.run` never returns, therefore we must do this to ensure

+ // the resources are properly cleaned up.

+ let _ = (&instance, &adapter, &shader, &pipeline_layout);

+

+ *control_flow = ControlFlow::Wait;

+ match event {

+ Event::WindowEvent {

+ event: WindowEvent::Resized(size),

+ ..

+ } => {

+ // Reconfigure the surface with the new size

+ config.width = size.width;

+ config.height = size.height;

+

+ multisampled_framebuffer =

+ create_multisampled_framebuffer(&device, &config, sample_count);

+

+ surface.configure(&device, &config);

+ // On macos the window needs to be redrawn manually after resizing

+ window.request_redraw();

+ }

+ Event::RedrawRequested(_) => {

+ let frame = surface

+ .get_current_texture()

+ .expect("Failed to acquire next swap chain texture");

+ let view = frame

+ .texture

+ .create_view(&wgpu::TextureViewDescriptor::default());

+ let mut encoder =

+ device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });

+

+ // TODO: need to use queue.write_buffer or staging_belt to write to it

+

+ // Pass the current window size in

+ let dpi_factor = window.scale_factor();

+ let size = window.inner_size();

+ let winit::dpi::LogicalSize { width, height } = size.to_logical::<f32>(dpi_factor);

+

+ let data = View {

+ size: [width, height],

+ };

+

+ queue.write_buffer(&uniform_buffer, 0, bytemuck::cast_slice(&[data]));

+

+ {

+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {

+ label: None,

+ color_attachments: &[wgpu::RenderPassColorAttachment {

+ view: &multisampled_framebuffer,

+ resolve_target: Some(&view),

+ ops: wgpu::Operations {

+ load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),

+ store: true,

+ },

+ }],

+ depth_stencil_attachment: None,

+ });

+

+ // rpass.set_viewport();

+

+ rpass.set_pipeline(&render_pipeline);

+ rpass.set_bind_group(0, &uniform_bind_group, &[]);

+ rpass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint16);

+ rpass.set_vertex_buffer(0, vertex_buffer.slice(..));

+ rpass.draw_indexed(0..(geometry.indices.len() as u32), 0, 0..1);

+ }

+

+ queue.submit(Some(encoder.finish()));

+ frame.present();

+ }

+ Event::WindowEvent {

+ event: WindowEvent::CloseRequested,

+ ..

+ } => *control_flow = ControlFlow::Exit,

+ _ => {}

+ }

+ });

+}

+

+fn main() {

+ let event_loop = EventLoop::new();

+ let window = winit::window::Window::new(&event_loop).unwrap();

+ #[cfg(not(target_arch = "wasm32"))]

+ {

+ env_logger::init();

+ // Temporarily avoid srgb formats for the swapchain on the web

+ pollster::block_on(run(event_loop, window));

+ }

+ #[cfg(target_arch = "wasm32")]

+ {

+ std::panic::set_hook(Box::new(console_error_panic_hook::hook));

+ console_log::init().expect("could not initialize logger");

+ use winit::platform::web::WindowExtWebSys;

+ // On wasm, append the canvas to the document body

+ web_sys::window()

+ .and_then(|win| win.document())

+ .and_then(|doc| doc.body())

+ .and_then(|body| {

+ body.append_child(&web_sys::Element::from(window.canvas()))

+ .ok()

+ })

+ .expect("couldn't append canvas to document body");

+ wasm_bindgen_futures::spawn_local(run(event_loop, window));

+ }

+}