Revert "Revert recent anti-aliasing improvements (#24289)" and fix selection top right corner radius issue (#24342)
Release Notes: - N/A ---- To fix #24289 mention issue and revert PathBuilder and MSAA. I'm sorry about of this, in #22808 I was forgotten this bit of detail.  So, add `move_to` here, we can fix the selection top right corner radius issue. ## After change <img width="1383" alt="image" src="https://github.com/user-attachments/assets/28ea103c-d652-41d6-bbe0-7fd042d81e77" />
This commit is contained in:
Jason Lee
GitHub
parent
1f2205d75c
commit
f08b1d78ec
13 changed files with 586 additions and 113 deletions
|
|
@ -82,6 +82,7 @@ mod input;
|
|||
mod interactive;
|
||||
mod key_dispatch;
|
||||
mod keymap;
|
||||
mod path_builder;
|
||||
mod platform;
|
||||
pub mod prelude;
|
||||
mod scene;
|
||||
|
|
@ -135,6 +136,7 @@ pub use input::*;
|
|||
pub use interactive::*;
|
||||
use key_dispatch::*;
|
||||
pub use keymap::*;
|
||||
pub use path_builder::*;
|
||||
pub use platform::*;
|
||||
pub use refineable::*;
|
||||
pub use scene::*;
|
||||
|
|
|
|||
241
crates/gpui/src/path_builder.rs
Normal file
241
crates/gpui/src/path_builder.rs
Normal file
|
|
@ -0,0 +1,241 @@
|
|||
use anyhow::Error;
|
||||
use etagere::euclid::Vector2D;
|
||||
use lyon::geom::Angle;
|
||||
use lyon::tessellation::{
|
||||
BuffersBuilder, FillTessellator, FillVertex, StrokeTessellator, StrokeVertex, VertexBuffers,
|
||||
};
|
||||
|
||||
pub use lyon::math::Transform;
|
||||
pub use lyon::tessellation::{FillOptions, FillRule, StrokeOptions};
|
||||
|
||||
use crate::{point, px, Path, Pixels, Point};
|
||||
|
||||
/// Style of the PathBuilder
|
||||
pub enum PathStyle {
|
||||
/// Stroke style
|
||||
Stroke(StrokeOptions),
|
||||
/// Fill style
|
||||
Fill(FillOptions),
|
||||
}
|
||||
|
||||
/// A [`Path`] builder.
|
||||
pub struct PathBuilder {
|
||||
raw: lyon::path::builder::WithSvg<lyon::path::BuilderImpl>,
|
||||
transform: Option<lyon::math::Transform>,
|
||||
/// PathStyle of the PathBuilder
|
||||
pub style: PathStyle,
|
||||
}
|
||||
|
||||
impl From<lyon::path::Builder> for PathBuilder {
|
||||
fn from(builder: lyon::path::Builder) -> Self {
|
||||
Self {
|
||||
raw: builder.with_svg(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<lyon::path::builder::WithSvg<lyon::path::BuilderImpl>> for PathBuilder {
|
||||
fn from(raw: lyon::path::builder::WithSvg<lyon::path::BuilderImpl>) -> Self {
|
||||
Self {
|
||||
raw,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<lyon::math::Point> for Point<Pixels> {
|
||||
fn from(p: lyon::math::Point) -> Self {
|
||||
point(px(p.x), px(p.y))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<Point<Pixels>> for lyon::math::Point {
|
||||
fn from(p: Point<Pixels>) -> Self {
|
||||
lyon::math::point(p.x.0, p.y.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for PathBuilder {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
raw: lyon::path::Path::builder().with_svg(),
|
||||
style: PathStyle::Fill(FillOptions::default()),
|
||||
transform: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PathBuilder {
|
||||
/// Creates a new [`PathBuilder`] to build a Stroke path.
|
||||
pub fn stroke(width: Pixels) -> Self {
|
||||
Self {
|
||||
style: PathStyle::Stroke(StrokeOptions::default().with_line_width(width.0)),
|
||||
..Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new [`PathBuilder`] to build a Fill path.
|
||||
pub fn fill() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
/// Sets the style of the [`PathBuilder`].
|
||||
pub fn with_style(self, style: PathStyle) -> Self {
|
||||
Self { style, ..self }
|
||||
}
|
||||
|
||||
/// Move the current point to the given point.
|
||||
#[inline]
|
||||
pub fn move_to(&mut self, to: Point<Pixels>) {
|
||||
self.raw.move_to(to.into());
|
||||
}
|
||||
|
||||
/// Draw a straight line from the current point to the given point.
|
||||
#[inline]
|
||||
pub fn line_to(&mut self, to: Point<Pixels>) {
|
||||
self.raw.line_to(to.into());
|
||||
}
|
||||
|
||||
/// Draw a curve from the current point to the given point, using the given control point.
|
||||
#[inline]
|
||||
pub fn curve_to(&mut self, to: Point<Pixels>, ctrl: Point<Pixels>) {
|
||||
self.raw.quadratic_bezier_to(ctrl.into(), to.into());
|
||||
}
|
||||
|
||||
/// Adds a cubic Bézier to the [`Path`] given its two control points
|
||||
/// and its end point.
|
||||
#[inline]
|
||||
pub fn cubic_bezier_to(
|
||||
&mut self,
|
||||
to: Point<Pixels>,
|
||||
control_a: Point<Pixels>,
|
||||
control_b: Point<Pixels>,
|
||||
) {
|
||||
self.raw
|
||||
.cubic_bezier_to(control_a.into(), control_b.into(), to.into());
|
||||
}
|
||||
|
||||
/// Close the current sub-path.
|
||||
#[inline]
|
||||
pub fn close(&mut self) {
|
||||
self.raw.close();
|
||||
}
|
||||
|
||||
/// Applies a transform to the path.
|
||||
#[inline]
|
||||
pub fn transform(&mut self, transform: Transform) {
|
||||
self.transform = Some(transform);
|
||||
}
|
||||
|
||||
/// Applies a translation to the path.
|
||||
#[inline]
|
||||
pub fn translate(&mut self, to: Point<Pixels>) {
|
||||
if let Some(transform) = self.transform {
|
||||
self.transform = Some(transform.then_translate(Vector2D::new(to.x.0, to.y.0)));
|
||||
} else {
|
||||
self.transform = Some(Transform::translation(to.x.0, to.y.0))
|
||||
}
|
||||
}
|
||||
|
||||
/// Applies a scale to the path.
|
||||
#[inline]
|
||||
pub fn scale(&mut self, scale: f32) {
|
||||
if let Some(transform) = self.transform {
|
||||
self.transform = Some(transform.then_scale(scale, scale));
|
||||
} else {
|
||||
self.transform = Some(Transform::scale(scale, scale));
|
||||
}
|
||||
}
|
||||
|
||||
/// Applies a rotation to the path.
|
||||
///
|
||||
/// The `angle` is in degrees value in the range 0.0 to 360.0.
|
||||
#[inline]
|
||||
pub fn rotate(&mut self, angle: f32) {
|
||||
let radians = angle.to_radians();
|
||||
if let Some(transform) = self.transform {
|
||||
self.transform = Some(transform.then_rotate(Angle::radians(radians)));
|
||||
} else {
|
||||
self.transform = Some(Transform::rotation(Angle::radians(radians)));
|
||||
}
|
||||
}
|
||||
|
||||
/// Builds into a [`Path`].
|
||||
#[inline]
|
||||
pub fn build(self) -> Result<Path<Pixels>, Error> {
|
||||
let path = if let Some(transform) = self.transform {
|
||||
self.raw.build().transformed(&transform)
|
||||
} else {
|
||||
self.raw.build()
|
||||
};
|
||||
|
||||
match self.style {
|
||||
PathStyle::Stroke(options) => Self::tessellate_stroke(&path, &options),
|
||||
PathStyle::Fill(options) => Self::tessellate_fill(&path, &options),
|
||||
}
|
||||
}
|
||||
|
||||
fn tessellate_fill(
|
||||
path: &lyon::path::Path,
|
||||
options: &FillOptions,
|
||||
) -> Result<Path<Pixels>, Error> {
|
||||
// Will contain the result of the tessellation.
|
||||
let mut buf: VertexBuffers<lyon::math::Point, u16> = VertexBuffers::new();
|
||||
let mut tessellator = FillTessellator::new();
|
||||
|
||||
// Compute the tessellation.
|
||||
tessellator.tessellate_path(
|
||||
path,
|
||||
options,
|
||||
&mut BuffersBuilder::new(&mut buf, |vertex: FillVertex| vertex.position()),
|
||||
)?;
|
||||
|
||||
Ok(Self::build_path(buf))
|
||||
}
|
||||
|
||||
fn tessellate_stroke(
|
||||
path: &lyon::path::Path,
|
||||
options: &StrokeOptions,
|
||||
) -> Result<Path<Pixels>, Error> {
|
||||
// Will contain the result of the tessellation.
|
||||
let mut buf: VertexBuffers<lyon::math::Point, u16> = VertexBuffers::new();
|
||||
let mut tessellator = StrokeTessellator::new();
|
||||
|
||||
// Compute the tessellation.
|
||||
tessellator.tessellate_path(
|
||||
path,
|
||||
options,
|
||||
&mut BuffersBuilder::new(&mut buf, |vertex: StrokeVertex| vertex.position()),
|
||||
)?;
|
||||
|
||||
Ok(Self::build_path(buf))
|
||||
}
|
||||
|
||||
/// Builds a [`Path`] from a [`lyon::VertexBuffers`].
|
||||
pub fn build_path(buf: VertexBuffers<lyon::math::Point, u16>) -> Path<Pixels> {
|
||||
if buf.vertices.is_empty() {
|
||||
return Path::new(Point::default());
|
||||
}
|
||||
|
||||
let first_point = buf.vertices[0];
|
||||
|
||||
let mut path = Path::new(first_point.into());
|
||||
for i in 0..buf.indices.len() / 3 {
|
||||
let i0 = buf.indices[i * 3] as usize;
|
||||
let i1 = buf.indices[i * 3 + 1] as usize;
|
||||
let i2 = buf.indices[i * 3 + 2] as usize;
|
||||
|
||||
let v0 = buf.vertices[i0];
|
||||
let v1 = buf.vertices[i1];
|
||||
let v2 = buf.vertices[i2];
|
||||
|
||||
path.push_triangle(
|
||||
(v0.into(), v1.into(), v2.into()),
|
||||
(point(0., 1.), point(0., 1.), point(0., 1.)),
|
||||
);
|
||||
}
|
||||
|
||||
path
|
||||
}
|
||||
}
|
||||
|
|
@ -27,6 +27,7 @@ struct BladeAtlasState {
|
|||
tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
|
||||
initializations: Vec<AtlasTextureId>,
|
||||
uploads: Vec<PendingUpload>,
|
||||
path_sample_count: u32,
|
||||
}
|
||||
|
||||
#[cfg(gles)]
|
||||
|
|
@ -42,10 +43,11 @@ impl BladeAtlasState {
|
|||
pub struct BladeTextureInfo {
|
||||
pub size: gpu::Extent,
|
||||
pub raw_view: gpu::TextureView,
|
||||
pub msaa_view: Option<gpu::TextureView>,
|
||||
}
|
||||
|
||||
impl BladeAtlas {
|
||||
pub(crate) fn new(gpu: &Arc<gpu::Context>) -> Self {
|
||||
pub(crate) fn new(gpu: &Arc<gpu::Context>, path_sample_count: u32) -> Self {
|
||||
BladeAtlas(Mutex::new(BladeAtlasState {
|
||||
gpu: Arc::clone(gpu),
|
||||
upload_belt: BufferBelt::new(BufferBeltDescriptor {
|
||||
|
|
@ -57,6 +59,7 @@ impl BladeAtlas {
|
|||
tiles_by_key: Default::default(),
|
||||
initializations: Vec::new(),
|
||||
uploads: Vec::new(),
|
||||
path_sample_count,
|
||||
}))
|
||||
}
|
||||
|
||||
|
|
@ -106,6 +109,7 @@ impl BladeAtlas {
|
|||
depth: 1,
|
||||
},
|
||||
raw_view: texture.raw_view,
|
||||
msaa_view: texture.msaa_view,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -204,6 +208,39 @@ impl BladeAtlasState {
|
|||
}
|
||||
}
|
||||
|
||||
// We currently only enable MSAA for path textures.
|
||||
let (msaa, msaa_view) = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
|
||||
let msaa = self.gpu.create_texture(gpu::TextureDesc {
|
||||
name: "msaa path texture",
|
||||
format,
|
||||
size: gpu::Extent {
|
||||
width: size.width.into(),
|
||||
height: size.height.into(),
|
||||
depth: 1,
|
||||
},
|
||||
array_layer_count: 1,
|
||||
mip_level_count: 1,
|
||||
sample_count: self.path_sample_count,
|
||||
dimension: gpu::TextureDimension::D2,
|
||||
usage: gpu::TextureUsage::TARGET,
|
||||
});
|
||||
|
||||
(
|
||||
Some(msaa),
|
||||
Some(self.gpu.create_texture_view(
|
||||
msaa,
|
||||
gpu::TextureViewDesc {
|
||||
name: "msaa texture view",
|
||||
format,
|
||||
dimension: gpu::ViewDimension::D2,
|
||||
subresources: &Default::default(),
|
||||
},
|
||||
)),
|
||||
)
|
||||
} else {
|
||||
(None, None)
|
||||
};
|
||||
|
||||
let raw = self.gpu.create_texture(gpu::TextureDesc {
|
||||
name: "atlas",
|
||||
format,
|
||||
|
|
@ -240,6 +277,8 @@ impl BladeAtlasState {
|
|||
format,
|
||||
raw,
|
||||
raw_view,
|
||||
msaa,
|
||||
msaa_view,
|
||||
live_atlas_keys: 0,
|
||||
};
|
||||
|
||||
|
|
@ -354,6 +393,8 @@ struct BladeAtlasTexture {
|
|||
allocator: BucketedAtlasAllocator,
|
||||
raw: gpu::Texture,
|
||||
raw_view: gpu::TextureView,
|
||||
msaa: Option<gpu::Texture>,
|
||||
msaa_view: Option<gpu::TextureView>,
|
||||
format: gpu::TextureFormat,
|
||||
live_atlas_keys: u32,
|
||||
}
|
||||
|
|
@ -381,6 +422,12 @@ impl BladeAtlasTexture {
|
|||
fn destroy(&mut self, gpu: &gpu::Context) {
|
||||
gpu.destroy_texture(self.raw);
|
||||
gpu.destroy_texture_view(self.raw_view);
|
||||
if let Some(msaa) = self.msaa {
|
||||
gpu.destroy_texture(msaa);
|
||||
}
|
||||
if let Some(msaa_view) = self.msaa_view {
|
||||
gpu.destroy_texture_view(msaa_view);
|
||||
}
|
||||
}
|
||||
|
||||
fn bytes_per_pixel(&self) -> u8 {
|
||||
|
|
|
|||
|
|
@ -7,16 +7,18 @@ use crate::{
|
|||
MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad,
|
||||
ScaledPixels, Scene, Shadow, Size, Underline,
|
||||
};
|
||||
use blade_graphics as gpu;
|
||||
use blade_util::{BufferBelt, BufferBeltDescriptor};
|
||||
use bytemuck::{Pod, Zeroable};
|
||||
use collections::HashMap;
|
||||
#[cfg(target_os = "macos")]
|
||||
use media::core_video::CVMetalTextureCache;
|
||||
|
||||
use blade_graphics as gpu;
|
||||
use blade_util::{BufferBelt, BufferBeltDescriptor};
|
||||
use std::{mem, sync::Arc};
|
||||
|
||||
const MAX_FRAME_TIME_MS: u32 = 10000;
|
||||
// Use 4x MSAA, all devices support it.
|
||||
// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
|
||||
const PATH_SAMPLE_COUNT: u32 = 4;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Clone, Copy, Pod, Zeroable)]
|
||||
|
|
@ -208,7 +210,10 @@ impl BladePipelines {
|
|||
blend: Some(gpu::BlendState::ADDITIVE),
|
||||
write_mask: gpu::ColorWrites::default(),
|
||||
}],
|
||||
multisample_state: gpu::MultisampleState::default(),
|
||||
multisample_state: gpu::MultisampleState {
|
||||
sample_count: PATH_SAMPLE_COUNT,
|
||||
..Default::default()
|
||||
},
|
||||
}),
|
||||
paths: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
|
||||
name: "paths",
|
||||
|
|
@ -348,7 +353,7 @@ impl BladeRenderer {
|
|||
min_chunk_size: 0x1000,
|
||||
alignment: 0x40, // Vulkan `minStorageBufferOffsetAlignment` on Intel Xe
|
||||
});
|
||||
let atlas = Arc::new(BladeAtlas::new(&context.gpu));
|
||||
let atlas = Arc::new(BladeAtlas::new(&context.gpu, PATH_SAMPLE_COUNT));
|
||||
let atlas_sampler = context.gpu.create_sampler(gpu::SamplerDesc {
|
||||
name: "atlas",
|
||||
mag_filter: gpu::FilterMode::Linear,
|
||||
|
|
@ -497,27 +502,38 @@ impl BladeRenderer {
|
|||
};
|
||||
|
||||
let vertex_buf = unsafe { self.instance_belt.alloc_typed(&vertices, &self.gpu) };
|
||||
let mut pass = self.command_encoder.render(
|
||||
let frame_view = tex_info.raw_view;
|
||||
let color_target = if let Some(msaa_view) = tex_info.msaa_view {
|
||||
gpu::RenderTarget {
|
||||
view: msaa_view,
|
||||
init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
|
||||
finish_op: gpu::FinishOp::ResolveTo(frame_view),
|
||||
}
|
||||
} else {
|
||||
gpu::RenderTarget {
|
||||
view: frame_view,
|
||||
init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
|
||||
finish_op: gpu::FinishOp::Store,
|
||||
}
|
||||
};
|
||||
|
||||
if let mut pass = self.command_encoder.render(
|
||||
"paths",
|
||||
gpu::RenderTargetSet {
|
||||
colors: &[gpu::RenderTarget {
|
||||
view: tex_info.raw_view,
|
||||
init_op: gpu::InitOp::Clear(gpu::TextureColor::OpaqueBlack),
|
||||
finish_op: gpu::FinishOp::Store,
|
||||
}],
|
||||
colors: &[color_target],
|
||||
depth_stencil: None,
|
||||
},
|
||||
);
|
||||
|
||||
let mut encoder = pass.with(&self.pipelines.path_rasterization);
|
||||
encoder.bind(
|
||||
0,
|
||||
&ShaderPathRasterizationData {
|
||||
globals,
|
||||
b_path_vertices: vertex_buf,
|
||||
},
|
||||
);
|
||||
encoder.draw(0, vertices.len() as u32, 0, 1);
|
||||
) {
|
||||
let mut encoder = pass.with(&self.pipelines.path_rasterization);
|
||||
encoder.bind(
|
||||
0,
|
||||
&ShaderPathRasterizationData {
|
||||
globals,
|
||||
b_path_vertices: vertex_buf,
|
||||
},
|
||||
);
|
||||
encoder.draw(0, vertices.len() as u32, 0, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,13 +13,14 @@ use std::borrow::Cow;
|
|||
pub(crate) struct MetalAtlas(Mutex<MetalAtlasState>);
|
||||
|
||||
impl MetalAtlas {
|
||||
pub(crate) fn new(device: Device) -> Self {
|
||||
pub(crate) fn new(device: Device, path_sample_count: u32) -> Self {
|
||||
MetalAtlas(Mutex::new(MetalAtlasState {
|
||||
device: AssertSend(device),
|
||||
monochrome_textures: Default::default(),
|
||||
polychrome_textures: Default::default(),
|
||||
path_textures: Default::default(),
|
||||
tiles_by_key: Default::default(),
|
||||
path_sample_count,
|
||||
}))
|
||||
}
|
||||
|
||||
|
|
@ -27,6 +28,10 @@ impl MetalAtlas {
|
|||
self.0.lock().texture(id).metal_texture.clone()
|
||||
}
|
||||
|
||||
pub(crate) fn msaa_texture(&self, id: AtlasTextureId) -> Option<metal::Texture> {
|
||||
self.0.lock().texture(id).msaa_texture.clone()
|
||||
}
|
||||
|
||||
pub(crate) fn allocate(
|
||||
&self,
|
||||
size: Size<DevicePixels>,
|
||||
|
|
@ -54,6 +59,7 @@ struct MetalAtlasState {
|
|||
polychrome_textures: AtlasTextureList<MetalAtlasTexture>,
|
||||
path_textures: AtlasTextureList<MetalAtlasTexture>,
|
||||
tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,
|
||||
path_sample_count: u32,
|
||||
}
|
||||
|
||||
impl PlatformAtlas for MetalAtlas {
|
||||
|
|
@ -176,6 +182,18 @@ impl MetalAtlasState {
|
|||
texture_descriptor.set_usage(usage);
|
||||
let metal_texture = self.device.new_texture(&texture_descriptor);
|
||||
|
||||
// We currently only enable MSAA for path textures.
|
||||
let msaa_texture = if self.path_sample_count > 1 && kind == AtlasTextureKind::Path {
|
||||
let mut descriptor = texture_descriptor.clone();
|
||||
descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);
|
||||
descriptor.set_storage_mode(metal::MTLStorageMode::Private);
|
||||
descriptor.set_sample_count(self.path_sample_count as _);
|
||||
let msaa_texture = self.device.new_texture(&descriptor);
|
||||
Some(msaa_texture)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let texture_list = match kind {
|
||||
AtlasTextureKind::Monochrome => &mut self.monochrome_textures,
|
||||
AtlasTextureKind::Polychrome => &mut self.polychrome_textures,
|
||||
|
|
@ -191,6 +209,7 @@ impl MetalAtlasState {
|
|||
},
|
||||
allocator: etagere::BucketedAtlasAllocator::new(size.into()),
|
||||
metal_texture: AssertSend(metal_texture),
|
||||
msaa_texture: AssertSend(msaa_texture),
|
||||
live_atlas_keys: 0,
|
||||
};
|
||||
|
||||
|
|
@ -217,6 +236,7 @@ struct MetalAtlasTexture {
|
|||
id: AtlasTextureId,
|
||||
allocator: BucketedAtlasAllocator,
|
||||
metal_texture: AssertSend<metal::Texture>,
|
||||
msaa_texture: AssertSend<Option<metal::Texture>>,
|
||||
live_atlas_keys: u32,
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -28,6 +28,9 @@ pub(crate) type PointF = crate::Point<f32>;
|
|||
const SHADERS_METALLIB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib"));
|
||||
#[cfg(feature = "runtime_shaders")]
|
||||
const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal"));
|
||||
// Use 4x MSAA, all devices support it.
|
||||
// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
|
||||
const PATH_SAMPLE_COUNT: u32 = 4;
|
||||
|
||||
pub type Context = Arc<Mutex<InstanceBufferPool>>;
|
||||
pub type Renderer = MetalRenderer;
|
||||
|
|
@ -170,6 +173,7 @@ impl MetalRenderer {
|
|||
"path_rasterization_vertex",
|
||||
"path_rasterization_fragment",
|
||||
MTLPixelFormat::R16Float,
|
||||
PATH_SAMPLE_COUNT,
|
||||
);
|
||||
let path_sprites_pipeline_state = build_pipeline_state(
|
||||
&device,
|
||||
|
|
@ -229,7 +233,7 @@ impl MetalRenderer {
|
|||
);
|
||||
|
||||
let command_queue = device.new_command_queue();
|
||||
let sprite_atlas = Arc::new(MetalAtlas::new(device.clone()));
|
||||
let sprite_atlas = Arc::new(MetalAtlas::new(device.clone(), PATH_SAMPLE_COUNT));
|
||||
let core_video_texture_cache =
|
||||
unsafe { CVMetalTextureCache::new(device.as_ptr()).unwrap() };
|
||||
|
||||
|
|
@ -531,10 +535,20 @@ impl MetalRenderer {
|
|||
.unwrap();
|
||||
|
||||
let texture = self.sprite_atlas.metal_texture(texture_id);
|
||||
color_attachment.set_texture(Some(&texture));
|
||||
color_attachment.set_load_action(metal::MTLLoadAction::Clear);
|
||||
color_attachment.set_store_action(metal::MTLStoreAction::Store);
|
||||
let msaa_texture = self.sprite_atlas.msaa_texture(texture_id);
|
||||
|
||||
if let Some(msaa_texture) = msaa_texture {
|
||||
color_attachment.set_texture(Some(&msaa_texture));
|
||||
color_attachment.set_resolve_texture(Some(&texture));
|
||||
color_attachment.set_load_action(metal::MTLLoadAction::Clear);
|
||||
color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);
|
||||
} else {
|
||||
color_attachment.set_texture(Some(&texture));
|
||||
color_attachment.set_load_action(metal::MTLLoadAction::Clear);
|
||||
color_attachment.set_store_action(metal::MTLStoreAction::Store);
|
||||
}
|
||||
color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., 1.));
|
||||
|
||||
let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);
|
||||
command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state);
|
||||
command_encoder.set_vertex_buffer(
|
||||
|
|
@ -1160,6 +1174,7 @@ fn build_path_rasterization_pipeline_state(
|
|||
vertex_fn_name: &str,
|
||||
fragment_fn_name: &str,
|
||||
pixel_format: metal::MTLPixelFormat,
|
||||
path_sample_count: u32,
|
||||
) -> metal::RenderPipelineState {
|
||||
let vertex_fn = library
|
||||
.get_function(vertex_fn_name, None)
|
||||
|
|
@ -1172,6 +1187,10 @@ fn build_path_rasterization_pipeline_state(
|
|||
descriptor.set_label(label);
|
||||
descriptor.set_vertex_function(Some(vertex_fn.as_ref()));
|
||||
descriptor.set_fragment_function(Some(fragment_fn.as_ref()));
|
||||
if path_sample_count > 1 {
|
||||
descriptor.set_raster_sample_count(path_sample_count as _);
|
||||
descriptor.set_alpha_to_coverage_enabled(true);
|
||||
}
|
||||
let color_attachment = descriptor.color_attachments().object_at(0).unwrap();
|
||||
color_attachment.set_pixel_format(pixel_format);
|
||||
color_attachment.set_blending_enabled(true);
|
||||
|
|
|
|||
|
|
@ -715,6 +715,13 @@ impl Path<Pixels> {
|
|||
}
|
||||
}
|
||||
|
||||
/// Move the start, current point to the given point.
|
||||
pub fn move_to(&mut self, to: Point<Pixels>) {
|
||||
self.contour_count += 1;
|
||||
self.start = to;
|
||||
self.current = to;
|
||||
}
|
||||
|
||||
/// Draw a straight line from the current point to the given point.
|
||||
pub fn line_to(&mut self, to: Point<Pixels>) {
|
||||
self.contour_count += 1;
|
||||
|
|
@ -744,7 +751,8 @@ impl Path<Pixels> {
|
|||
self.current = to;
|
||||
}
|
||||
|
||||
fn push_triangle(
|
||||
/// Push a triangle to the Path.
|
||||
pub fn push_triangle(
|
||||
&mut self,
|
||||
xy: (Point<Pixels>, Point<Pixels>, Point<Pixels>),
|
||||
st: (Point<f32>, Point<f32>, Point<f32>),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue