Enable Blade on MacOS via "macos-blade" feature (#7669)

Depends on https://github.com/zed-industries/font-kit/pull/2 and
https://github.com/kvark/blade/pull/77

This change enables Blade to be also used on MacOS. It will also make it
easier to use it on Windows.

What works: most of the things. Zed loads as fast and appears equally
responsive to the current renderer.
<img width="306" alt="Screenshot 2024-02-11 at 12 09 15 AM"
src="https://github.com/zed-industries/zed/assets/107301/66d82f45-5ea2-4e2b-86c6-5b3ed333c827">

Things missing:
- [x] video streaming. ~~Requires a bit of plumbing on both Blade and
Zed sides, but all fairly straightforward.~~
  -  verified with a local setup
- [x] resize. ~~Not sure where exactly to hook up the reaction on the
window size change. Once we know where, the fix is one line.~~
- [ ] fine-tune CA Layer
- this isn't a blocker for merging the PR, but it would be a blocker if
we wanted to switch to the new path by default
- [ ] rebase on latest, get the dependency merged (need review/merge of
https://github.com/zed-industries/font-kit/pull/2!)

Update: I implemented resize support as well as "surface" rendering on
the Blade path (which will be useful on Linux/Windows later on). I
haven't tested the latter though - not sure how to get something
streaming. Would appreciate some help! I don't think this should be a
blocker to this PR, anyway.

The only little piece that's missing for the Blade on MacOS path to be
full-featured is fine-tuning the CALayer configuration. Zed does a lot
of careful logic in configuring the layer, such as switching the
"present with transaction" on/off intermittently, which Blade path
doesn't have yet.

Release Notes:
- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>
This commit is contained in:
Dzmitry Malyshau 2024-02-16 13:39:40 -08:00 committed by GitHub
parent 1c361ac579
commit 9ad1862f2f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
23 changed files with 492 additions and 163 deletions

View File

@ -91,8 +91,8 @@ jobs:
- name: Build collab
run: cargo build -p collab
- name: Build other binaries
run: cargo build --workspace --bins --all-features
- name: Build other binaries and features
run: cargo build --workspace --bins --all-features; cargo check -p gpui --features "macos-blade"
# todo!(linux): Actually run the tests
linux_tests:

42
Cargo.lock generated
View File

@ -1396,7 +1396,7 @@ dependencies = [
[[package]]
name = "blade-graphics"
version = "0.3.0"
source = "git+https://github.com/kvark/blade?rev=c4f951a88b345724cb952e920ad30e39851f7760#c4f951a88b345724cb952e920ad30e39851f7760"
source = "git+https://github.com/kvark/blade?rev=e9d93a4d41f3946a03ffb76136290d6ccf7f2b80#e9d93a4d41f3946a03ffb76136290d6ccf7f2b80"
dependencies = [
"ash",
"ash-window",
@ -1413,7 +1413,7 @@ dependencies = [
"khronos-egl",
"libloading 0.8.0",
"log",
"metal 0.25.0",
"metal",
"mint",
"naga",
"objc",
@ -1426,7 +1426,7 @@ dependencies = [
[[package]]
name = "blade-macros"
version = "0.2.1"
source = "git+https://github.com/kvark/blade?rev=c4f951a88b345724cb952e920ad30e39851f7760#c4f951a88b345724cb952e920ad30e39851f7760"
source = "git+https://github.com/kvark/blade?rev=e9d93a4d41f3946a03ffb76136290d6ccf7f2b80#e9d93a4d41f3946a03ffb76136290d6ccf7f2b80"
dependencies = [
"proc-macro2",
"quote",
@ -2359,13 +2359,13 @@ dependencies = [
[[package]]
name = "core-text"
version = "19.2.0"
version = "20.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99d74ada66e07c1cefa18f8abfba765b486f250de2e4a999e5727fc0dd4b4a25"
checksum = "c9d2790b5c08465d49f8dc05c8bcae9fea467855947db39b0f8145c091aaced5"
dependencies = [
"core-foundation",
"core-graphics 0.22.3",
"foreign-types 0.3.2",
"core-graphics 0.23.1",
"foreign-types 0.5.0",
"libc",
]
@ -3511,12 +3511,12 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "font-kit"
version = "0.11.0"
source = "git+https://github.com/zed-industries/font-kit?rev=d97147f#d97147ff11a9024b9707d9c9c7e3a0bdaba048ac"
source = "git+https://github.com/zed-industries/font-kit?rev=5a5c4d4#5a5c4d4ca395c74eb0abde38508e170ce0fd761a"
dependencies = [
"bitflags 1.3.2",
"byteorder",
"core-foundation",
"core-graphics 0.22.3",
"core-graphics 0.23.1",
"core-text",
"dirs-next",
"dwrote",
@ -4085,7 +4085,7 @@ dependencies = [
"cocoa",
"collections",
"core-foundation",
"core-graphics 0.22.3",
"core-graphics 0.23.1",
"core-text",
"cosmic-text",
"ctor",
@ -4095,7 +4095,7 @@ dependencies = [
"etagere",
"flume",
"font-kit",
"foreign-types 0.3.2",
"foreign-types 0.5.0",
"futures 0.3.28",
"gpui_macros",
"image",
@ -4104,7 +4104,7 @@ dependencies = [
"linkme",
"log",
"media",
"metal 0.21.0",
"metal",
"num_cpus",
"objc",
"open",
@ -5350,8 +5350,8 @@ dependencies = [
"block",
"bytes 1.5.0",
"core-foundation",
"foreign-types 0.3.2",
"metal 0.21.0",
"foreign-types 0.5.0",
"metal",
"objc",
]
@ -5423,20 +5423,6 @@ dependencies = [
"serde",
]
[[package]]
name = "metal"
version = "0.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4598d719460ade24c7d91f335daf055bf2a7eec030728ce751814c50cdd6a26c"
dependencies = [
"bitflags 1.3.2",
"block",
"cocoa-foundation",
"foreign-types 0.3.2",
"log",
"objc",
]
[[package]]
name = "metal"
version = "0.25.0"

View File

@ -181,6 +181,9 @@ anyhow = "1.0.57"
async-compression = { version = "0.4", features = ["gzip", "futures-io"] }
async-tar = "0.4.2"
async-trait = "0.1"
blade-graphics = { git = "https://github.com/kvark/blade", rev = "e9d93a4d41f3946a03ffb76136290d6ccf7f2b80" }
blade-macros = { git = "https://github.com/kvark/blade", rev = "e9d93a4d41f3946a03ffb76136290d6ccf7f2b80" }
blade-rwh = { package = "raw-window-handle", version = "0.5" }
chrono = { version = "0.4", features = ["serde"] }
ctor = "0.2.6"
derive_more = "0.99.17"

View File

@ -16,6 +16,7 @@ test-support = [
"util/test-support",
]
runtime_shaders = []
macos-blade = ["blade-graphics", "blade-macros", "blade-rwh", "bytemuck"]
[lib]
path = "src/gpui.rs"
@ -26,6 +27,10 @@ anyhow.workspace = true
async-task = "4.7"
backtrace = { version = "0.3", optional = true }
bitflags = "2.4.0"
blade-graphics = { workspace = true, optional = true }
blade-macros = { workspace = true, optional = true }
blade-rwh = { workspace = true, optional = true }
bytemuck = { version = "1", optional = true }
collections.workspace = true
ctor.workspace = true
derive_more.workspace = true
@ -33,7 +38,7 @@ dhat = { version = "0.3", optional = true }
env_logger = { version = "0.9", optional = true }
etagere = "0.2"
futures.workspace = true
font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "d97147f" }
font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "5a5c4d4" }
gpui_macros.workspace = true
image = "0.23"
itertools = "0.10"
@ -48,7 +53,6 @@ pathfinder_geometry = "0.5"
postage.workspace = true
rand.workspace = true
raw-window-handle = "0.6"
blade-rwh = { package = "raw-window-handle", version = "0.5" }
refineable.workspace = true
resvg = "0.14"
schemars.workspace = true
@ -86,12 +90,12 @@ cbindgen = "0.26.0"
block = "0.1"
cocoa = "0.25"
core-foundation = { version = "0.9.3", features = ["with-uuid"] }
core-graphics = "0.22.3"
core-text = "19.2"
foreign-types = "0.3"
core-graphics = "0.23"
core-text = "20.1"
foreign-types = "0.5"
log.workspace = true
media.workspace = true
metal = "0.21.0"
metal = "0.25"
objc = "0.2"
[target.'cfg(target_os = "linux")'.dependencies]
@ -105,8 +109,9 @@ wayland-protocols = { version = "0.31.2", features = ["client"] }
wayland-backend = { version = "0.3.3", features = ["client_system"] }
as-raw-xcb-connection = "1"
#TODO: use these on all platforms
blade-graphics = { git = "https://github.com/kvark/blade", rev = "c4f951a88b345724cb952e920ad30e39851f7760" }
blade-macros = { git = "https://github.com/kvark/blade", rev = "c4f951a88b345724cb952e920ad30e39851f7760" }
blade-graphics.workspace = true
blade-macros.workspace = true
blade-rwh.workspace = true
bytemuck = "1"
cosmic-text = "0.10.0"
xkbcommon = { version = "0.7", features = ["x11"] }

View File

@ -1,4 +1,4 @@
#![cfg_attr(not(target_os = "macos"), allow(unused))]
#![cfg_attr(any(not(target_os = "macos"), feature = "macos-blade"), allow(unused))]
use std::{
env,
@ -7,15 +7,18 @@ use std::{
use cbindgen::Config;
//TODO: consider generating shader code for WGSL
//TODO: deprecate "runtime-shaders" and "macos-blade"
fn main() {
#[cfg(target_os = "macos")]
generate_dispatch_bindings();
#[cfg(target_os = "macos")]
#[cfg(all(target_os = "macos", not(feature = "macos-blade")))]
let header_path = generate_shader_bindings();
#[cfg(target_os = "macos")]
#[cfg(all(target_os = "macos", not(feature = "macos-blade")))]
#[cfg(feature = "runtime_shaders")]
emit_stitched_shaders(&header_path);
#[cfg(target_os = "macos")]
#[cfg(all(target_os = "macos", not(feature = "macos-blade")))]
#[cfg(not(feature = "runtime_shaders"))]
compile_metal_shaders(&header_path);
}

View File

@ -60,8 +60,9 @@
//! and will be publishing more guides to GPUI on our [blog](https://zed.dev/blog).
#![deny(missing_docs)]
#![allow(clippy::type_complexity)]
#![allow(clippy::collapsible_else_if)]
#![allow(clippy::type_complexity)] // Not useful, GPUI makes heavy use of callbacks
#![allow(clippy::collapsible_else_if)] // False positives in platform specific code
#![allow(unused_mut)] // False positives in platform specific code
#[macro_use]
mod action;

View File

@ -3,10 +3,16 @@
mod app_menu;
mod keystroke;
#[cfg(target_os = "linux")]
mod linux;
#[cfg(target_os = "macos")]
mod mac;
#[cfg(any(target_os = "linux", feature = "macos-blade"))]
mod blade;
#[cfg(any(test, feature = "test-support"))]
mod test;

View File

@ -0,0 +1,8 @@
mod blade_atlas;
mod blade_belt;
mod blade_renderer;
pub(crate) use blade_atlas::*;
pub(crate) use blade_renderer::*;
use blade_belt::*;

View File

@ -1,14 +1,18 @@
// Doing `if let` gives you nice scoping with passes/encoders
#![allow(irrefutable_let_patterns)]
use super::{BladeBelt, BladeBeltDescriptor};
use super::{BladeAtlas, BladeBelt, BladeBeltDescriptor, PATH_TEXTURE_FORMAT};
use crate::{
AtlasTextureKind, AtlasTile, BladeAtlas, Bounds, ContentMask, Hsla, MonochromeSprite, Path,
PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow,
Underline, PATH_TEXTURE_FORMAT,
AtlasTextureKind, AtlasTile, Bounds, ContentMask, Hsla, MonochromeSprite, Path, PathId,
PathVertex, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,
Underline,
};
use bytemuck::{Pod, Zeroable};
use collections::HashMap;
#[cfg(target_os = "macos")]
use media::core_video::CVMetalTextureCache;
#[cfg(target_os = "macos")]
use std::ffi::c_void;
use blade_graphics as gpu;
use std::{mem, sync::Arc};
@ -16,6 +20,61 @@ use std::{mem, sync::Arc};
const SURFACE_FRAME_COUNT: u32 = 3;
const MAX_FRAME_TIME_MS: u32 = 1000;
pub type Context = ();
pub type Renderer = BladeRenderer;
#[cfg(target_os = "macos")]
pub unsafe fn new_renderer(
_context: self::Context,
native_window: *mut c_void,
native_view: *mut c_void,
bounds: crate::Size<f32>,
) -> Renderer {
struct RawWindow {
window: *mut c_void,
view: *mut c_void,
}
unsafe impl blade_rwh::HasRawWindowHandle for RawWindow {
fn raw_window_handle(&self) -> blade_rwh::RawWindowHandle {
let mut wh = blade_rwh::AppKitWindowHandle::empty();
wh.ns_window = self.window;
wh.ns_view = self.view;
wh.into()
}
}
unsafe impl blade_rwh::HasRawDisplayHandle for RawWindow {
fn raw_display_handle(&self) -> blade_rwh::RawDisplayHandle {
let dh = blade_rwh::AppKitDisplayHandle::empty();
dh.into()
}
}
let gpu = Arc::new(
gpu::Context::init_windowed(
&RawWindow {
window: native_window as *mut _,
view: native_view as *mut _,
},
gpu::ContextDesc {
validation: cfg!(debug_assertions),
capture: false,
},
)
.unwrap(),
);
BladeRenderer::new(
gpu,
gpu::Extent {
width: bounds.width as u32,
height: bounds.height as u32,
depth: 1,
},
)
}
#[repr(C)]
#[derive(Clone, Copy, Pod, Zeroable)]
struct GlobalParams {
@ -23,6 +82,31 @@ struct GlobalParams {
pad: [u32; 2],
}
//Note: we can't use `Bounds` directly here because
// it doesn't implement Pod + Zeroable
#[repr(C)]
#[derive(Clone, Copy, Pod, Zeroable)]
struct PodBounds {
origin: [f32; 2],
size: [f32; 2],
}
impl From<Bounds<ScaledPixels>> for PodBounds {
fn from(bounds: Bounds<ScaledPixels>) -> Self {
Self {
origin: [bounds.origin.x.0, bounds.origin.y.0],
size: [bounds.size.width.0, bounds.size.height.0],
}
}
}
#[repr(C)]
#[derive(Clone, Copy, Pod, Zeroable)]
struct SurfaceParams {
bounds: PodBounds,
content_mask: PodBounds,
}
#[derive(blade_macros::ShaderData)]
struct ShaderQuadsData {
globals: GlobalParams,
@ -71,6 +155,15 @@ struct ShaderPolySpritesData {
b_poly_sprites: gpu::BufferPiece,
}
#[derive(blade_macros::ShaderData)]
struct ShaderSurfacesData {
globals: GlobalParams,
surface_locals: SurfaceParams,
t_y: gpu::TextureView,
t_cb_cr: gpu::TextureView,
s_surface: gpu::Sampler,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[repr(C)]
struct PathSprite {
@ -87,6 +180,7 @@ struct BladePipelines {
underlines: gpu::RenderPipeline,
mono_sprites: gpu::RenderPipeline,
poly_sprites: gpu::RenderPipeline,
surfaces: gpu::RenderPipeline,
}
impl BladePipelines {
@ -96,6 +190,8 @@ impl BladePipelines {
let shader = gpu.create_shader(gpu::ShaderDesc {
source: include_str!("shaders.wgsl"),
});
shader.check_struct_size::<GlobalParams>();
shader.check_struct_size::<SurfaceParams>();
shader.check_struct_size::<Quad>();
shader.check_struct_size::<Shadow>();
assert_eq!(
@ -220,6 +316,22 @@ impl BladePipelines {
write_mask: gpu::ColorWrites::default(),
}],
}),
surfaces: gpu.create_render_pipeline(gpu::RenderPipelineDesc {
name: "surfaces",
data_layouts: &[&ShaderSurfacesData::layout()],
vertex: shader.at("vs_surface"),
primitive: gpu::PrimitiveState {
topology: gpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: None,
fragment: shader.at("fs_surface"),
color_targets: &[gpu::ColorTargetState {
format: surface_format,
blend: Some(gpu::BlendState::ALPHA_BLENDING),
write_mask: gpu::ColorWrites::default(),
}],
}),
}
}
}
@ -234,6 +346,8 @@ pub struct BladeRenderer {
path_tiles: HashMap<PathId, AtlasTile>,
atlas: Arc<BladeAtlas>,
atlas_sampler: gpu::Sampler,
#[cfg(target_os = "macos")]
core_video_texture_cache: CVMetalTextureCache,
}
impl BladeRenderer {
@ -268,6 +382,12 @@ impl BladeRenderer {
..Default::default()
});
#[cfg(target_os = "macos")]
let core_video_texture_cache = unsafe {
use foreign_types::ForeignType as _;
CVMetalTextureCache::new(gpu.metal_device().as_ptr()).unwrap()
};
Self {
gpu,
command_encoder,
@ -278,6 +398,8 @@ impl BladeRenderer {
path_tiles: HashMap::default(),
atlas,
atlas_sampler,
#[cfg(target_os = "macos")]
core_video_texture_cache,
}
}
@ -289,27 +411,39 @@ impl BladeRenderer {
}
}
pub fn destroy(&mut self) {
self.wait_for_gpu();
self.atlas.destroy();
self.instance_belt.destroy(&self.gpu);
self.gpu.destroy_command_encoder(&mut self.command_encoder);
}
pub fn update_drawable_size(&mut self, size: Size<f64>) {
let gpu_size = gpu::Extent {
width: size.width as u32,
height: size.height as u32,
depth: 1,
};
pub fn resize(&mut self, size: gpu::Extent) {
self.wait_for_gpu();
self.gpu.resize(Self::make_surface_config(size));
self.viewport_size = size;
if gpu_size != self.viewport_size() {
self.wait_for_gpu();
self.gpu.resize(Self::make_surface_config(gpu_size));
self.viewport_size = gpu_size;
}
}
pub fn viewport_size(&self) -> gpu::Extent {
self.viewport_size
}
pub fn atlas(&self) -> &Arc<BladeAtlas> {
pub fn sprite_atlas(&self) -> &Arc<BladeAtlas> {
&self.atlas
}
#[cfg(target_os = "macos")]
pub fn layer(&self) -> metal::MetalLayer {
self.gpu.metal_layer().unwrap()
}
#[cfg(target_os = "macos")]
pub fn layer_ptr(&self) -> *mut metal::CAMetalLayer {
use metal::foreign_types::ForeignType as _;
self.gpu.metal_layer().unwrap().as_ptr()
}
fn rasterize_paths(&mut self, paths: &[Path<ScaledPixels>]) {
self.path_tiles.clear();
let mut vertices_by_texture_id = HashMap::default();
@ -362,6 +496,13 @@ impl BladeRenderer {
}
}
pub fn destroy(&mut self) {
self.wait_for_gpu();
self.atlas.destroy();
self.instance_belt.destroy(&self.gpu);
self.gpu.destroy_command_encoder(&mut self.command_encoder);
}
pub fn draw(&mut self, scene: &Scene) {
let frame = self.gpu.acquire_frame();
self.command_encoder.start();
@ -495,8 +636,78 @@ impl BladeRenderer {
);
encoder.draw(0, 4, 0, sprites.len() as u32);
}
PrimitiveBatch::Surfaces { .. } => {
unimplemented!()
PrimitiveBatch::Surfaces(surfaces) => {
let mut _encoder = pass.with(&self.pipelines.surfaces);
for surface in surfaces {
#[cfg(not(target_os = "macos"))]
{
let _ = surface;
continue;
};
#[cfg(target_os = "macos")]
{
let (t_y, t_cb_cr) = {
use core_foundation::base::TCFType as _;
use std::ptr;
assert_eq!(
surface.image_buffer.pixel_format_type(),
media::core_video::kCVPixelFormatType_420YpCbCr8BiPlanarFullRange
);
let y_texture = unsafe {
self.core_video_texture_cache
.create_texture_from_image(
surface.image_buffer.as_concrete_TypeRef(),
ptr::null(),
metal::MTLPixelFormat::R8Unorm,
surface.image_buffer.plane_width(0),
surface.image_buffer.plane_height(0),
0,
)
.unwrap()
};
let cb_cr_texture = unsafe {
self.core_video_texture_cache
.create_texture_from_image(
surface.image_buffer.as_concrete_TypeRef(),
ptr::null(),
metal::MTLPixelFormat::RG8Unorm,
surface.image_buffer.plane_width(1),
surface.image_buffer.plane_height(1),
1,
)
.unwrap()
};
(
gpu::TextureView::from_metal_texture(
y_texture.as_texture_ref(),
),
gpu::TextureView::from_metal_texture(
cb_cr_texture.as_texture_ref(),
),
)
};
_encoder.bind(
0,
&ShaderSurfacesData {
globals,
surface_locals: SurfaceParams {
bounds: surface.bounds.into(),
content_mask: surface.content_mask.bounds.into(),
},
t_y,
t_cb_cr,
s_surface: self.atlas_sampler,
},
);
_encoder.draw(0, 4, 0, 1);
}
}
}
}
}

View File

@ -1,9 +1,9 @@
struct Globals {
struct GlobalParams {
viewport_size: vec2<f32>,
pad: vec2<u32>,
}
var<uniform> globals: Globals;
var<uniform> globals: GlobalParams;
var t_sprite: texture_2d<f32>;
var s_sprite: sampler;
@ -563,7 +563,56 @@ fn fs_poly_sprite(input: PolySpriteVarying) -> @location(0) vec4<f32> {
color = vec4<f32>(vec3<f32>(grayscale), sample.a);
}
color.a *= saturate(0.5 - distance);
return color;;
return color;
}
// --- surface sprites --- //
// --- surfaces --- //
struct SurfaceParams {
bounds: Bounds,
content_mask: Bounds,
}
var<uniform> surface_locals: SurfaceParams;
var t_y: texture_2d<f32>;
var t_cb_cr: texture_2d<f32>;
var s_surface: sampler;
const ycbcr_to_RGB = mat4x4<f32>(
vec4<f32>( 1.0000f, 1.0000f, 1.0000f, 0.0),
vec4<f32>( 0.0000f, -0.3441f, 1.7720f, 0.0),
vec4<f32>( 1.4020f, -0.7141f, 0.0000f, 0.0),
vec4<f32>(-0.7010f, 0.5291f, -0.8860f, 1.0),
);
struct SurfaceVarying {
@builtin(position) position: vec4<f32>,
@location(0) texture_position: vec2<f32>,
@location(3) clip_distances: vec4<f32>,
}
@vertex
fn vs_surface(@builtin(vertex_index) vertex_id: u32) -> SurfaceVarying {
let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));
var out = SurfaceVarying();
out.position = to_device_position(unit_vertex, surface_locals.bounds);
out.texture_position = unit_vertex;
out.clip_distances = distance_from_clip_rect(unit_vertex, surface_locals.bounds, surface_locals.content_mask);
return out;
}
@fragment
fn fs_surface(input: SurfaceVarying) -> @location(0) vec4<f32> {
// Alpha clip after using the derivatives.
if (any(input.clip_distances < vec4<f32>(0.0))) {
return vec4<f32>(0.0);
}
let y_cb_cr = vec4<f32>(
textureSampleLevel(t_y, s_surface, input.texture_position, 0.0).r,
textureSampleLevel(t_cb_cr, s_surface, input.texture_position, 0.0).rg,
1.0);
return ycbcr_to_RGB * y_cb_cr;
}

View File

@ -1,6 +1,3 @@
mod blade_atlas;
mod blade_belt;
mod blade_renderer;
mod client;
mod client_dispatcher;
mod dispatcher;
@ -9,10 +6,7 @@ mod text_system;
mod wayland;
mod x11;
pub(crate) use blade_atlas::*;
pub(crate) use dispatcher::*;
pub(crate) use platform::*;
pub(crate) use text_system::*;
pub(crate) use x11::*;
use blade_belt::*;

View File

@ -13,12 +13,12 @@ use raw_window_handle::{
use wayland_client::{protocol::wl_surface, Proxy};
use wayland_protocols::xdg::shell::client::xdg_toplevel;
use crate::platform::linux::blade_renderer::BladeRenderer;
use crate::platform::blade::BladeRenderer;
use crate::platform::linux::wayland::display::WaylandDisplay;
use crate::platform::{PlatformAtlas, PlatformInputHandler, PlatformWindow};
use crate::scene::Scene;
use crate::{
px, Bounds, Modifiers, Pixels, PlatformDisplay, PlatformInput, Point, PromptLevel, Size,
px, size, Bounds, Modifiers, Pixels, PlatformDisplay, PlatformInput, Point, PromptLevel, Size,
WindowAppearance, WindowBounds, WindowOptions,
};
@ -150,11 +150,9 @@ impl WaylandWindowState {
let mut inner = self.inner.lock();
inner.bounds.size.width = width;
inner.bounds.size.height = height;
inner.renderer.resize(gpu::Extent {
width: width as u32,
height: height as u32,
depth: 1,
});
inner
.renderer
.update_drawable_size(size(width as f64, height as f64));
}
let mut callbacks = self.callbacks.lock();
if let Some(ref mut fun) = callbacks.resize {
@ -341,7 +339,7 @@ impl PlatformWindow for WaylandWindow {
fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {
let inner = self.0.inner.lock();
inner.renderer.atlas().clone()
inner.renderer.sprite_atlas().clone()
}
fn set_graphics_profiler_enabled(&self, enabled: bool) {

View File

@ -1,6 +1,20 @@
//todo!(linux): remove
#![allow(unused)]
use crate::{
platform::blade::BladeRenderer, size, Bounds, GlobalPixels, Pixels, PlatformDisplay,
PlatformInput, PlatformInputHandler, PlatformWindow, Point, Size, WindowAppearance,
WindowBounds, WindowOptions, X11Display,
};
use blade_graphics as gpu;
use parking_lot::Mutex;
use raw_window_handle as rwh;
use xcb::{
x::{self, StackMode},
Xid as _,
};
use std::{
ffi::c_void,
mem,
@ -10,17 +24,6 @@ use std::{
sync::{self, Arc},
};
use blade_graphics as gpu;
use parking_lot::Mutex;
use raw_window_handle as rwh;
use xcb::{x, Xid as _};
use crate::platform::linux::blade_renderer::BladeRenderer;
use crate::{
Bounds, GlobalPixels, Pixels, PlatformDisplay, PlatformInput, PlatformInputHandler,
PlatformWindow, Point, Size, WindowAppearance, WindowBounds, WindowOptions, X11Display,
};
#[derive(Default)]
struct Callbacks {
request_frame: Option<Box<dyn FnMut()>>,
@ -293,9 +296,13 @@ impl X11WindowState {
let mut inner = self.inner.lock();
let old_bounds = mem::replace(&mut inner.bounds, bounds);
do_move = old_bounds.origin != bounds.origin;
//todo!(linux): use normal GPUI types here, refactor out the double
// viewport check and extra casts ( )
let gpu_size = query_render_extent(&self.xcb_connection, self.x_window);
if inner.renderer.viewport_size() != gpu_size {
inner.renderer.resize(gpu_size);
inner
.renderer
.update_drawable_size(size(gpu_size.width as f64, gpu_size.height as f64));
resize_args = Some((inner.content_size(), inner.scale_factor));
}
}
@ -493,7 +500,7 @@ impl PlatformWindow for X11Window {
fn sprite_atlas(&self) -> sync::Arc<dyn crate::PlatformAtlas> {
let inner = self.0.inner.lock();
inner.renderer.atlas().clone()
inner.renderer.sprite_atlas().clone()
}
fn set_graphics_profiler_enabled(&self, enabled: bool) {

View File

@ -4,8 +4,18 @@ mod dispatcher;
mod display;
mod display_link;
mod events;
#[cfg(not(feature = "macos-blade"))]
mod metal_atlas;
mod metal_renderer;
#[cfg(not(feature = "macos-blade"))]
pub mod metal_renderer;
#[cfg(not(feature = "macos-blade"))]
use metal_renderer as renderer;
#[cfg(feature = "macos-blade")]
use crate::platform::blade as renderer;
mod open_type;
mod platform;
mod text_system;
@ -17,14 +27,13 @@ use cocoa::{
base::{id, nil},
foundation::{NSAutoreleasePool, NSNotFound, NSRect, NSSize, NSString, NSUInteger},
};
use metal_renderer::*;
use objc::runtime::{BOOL, NO, YES};
use std::ops::Range;
pub(crate) use dispatcher::*;
pub(crate) use display::*;
pub(crate) use display_link::*;
pub(crate) use metal_atlas::*;
pub(crate) use platform::*;
pub(crate) use text_system::*;
pub(crate) use window::*;

View File

@ -111,11 +111,11 @@ mod sys {
pub enum CVDisplayLink {}
foreign_type! {
type CType = CVDisplayLink;
fn drop = CVDisplayLinkRelease;
fn clone = CVDisplayLinkRetain;
pub struct DisplayLink;
pub struct DisplayLinkRef;
pub unsafe type DisplayLink {
type CType = CVDisplayLink;
fn drop = CVDisplayLinkRelease;
fn clone = CVDisplayLinkRetain;
}
}
impl Debug for DisplayLink {

View File

@ -13,7 +13,7 @@ use core_graphics::{
event_source::{CGEventSource, CGEventSourceStateID},
};
use ctor::ctor;
use foreign_types::ForeignType;
use metal::foreign_types::ForeignType as _;
use objc::{class, msg_send, sel, sel_impl};
use std::{borrow::Cow, ffi::CStr, mem, os::raw::c_char, ptr};

View File

@ -1,19 +1,20 @@
use super::metal_atlas::MetalAtlas;
use crate::{
platform::mac::ns_string, point, size, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds,
ContentMask, DevicePixels, Hsla, MetalAtlas, MonochromeSprite, Path, PathId, PathVertex,
PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, Surface, Underline,
point, size, AtlasTextureId, AtlasTextureKind, AtlasTile, Bounds, ContentMask, DevicePixels,
Hsla, MonochromeSprite, Path, PathId, PathVertex, PolychromeSprite, PrimitiveBatch, Quad,
ScaledPixels, Scene, Shadow, Size, Surface, Underline,
};
use block::ConcreteBlock;
use cocoa::{
base::{nil, NO, YES},
foundation::{NSDictionary, NSUInteger},
base::{NO, YES},
foundation::NSUInteger,
quartzcore::AutoresizingMask,
};
use collections::HashMap;
use core_foundation::base::TCFType;
use foreign_types::ForeignType;
use media::core_video::CVMetalTextureCache;
use metal::{CommandQueue, MTLPixelFormat, MTLResourceOptions, NSRange};
use metal::{CAMetalLayer, CommandQueue, MTLPixelFormat, MTLResourceOptions, NSRange};
use objc::{self, msg_send, sel, sel_impl};
use parking_lot::Mutex;
use smallvec::SmallVec;
@ -29,6 +30,18 @@ const SHADERS_SOURCE_FILE: &'static str =
include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal"));
const INSTANCE_BUFFER_SIZE: usize = 2 * 1024 * 1024; // This is an arbitrary decision. There's probably a more optimal value (maybe even we could adjust dynamically...)
pub type Context = Arc<Mutex<Vec<metal::Buffer>>>;
pub type Renderer = MetalRenderer;
pub unsafe fn new_renderer(
context: self::Context,
_native_window: *mut c_void,
_native_view: *mut c_void,
_bounds: crate::Size<f32>,
) -> Renderer {
MetalRenderer::new(context)
}
pub(crate) struct MetalRenderer {
device: metal::Device,
layer: metal::MetalLayer,
@ -196,25 +209,12 @@ impl MetalRenderer {
&self.layer
}
pub fn sprite_atlas(&self) -> &Arc<MetalAtlas> {
&self.sprite_atlas
pub fn layer_ptr(&self) -> *mut CAMetalLayer {
self.layer.as_ptr()
}
/// Enables or disables the Metal HUD for debugging purposes. Note that this only works
/// when the app is bundled and it has the `MetalHudEnabled` key set to true in Info.plist.
pub fn set_hud_enabled(&mut self, enabled: bool) {
unsafe {
if enabled {
let hud_properties = NSDictionary::dictionaryWithObject_forKey_(
nil,
ns_string("default"),
ns_string("mode"),
);
let _: () = msg_send![&*self.layer, setDeveloperHUDProperties: hud_properties];
} else {
let _: () = msg_send![&*self.layer, setDeveloperHUDProperties: NSDictionary::dictionary(nil)];
}
}
pub fn sprite_atlas(&self) -> &Arc<MetalAtlas> {
&self.sprite_atlas
}
pub fn set_presents_with_transaction(&mut self, presents_with_transaction: bool) {
@ -223,6 +223,19 @@ impl MetalRenderer {
.set_presents_with_transaction(presents_with_transaction);
}
pub fn update_drawable_size(&mut self, size: Size<f64>) {
unsafe {
let _: () = msg_send![
self.layer(),
setDrawableSize: size
];
}
}
pub fn destroy(&mut self) {
// nothing to do
}
pub fn draw(&mut self, scene: &Scene) {
let layer = self.layer.clone();
let viewport_size = layer.drawable_size();

View File

@ -52,6 +52,8 @@ use std::{
};
use time::UtcOffset;
use super::renderer;
#[allow(non_upper_case_globals)]
const NSUTF8StringEncoding: NSUInteger = 4;
@ -145,7 +147,7 @@ pub(crate) struct MacPlatformState {
background_executor: BackgroundExecutor,
foreground_executor: ForegroundExecutor,
text_system: Arc<MacTextSystem>,
instance_buffer_pool: Arc<Mutex<Vec<metal::Buffer>>>,
renderer_context: renderer::Context,
pasteboard: id,
text_hash_pasteboard_type: id,
metadata_pasteboard_type: id,
@ -175,7 +177,7 @@ impl MacPlatform {
background_executor: BackgroundExecutor::new(dispatcher.clone()),
foreground_executor: ForegroundExecutor::new(dispatcher),
text_system: Arc::new(MacTextSystem::new()),
instance_buffer_pool: Arc::default(),
renderer_context: renderer::Context::default(),
pasteboard: unsafe { NSPasteboard::generalPasteboard(nil) },
text_hash_pasteboard_type: unsafe { ns_string("zed-text-hash") },
metadata_pasteboard_type: unsafe { ns_string("zed-metadata") },
@ -494,12 +496,11 @@ impl Platform for MacPlatform {
handle: AnyWindowHandle,
options: WindowOptions,
) -> Box<dyn PlatformWindow> {
let instance_buffer_pool = self.0.lock().instance_buffer_pool.clone();
Box::new(MacWindow::open(
handle,
options,
self.foreground_executor(),
instance_buffer_pool,
self.0.lock().renderer_context.clone(),
))
}

View File

@ -1,4 +1,4 @@
use super::{global_bounds_from_ns_rect, ns_string, MacDisplay, MetalRenderer, NSRange};
use super::{global_bounds_from_ns_rect, ns_string, renderer, MacDisplay, NSRange};
use crate::{
global_bounds_to_ns_rect, platform::PlatformInputHandler, point, px, size, AnyWindowHandle,
Bounds, DisplayLink, ExternalPaths, FileDropEvent, ForegroundExecutor, GlobalPixels,
@ -23,7 +23,6 @@ use cocoa::{
};
use core_graphics::display::{CGDirectDisplayID, CGRect};
use ctor::ctor;
use foreign_types::ForeignTypeRef;
use futures::channel::oneshot;
use objc::{
class,
@ -322,7 +321,7 @@ struct MacWindowState {
native_window: id,
native_view: NonNull<Object>,
display_link: Option<DisplayLink>,
renderer: MetalRenderer,
renderer: renderer::Renderer,
kind: WindowKind,
request_frame_callback: Option<Box<dyn FnMut()>>,
event_callback: Option<Box<dyn FnMut(PlatformInput) -> bool>>,
@ -450,6 +449,13 @@ impl MacWindowState {
get_scale_factor(self.native_window)
}
fn update_drawable_size(&mut self, drawable_size: NSSize) {
self.renderer.update_drawable_size(Size {
width: drawable_size.width,
height: drawable_size.height,
})
}
fn titlebar_height(&self) -> Pixels {
unsafe {
let frame = NSWindow::frame(self.native_window);
@ -478,7 +484,7 @@ impl MacWindow {
handle: AnyWindowHandle,
options: WindowOptions,
executor: ForegroundExecutor,
instance_buffer_pool: Arc<Mutex<Vec<metal::Buffer>>>,
renderer_context: renderer::Context,
) -> Self {
unsafe {
let pool = NSAutoreleasePool::new(nil);
@ -541,13 +547,32 @@ impl MacWindow {
let native_view = NSView::init(native_view);
assert!(!native_view.is_null());
let window_size = {
let bounds = match options.bounds {
WindowBounds::Fullscreen | WindowBounds::Maximized => {
native_window.screen().visibleFrame()
}
WindowBounds::Fixed(bounds) => global_bounds_to_ns_rect(bounds),
};
let scale = get_scale_factor(native_window);
size(
bounds.size.width as f32 * scale,
bounds.size.height as f32 * scale,
)
};
let window = Self(Arc::new(Mutex::new(MacWindowState {
handle,
executor,
native_window,
native_view: NonNull::new_unchecked(native_view),
display_link: None,
renderer: MetalRenderer::new(instance_buffer_pool),
renderer: renderer::new_renderer(
renderer_context,
native_window as *mut _,
native_view as *mut _,
window_size,
),
kind: options.kind,
request_frame_callback: None,
event_callback: None,
@ -704,6 +729,7 @@ impl MacWindow {
impl Drop for MacWindow {
fn drop(&mut self) {
let mut this = self.0.lock();
this.renderer.destroy();
let window = this.native_window;
this.display_link.take();
this.executor
@ -1031,7 +1057,22 @@ impl PlatformWindow for MacWindow {
/// Enables or disables the Metal HUD for debugging purposes. Note that this only works
/// when the app is bundled and it has the `MetalHudEnabled` key set to true in Info.plist.
fn set_graphics_profiler_enabled(&self, enabled: bool) {
self.0.lock().renderer.set_hud_enabled(enabled);
let this_lock = self.0.lock();
let layer = this_lock.renderer.layer();
unsafe {
if enabled {
let hud_properties = NSDictionary::dictionaryWithObject_forKey_(
nil,
ns_string("default"),
ns_string("mode"),
);
let _: () = msg_send![layer, setDeveloperHUDProperties: hud_properties];
} else {
let _: () =
msg_send![layer, setDeveloperHUDProperties: NSDictionary::dictionary(nil)];
}
}
}
}
@ -1487,31 +1528,28 @@ extern "C" fn close_window(this: &Object, _: Sel) {
extern "C" fn make_backing_layer(this: &Object, _: Sel) -> id {
let window_state = unsafe { get_window_state(this) };
let window_state = window_state.as_ref().lock();
window_state.renderer.layer().as_ptr() as id
window_state.renderer.layer_ptr() as id
}
extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel) {
let window_state = unsafe { get_window_state(this) };
let mut lock = window_state.as_ref().lock();
let scale_factor = lock.scale_factor() as f64;
let size = lock.content_size();
let drawable_size: NSSize = NSSize {
width: f64::from(size.width) * scale_factor,
height: f64::from(size.height) * scale_factor,
};
unsafe {
let scale_factor = lock.scale_factor() as f64;
let size = lock.content_size();
let drawable_size: NSSize = NSSize {
width: f64::from(size.width) * scale_factor,
height: f64::from(size.height) * scale_factor,
};
let _: () = msg_send![
lock.renderer.layer(),
setContentsScale: scale_factor
];
let _: () = msg_send![
lock.renderer.layer(),
setDrawableSize: drawable_size
];
}
lock.update_drawable_size(drawable_size);
if let Some(mut callback) = lock.resize_callback.take() {
let content_size = lock.content_size();
let scale_factor = lock.scale_factor();
@ -1523,7 +1561,7 @@ extern "C" fn view_did_change_backing_properties(this: &Object, _: Sel) {
extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
let window_state = unsafe { get_window_state(this) };
let lock = window_state.as_ref().lock();
let mut lock = window_state.as_ref().lock();
if lock.content_size() == size.into() {
return;
@ -1539,12 +1577,7 @@ extern "C" fn set_frame_size(this: &Object, _: Sel, size: NSSize) {
height: size.height * scale_factor,
};
unsafe {
let _: () = msg_send![
lock.renderer.layer(),
setDrawableSize: drawable_size
];
}
lock.update_drawable_size(drawable_size);
drop(lock);
let mut lock = window_state.lock();
@ -1561,6 +1594,7 @@ extern "C" fn display_layer(this: &Object, _: Sel, _: id) {
let window_state = unsafe { get_window_state(this) };
let mut lock = window_state.lock();
if let Some(mut callback) = lock.request_frame_callback.take() {
#[cfg(not(feature = "macos-blade"))]
lock.renderer.set_presents_with_transaction(true);
lock.stop_display_link();
drop(lock);
@ -1568,6 +1602,7 @@ extern "C" fn display_layer(this: &Object, _: Sel, _: id) {
let mut lock = window_state.lock();
lock.request_frame_callback = Some(callback);
#[cfg(not(feature = "macos-blade"))]
lock.renderer.set_presents_with_transaction(false);
lock.start_display_link();
}

View File

@ -16,8 +16,8 @@ bytes = "1.2"
[target.'cfg(target_os = "macos")'.dependencies]
core-foundation = "0.9.3"
foreign-types = "0.3"
metal = "0.21.0"
foreign-types = "0.5"
metal = "0.25"
objc = "0.2"
[build-dependencies]

View File

@ -135,24 +135,24 @@ echo "Bundled ${app_path}"
if [ "$local_arch" = false ]; then
echo "Uploading dSYMs"
dsymutil --flat target/aarch64-apple-darwin/release/Zed
dsymutil --flat target/x86_64-apple-darwin/release/Zed
dsymutil --flat target/aarch64-apple-darwin/${target_dir}/Zed
dsymutil --flat target/x86_64-apple-darwin/${target_dir}/Zed
version="$(cargo metadata --no-deps --manifest-path crates/zed/Cargo.toml --offline --format-version=1 | jq -r '.packages | map(select(.name == "zed"))[0].version')"
if [ "$channel" == "nightly" ]; then
version="$version-$(git rev-parse --short HEAD)"
fi
echo "Removing existing gzipped dSYMs"
rm -f target/aarch64-apple-darwin/release/Zed.dwarf.gz
rm -f target/x86_64-apple-darwin/release/Zed.dwarf.gz
rm -f target/aarch64-apple-darwin/${target_dir}/Zed.dwarf.gz
rm -f target/x86_64-apple-darwin/${target_dir}/Zed.dwarf.gz
echo "Gzipping dSYMs"
gzip target/aarch64-apple-darwin/release/Zed.dwarf
gzip target/x86_64-apple-darwin/release/Zed.dwarf
gzip target/aarch64-apple-darwin/${target_dir}/Zed.dwarf
gzip target/x86_64-apple-darwin/${target_dir}/Zed.dwarf
echo "Uploading dSYMs"
uploadDsym target/aarch64-apple-darwin/release/Zed.dwarf.gz "$channel/Zed-$version-aarch64-apple-darwin.dwarf.gz"
uploadDsym target/x86_64-apple-darwin/release/Zed.dwarf.gz "$channel/Zed-$version-x86_64-apple-darwin.dwarf.gz"
uploadDsym target/aarch64-apple-darwin/${target_dir}/Zed.dwarf.gz "$channel/Zed-$version-aarch64-apple-darwin.dwarf.gz"
uploadDsym target/x86_64-apple-darwin/${target_dir}/Zed.dwarf.gz "$channel/Zed-$version-x86_64-apple-darwin.dwarf.gz"
echo "Creating fat binaries"
lipo \