roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-22 08:17:40 +03:00
Code Issues Packages Projects Releases Wiki Activity

highlight all text in editor

Browse Source
This commit is contained in:
Anton-4 2020-12-21 19:49:15 +01:00
parent b5dcde267a
commit d89bf1c0af
4 changed files with 108 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
editor/src/buffer.rs
View File

@ -87,21 +87,8 @@ pub struct RectBuffers {
pub fn create_rect_buffers(
gpu_device: &wgpu::Device,
encoder: &mut wgpu::CommandEncoder,
rects: &[Rect]
) -> RectBuffers {
// Test Rectangles
let test_rect_1 = Rect {
top_left_coords: (0.0, 0.0).into(),
width: 400.0,
height: 300.0,
color: [1.0, 0.0, 0.0],
};
let test_rect_2 = Rect {
top_left_coords: (400.0, 300.0).into(),
width: 400.0,
height: 300.0,
color: [0.0, 0.0, 1.0],
};
let vertex_buffer = gpu_device.create_buffer(&wgpu::BufferDescriptor {
label: None,
size: Vertex::SIZE * 4 * 3,
@ -119,10 +106,14 @@ pub fn create_rect_buffers(
});
let num_rects = {
let (stg_vertex, stg_index, num_indices) = QuadBufferBuilder::new()
.push_rect(&test_rect_1)
.push_rect(&test_rect_2)
.build(&gpu_device);
let mut quad_buffer_builder = QuadBufferBuilder::new();
for rect in rects {
quad_buffer_builder = quad_buffer_builder.push_rect(&rect);
}
let (stg_vertex, stg_index, num_indices) =
quad_buffer_builder.build(&gpu_device);
stg_vertex.copy_to_buffer(encoder, &vertex_buffer);
stg_index.copy_to_buffer(encoder, &index_buffer);

101
editor/src/lib.rs
View File

@ -11,6 +11,7 @@
use crate::buffer::create_rect_buffers;
use crate::text::{build_glyph_brush, Text};
use crate::vertex::Vertex;
use crate::rect::{convert_rect};
use ortho::{init_ortho, update_ortho_buffer, OrthoResources};
use std::error::Error;
use std::io;
@ -18,6 +19,7 @@ use std::path::Path;
use winit::event;
use winit::event::{Event, ModifiersState};
use winit::event_loop::ControlFlow;
use wgpu_glyph::{ab_glyph};
pub mod ast;
mod buffer;
@ -189,42 +191,58 @@ fn run_event_loop() -> Result<(), Box<dyn Error>> {
label: Some("Redraw"),
});
let rect_buffers = create_rect_buffers(&gpu_device, &mut encoder);
let frame = swap_chain
let frame = swap_chain
.get_current_frame()
.expect("Failed to acquire next SwapChainFrame")
.output;
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
resolve_target: None,
ops: wgpu::Operations::default(),
}],
depth_stencil_attachment: None,
});
if rect_buffers.num_rects > 0 {
render_pass.set_pipeline(&rect_pipeline);
render_pass.set_bind_group(0, &ortho.bind_group, &[]);
render_pass.set_vertex_buffer(0, rect_buffers.vertex_buffer.slice(..));
render_pass.set_index_buffer(rect_buffers.index_buffer.slice(..));
render_pass.draw_indexed(0..rect_buffers.num_rects, 0, 0..1);
}
drop(render_pass);
draw_all_text(
&gpu_device,
&mut staging_belt,
&mut encoder,
&frame,
let text_bounds_rect_opt = queue_all_text(
&size,
&text_state,
&mut glyph_brush,
);
match text_bounds_rect_opt {
Some(ab_bounds_rect) => {
let rect_buffers = create_rect_buffers(
&gpu_device,
&mut encoder,
&[convert_rect(ab_bounds_rect, [255.0, 255.0, 255.0])],
);
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
resolve_target: None,
ops: wgpu::Operations::default(),
}],
depth_stencil_attachment: None,
});
render_pass.set_pipeline(&rect_pipeline);
render_pass.set_bind_group(0, &ortho.bind_group, &[]);
render_pass.set_vertex_buffer(0, rect_buffers.vertex_buffer.slice(..));
render_pass.set_index_buffer(rect_buffers.index_buffer.slice(..));
render_pass.draw_indexed(0..rect_buffers.num_rects, 0, 0..1);
drop(render_pass);
},
None =>
(),
};
// draw all text
glyph_brush
.draw_queued(
&gpu_device,
&mut staging_belt,
&mut encoder,
&frame.view,
size.width,
size.height,
)
.expect("Draw queued");
staging_belt.finish();
cmd_queue.submit(Some(encoder.finish()));
@ -308,20 +326,16 @@ fn create_render_pipeline(
})
}
fn draw_all_text(
gpu_device: &wgpu::Device,
staging_belt: &mut wgpu::util::StagingBelt,
encoder: &mut wgpu::CommandEncoder,
frame: &wgpu::SwapChainTexture,
fn queue_all_text(
size: &winit::dpi::PhysicalSize<u32>,
text_state: &str,
glyph_brush: &mut wgpu_glyph::GlyphBrush<()>,
) {
let bounds = (size.width as f32, size.height as f32).into();
) -> Option<ab_glyph::Rect> {
let area_bounds = (size.width as f32, size.height as f32).into();
let main_label = Text {
position: (30.0, 30.0).into(),
bounds,
area_bounds,
color: (0.4666, 0.2, 1.0, 1.0).into(),
text: String::from("Enter some text:"),
size: 40.0,
@ -330,8 +344,8 @@ fn draw_all_text(
let code_text = Text {
position: (30.0, 90.0).into(),
bounds,
color: (1.0, 1.0, 1.0, 1.0).into(),
area_bounds,
color: (0.0, 0.05, 0.46, 1.0).into(),
text: String::from(format!("{}|", text_state).as_str()),
size: 40.0,
..Default::default()
@ -339,18 +353,9 @@ fn draw_all_text(
text::queue_text_draw(&main_label, glyph_brush);
text::queue_text_draw(&code_text, glyph_brush);
let code_bounds_rect_opt = text::queue_text_draw(&code_text, glyph_brush);
glyph_brush
.draw_queued(
gpu_device,
staging_belt,
encoder,
&frame.view,
size.width,
size.height,
)
.expect("Draw queued");
code_bounds_rect_opt
}
fn update_text_state(text_state: &mut String, received_char: &char) {

10
editor/src/rect.rs
View File

@ -1,4 +1,5 @@
use cgmath::Vector2;
use wgpu_glyph::{ab_glyph};
pub struct Rect {
pub top_left_coords: Vector2<f32>,
@ -6,3 +7,12 @@ pub struct Rect {
pub height: f32,
pub color: [f32; 3],
}
pub fn convert_rect(glyph_rect: ab_glyph::Rect, color: [f32; 3]) -> Rect {
Rect {
top_left_coords: [glyph_rect.min.x, glyph_rect.min.y].into(),
width: glyph_rect.width(),
height: glyph_rect.height(),
color
}
}

44
editor/src/text.rs
View File

@ -3,12 +3,12 @@
use ab_glyph::{FontArc, InvalidFont};
use cgmath::{Vector2, Vector4};
use wgpu_glyph::{ab_glyph, GlyphBrush, GlyphBrushBuilder, Section};
use wgpu_glyph::{ab_glyph, GlyphBrush, GlyphBrushBuilder, GlyphCruncher, Section};
#[derive(Debug)]
pub struct Text {
pub position: Vector2<f32>,
pub bounds: Vector2<f32>,
pub area_bounds: Vector2<f32>,
pub color: Vector4<f32>,
pub text: String,
pub size: f32,
@ -20,7 +20,7 @@ impl Default for Text {
fn default() -> Self {
Self {
position: (0.0, 0.0).into(),
bounds: (std::f32::INFINITY, std::f32::INFINITY).into(),
area_bounds: (std::f32::INFINITY, std::f32::INFINITY).into(),
color: (1.0, 1.0, 1.0, 1.0).into(),
text: String::new(),
size: 16.0,
@ -30,7 +30,7 @@ impl Default for Text {
}
}
pub fn queue_text_draw(text: &Text, glyph_brush: &mut GlyphBrush<()>) {
pub fn queue_text_draw(text: &Text, glyph_brush: &mut GlyphBrush<()>) -> Option<ab_glyph::Rect>{
let layout = wgpu_glyph::Layout::default().h_align(if text.centered {
wgpu_glyph::HorizontalAlign::Center
} else {
@ -39,17 +39,18 @@ pub fn queue_text_draw(text: &Text, glyph_brush: &mut GlyphBrush<()>) {
let section = Section {
screen_position: text.position.into(),
bounds: text.bounds.into(),
bounds: text.area_bounds.into(),
layout,
..Section::default()
}
.add_text(
}.add_text(
wgpu_glyph::Text::new(&text.text)
.with_color(text.color)
.with_scale(text.size),
);
glyph_brush.queue(section);
glyph_brush.queue(section.clone());
glyph_brush.glyph_bounds_custom_layout(section, &layout)
}
pub fn build_glyph_brush(
@ -60,3 +61,30 @@ pub fn build_glyph_brush(
Ok(GlyphBrushBuilder::using_font(inconsolata).build(&gpu_device, render_format))
}
/*fn my_draw_text(&mut self, ...) {
let layout = ...;
let section = ...;
// Avoid re-allocating new vec's every time by storing them internally
self.last_glyphs.clear();
self.last_bounds.clear();
// Get all the glyphs for the current section to calculate their bounds. Due to
// mutable borrow, this must be stored first.
self.last_glyphs
.extend(self.brush.glyphs_custom_layout(&s, &layout).cloned());
// Calculate the bounds of each glyph
self.last_bounds
.extend(self.last_glyphs.iter().map(|glyph| {
let bounds = &fonts[glyph.font_id.0].glyph_bounds(&glyph.glyph);
Rect::new(
Vec2::new(bounds.min.x, bounds.min.y),
Vec2::new(bounds.max.x, bounds.max.y),
)
}));
// Queue the glyphs for drawing
self.brush.queue_custom_layout(s, &layout);
}*/