1use std::{borrow::Cow, sync::Arc};
2
3use ::util::ResultExt;
4use anyhow::Result;
5use collections::HashMap;
6use itertools::Itertools;
7use parking_lot::{RwLock, RwLockUpgradableReadGuard};
8use windows::{
9 Win32::{
10 Foundation::*,
11 Globalization::GetUserDefaultLocaleName,
12 Graphics::{
13 Direct3D::D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,
14 Direct3D11::*,
15 DirectWrite::*,
16 Dxgi::Common::*,
17 Gdi::{IsRectEmpty, LOGFONTW},
18 Imaging::*,
19 },
20 System::SystemServices::LOCALE_NAME_MAX_LENGTH,
21 UI::WindowsAndMessaging::*,
22 },
23 core::*,
24};
25use windows_numerics::Vector2;
26
27use crate::*;
28
29#[derive(Debug)]
30struct FontInfo {
31 font_family: String,
32 font_face: IDWriteFontFace3,
33 features: IDWriteTypography,
34 fallbacks: Option<IDWriteFontFallback>,
35 is_system_font: bool,
36}
37
38pub(crate) struct DirectWriteTextSystem(RwLock<DirectWriteState>);
39
40struct DirectWriteComponent {
41 locale: String,
42 factory: IDWriteFactory5,
43 bitmap_factory: AgileReference<IWICImagingFactory>,
44 in_memory_loader: IDWriteInMemoryFontFileLoader,
45 builder: IDWriteFontSetBuilder1,
46 text_renderer: Arc<TextRendererWrapper>,
47
48 render_params: IDWriteRenderingParams3,
49 gpu_state: GPUState,
50}
51
52struct GPUState {
53 device: ID3D11Device,
54 device_context: ID3D11DeviceContext,
55 sampler: [Option<ID3D11SamplerState>; 1],
56 blend_state: ID3D11BlendState,
57 vertex_shader: ID3D11VertexShader,
58 pixel_shader: ID3D11PixelShader,
59}
60
61struct DirectWriteState {
62 components: DirectWriteComponent,
63 system_ui_font_name: SharedString,
64 system_font_collection: IDWriteFontCollection1,
65 custom_font_collection: IDWriteFontCollection1,
66 fonts: Vec<FontInfo>,
67 font_selections: HashMap<Font, FontId>,
68 font_id_by_identifier: HashMap<FontIdentifier, FontId>,
69}
70
71#[derive(Debug, Clone, Hash, PartialEq, Eq)]
72struct FontIdentifier {
73 postscript_name: String,
74 weight: i32,
75 style: i32,
76}
77
78impl DirectWriteComponent {
79 pub fn new(bitmap_factory: &IWICImagingFactory, gpu_context: &DirectXDevices) -> Result<Self> {
80 // todo: ideally this would not be a large unsafe block but smaller isolated ones for easier auditing
81 unsafe {
82 let factory: IDWriteFactory5 = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED)?;
83 let bitmap_factory = AgileReference::new(bitmap_factory)?;
84 // The `IDWriteInMemoryFontFileLoader` here is supported starting from
85 // Windows 10 Creators Update, which consequently requires the entire
86 // `DirectWriteTextSystem` to run on `win10 1703`+.
87 let in_memory_loader = factory.CreateInMemoryFontFileLoader()?;
88 factory.RegisterFontFileLoader(&in_memory_loader)?;
89 let builder = factory.CreateFontSetBuilder()?;
90 let mut locale_vec = vec![0u16; LOCALE_NAME_MAX_LENGTH as usize];
91 GetUserDefaultLocaleName(&mut locale_vec);
92 let locale = String::from_utf16_lossy(&locale_vec);
93 let text_renderer = Arc::new(TextRendererWrapper::new(&locale));
94
95 let render_params = {
96 let default_params: IDWriteRenderingParams3 =
97 factory.CreateRenderingParams()?.cast()?;
98 let gamma = default_params.GetGamma();
99 let enhanced_contrast = default_params.GetEnhancedContrast();
100 let gray_contrast = default_params.GetGrayscaleEnhancedContrast();
101 let cleartype_level = default_params.GetClearTypeLevel();
102 let grid_fit_mode = default_params.GetGridFitMode();
103
104 factory.CreateCustomRenderingParams(
105 gamma,
106 enhanced_contrast,
107 gray_contrast,
108 cleartype_level,
109 DWRITE_PIXEL_GEOMETRY_RGB,
110 DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC,
111 grid_fit_mode,
112 )?
113 };
114
115 let gpu_state = GPUState::new(gpu_context)?;
116
117 Ok(DirectWriteComponent {
118 locale,
119 factory,
120 bitmap_factory,
121 in_memory_loader,
122 builder,
123 text_renderer,
124 render_params,
125 gpu_state,
126 })
127 }
128 }
129}
130
131impl GPUState {
132 fn new(gpu_context: &DirectXDevices) -> Result<Self> {
133 let device = gpu_context.device.clone();
134 let device_context = gpu_context.device_context.clone();
135
136 let blend_state = {
137 let mut blend_state = None;
138 let desc = D3D11_BLEND_DESC {
139 AlphaToCoverageEnable: false.into(),
140 IndependentBlendEnable: false.into(),
141 RenderTarget: [
142 D3D11_RENDER_TARGET_BLEND_DESC {
143 BlendEnable: true.into(),
144 SrcBlend: D3D11_BLEND_SRC_ALPHA,
145 DestBlend: D3D11_BLEND_INV_SRC_ALPHA,
146 BlendOp: D3D11_BLEND_OP_ADD,
147 SrcBlendAlpha: D3D11_BLEND_SRC_ALPHA,
148 DestBlendAlpha: D3D11_BLEND_INV_SRC_ALPHA,
149 BlendOpAlpha: D3D11_BLEND_OP_ADD,
150 RenderTargetWriteMask: D3D11_COLOR_WRITE_ENABLE_ALL.0 as u8,
151 },
152 Default::default(),
153 Default::default(),
154 Default::default(),
155 Default::default(),
156 Default::default(),
157 Default::default(),
158 Default::default(),
159 ],
160 };
161 unsafe { device.CreateBlendState(&desc, Some(&mut blend_state)) }?;
162 blend_state.unwrap()
163 };
164
165 let sampler = {
166 let mut sampler = None;
167 let desc = D3D11_SAMPLER_DESC {
168 Filter: D3D11_FILTER_MIN_MAG_MIP_POINT,
169 AddressU: D3D11_TEXTURE_ADDRESS_BORDER,
170 AddressV: D3D11_TEXTURE_ADDRESS_BORDER,
171 AddressW: D3D11_TEXTURE_ADDRESS_BORDER,
172 MipLODBias: 0.0,
173 MaxAnisotropy: 1,
174 ComparisonFunc: D3D11_COMPARISON_ALWAYS,
175 BorderColor: [0.0, 0.0, 0.0, 0.0],
176 MinLOD: 0.0,
177 MaxLOD: 0.0,
178 };
179 unsafe { device.CreateSamplerState(&desc, Some(&mut sampler)) }?;
180 [sampler]
181 };
182
183 let vertex_shader = {
184 let source = shader_resources::RawShaderBytes::new(
185 shader_resources::ShaderModule::EmojiRasterization,
186 shader_resources::ShaderTarget::Vertex,
187 )?;
188 let mut shader = None;
189 unsafe { device.CreateVertexShader(source.as_bytes(), None, Some(&mut shader)) }?;
190 shader.unwrap()
191 };
192
193 let pixel_shader = {
194 let source = shader_resources::RawShaderBytes::new(
195 shader_resources::ShaderModule::EmojiRasterization,
196 shader_resources::ShaderTarget::Fragment,
197 )?;
198 let mut shader = None;
199 unsafe { device.CreatePixelShader(source.as_bytes(), None, Some(&mut shader)) }?;
200 shader.unwrap()
201 };
202
203 Ok(Self {
204 device,
205 device_context,
206 sampler,
207 blend_state,
208 vertex_shader,
209 pixel_shader,
210 })
211 }
212}
213
214impl DirectWriteTextSystem {
215 pub(crate) fn new(
216 gpu_context: &DirectXDevices,
217 bitmap_factory: &IWICImagingFactory,
218 ) -> Result<Self> {
219 let components = DirectWriteComponent::new(bitmap_factory, gpu_context)?;
220 let system_font_collection = unsafe {
221 let mut result = std::mem::zeroed();
222 components
223 .factory
224 .GetSystemFontCollection(false, &mut result, true)?;
225 result.unwrap()
226 };
227 let custom_font_set = unsafe { components.builder.CreateFontSet()? };
228 let custom_font_collection = unsafe {
229 components
230 .factory
231 .CreateFontCollectionFromFontSet(&custom_font_set)?
232 };
233 let system_ui_font_name = get_system_ui_font_name();
234
235 Ok(Self(RwLock::new(DirectWriteState {
236 components,
237 system_ui_font_name,
238 system_font_collection,
239 custom_font_collection,
240 fonts: Vec::new(),
241 font_selections: HashMap::default(),
242 font_id_by_identifier: HashMap::default(),
243 })))
244 }
245}
246
247impl PlatformTextSystem for DirectWriteTextSystem {
248 fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
249 self.0.write().add_fonts(fonts)
250 }
251
252 fn all_font_names(&self) -> Vec<String> {
253 self.0.read().all_font_names()
254 }
255
256 fn font_id(&self, font: &Font) -> Result<FontId> {
257 let lock = self.0.upgradable_read();
258 if let Some(font_id) = lock.font_selections.get(font) {
259 Ok(*font_id)
260 } else {
261 let mut lock = RwLockUpgradableReadGuard::upgrade(lock);
262 let font_id = lock.select_font(font);
263 lock.font_selections.insert(font.clone(), font_id);
264 Ok(font_id)
265 }
266 }
267
268 fn font_metrics(&self, font_id: FontId) -> FontMetrics {
269 self.0.read().font_metrics(font_id)
270 }
271
272 fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>> {
273 self.0.read().get_typographic_bounds(font_id, glyph_id)
274 }
275
276 fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> anyhow::Result<Size<f32>> {
277 self.0.read().get_advance(font_id, glyph_id)
278 }
279
280 fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
281 self.0.read().glyph_for_char(font_id, ch)
282 }
283
284 fn glyph_raster_bounds(
285 &self,
286 params: &RenderGlyphParams,
287 ) -> anyhow::Result<Bounds<DevicePixels>> {
288 self.0.read().raster_bounds(params)
289 }
290
291 fn rasterize_glyph(
292 &self,
293 params: &RenderGlyphParams,
294 raster_bounds: Bounds<DevicePixels>,
295 ) -> anyhow::Result<(Size<DevicePixels>, Vec<u8>)> {
296 self.0.read().rasterize_glyph(params, raster_bounds)
297 }
298
299 fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout {
300 self.0
301 .write()
302 .layout_line(text, font_size, runs)
303 .log_err()
304 .unwrap_or(LineLayout {
305 font_size,
306 ..Default::default()
307 })
308 }
309}
310
311impl DirectWriteState {
312 fn add_fonts(&mut self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
313 for font_data in fonts {
314 match font_data {
315 Cow::Borrowed(data) => unsafe {
316 let font_file = self
317 .components
318 .in_memory_loader
319 .CreateInMemoryFontFileReference(
320 &self.components.factory,
321 data.as_ptr() as _,
322 data.len() as _,
323 None,
324 )?;
325 self.components.builder.AddFontFile(&font_file)?;
326 },
327 Cow::Owned(data) => unsafe {
328 let font_file = self
329 .components
330 .in_memory_loader
331 .CreateInMemoryFontFileReference(
332 &self.components.factory,
333 data.as_ptr() as _,
334 data.len() as _,
335 None,
336 )?;
337 self.components.builder.AddFontFile(&font_file)?;
338 },
339 }
340 }
341 let set = unsafe { self.components.builder.CreateFontSet()? };
342 let collection = unsafe {
343 self.components
344 .factory
345 .CreateFontCollectionFromFontSet(&set)?
346 };
347 self.custom_font_collection = collection;
348
349 Ok(())
350 }
351
352 fn generate_font_fallbacks(
353 &self,
354 fallbacks: &FontFallbacks,
355 ) -> Result<Option<IDWriteFontFallback>> {
356 if fallbacks.fallback_list().is_empty() {
357 return Ok(None);
358 }
359 unsafe {
360 let builder = self.components.factory.CreateFontFallbackBuilder()?;
361 let font_set = &self.system_font_collection.GetFontSet()?;
362 for family_name in fallbacks.fallback_list() {
363 let Some(fonts) = font_set
364 .GetMatchingFonts(
365 &HSTRING::from(family_name),
366 DWRITE_FONT_WEIGHT_NORMAL,
367 DWRITE_FONT_STRETCH_NORMAL,
368 DWRITE_FONT_STYLE_NORMAL,
369 )
370 .log_err()
371 else {
372 continue;
373 };
374 if fonts.GetFontCount() == 0 {
375 log::error!("No matching font found for {}", family_name);
376 continue;
377 }
378 let font = fonts.GetFontFaceReference(0)?.CreateFontFace()?;
379 let mut count = 0;
380 font.GetUnicodeRanges(None, &mut count).ok();
381 if count == 0 {
382 continue;
383 }
384 let mut unicode_ranges = vec![DWRITE_UNICODE_RANGE::default(); count as usize];
385 let Some(_) = font
386 .GetUnicodeRanges(Some(&mut unicode_ranges), &mut count)
387 .log_err()
388 else {
389 continue;
390 };
391 let target_family_name = HSTRING::from(family_name);
392 builder.AddMapping(
393 &unicode_ranges,
394 &[target_family_name.as_ptr()],
395 None,
396 None,
397 None,
398 1.0,
399 )?;
400 }
401 let system_fallbacks = self.components.factory.GetSystemFontFallback()?;
402 builder.AddMappings(&system_fallbacks)?;
403 Ok(Some(builder.CreateFontFallback()?))
404 }
405 }
406
407 unsafe fn generate_font_features(
408 &self,
409 font_features: &FontFeatures,
410 ) -> Result<IDWriteTypography> {
411 let direct_write_features = unsafe { self.components.factory.CreateTypography()? };
412 apply_font_features(&direct_write_features, font_features)?;
413 Ok(direct_write_features)
414 }
415
416 unsafe fn get_font_id_from_font_collection(
417 &mut self,
418 family_name: &str,
419 font_weight: FontWeight,
420 font_style: FontStyle,
421 font_features: &FontFeatures,
422 font_fallbacks: Option<&FontFallbacks>,
423 is_system_font: bool,
424 ) -> Option<FontId> {
425 let collection = if is_system_font {
426 &self.system_font_collection
427 } else {
428 &self.custom_font_collection
429 };
430 let fontset = unsafe { collection.GetFontSet().log_err()? };
431 let font = unsafe {
432 fontset
433 .GetMatchingFonts(
434 &HSTRING::from(family_name),
435 font_weight.into(),
436 DWRITE_FONT_STRETCH_NORMAL,
437 font_style.into(),
438 )
439 .log_err()?
440 };
441 let total_number = unsafe { font.GetFontCount() };
442 for index in 0..total_number {
443 let Some(font_face_ref) = (unsafe { font.GetFontFaceReference(index).log_err() })
444 else {
445 continue;
446 };
447 let Some(font_face) = (unsafe { font_face_ref.CreateFontFace().log_err() }) else {
448 continue;
449 };
450 let Some(identifier) = get_font_identifier(&font_face, &self.components.locale) else {
451 continue;
452 };
453 let Some(direct_write_features) =
454 (unsafe { self.generate_font_features(font_features).log_err() })
455 else {
456 continue;
457 };
458 let fallbacks = font_fallbacks
459 .and_then(|fallbacks| self.generate_font_fallbacks(fallbacks).log_err().flatten());
460 let font_info = FontInfo {
461 font_family: family_name.to_owned(),
462 font_face,
463 features: direct_write_features,
464 fallbacks,
465 is_system_font,
466 };
467 let font_id = FontId(self.fonts.len());
468 self.fonts.push(font_info);
469 self.font_id_by_identifier.insert(identifier, font_id);
470 return Some(font_id);
471 }
472 None
473 }
474
475 unsafe fn update_system_font_collection(&mut self) {
476 let mut collection = unsafe { std::mem::zeroed() };
477 if unsafe {
478 self.components
479 .factory
480 .GetSystemFontCollection(false, &mut collection, true)
481 .log_err()
482 .is_some()
483 } {
484 self.system_font_collection = collection.unwrap();
485 }
486 }
487
488 fn select_font(&mut self, target_font: &Font) -> FontId {
489 unsafe {
490 if target_font.family == ".SystemUIFont" {
491 let family = self.system_ui_font_name.clone();
492 self.find_font_id(
493 family.as_ref(),
494 target_font.weight,
495 target_font.style,
496 &target_font.features,
497 target_font.fallbacks.as_ref(),
498 )
499 .unwrap()
500 } else {
501 self.find_font_id(
502 target_font.family.as_ref(),
503 target_font.weight,
504 target_font.style,
505 &target_font.features,
506 target_font.fallbacks.as_ref(),
507 )
508 .unwrap_or_else(|| {
509 #[cfg(any(test, feature = "test-support"))]
510 {
511 panic!("ERROR: {} font not found!", target_font.family);
512 }
513 #[cfg(not(any(test, feature = "test-support")))]
514 {
515 let family = self.system_ui_font_name.clone();
516 log::error!("{} not found, use {} instead.", target_font.family, family);
517 self.get_font_id_from_font_collection(
518 family.as_ref(),
519 target_font.weight,
520 target_font.style,
521 &target_font.features,
522 target_font.fallbacks.as_ref(),
523 true,
524 )
525 .unwrap()
526 }
527 })
528 }
529 }
530 }
531
532 unsafe fn find_font_id(
533 &mut self,
534 family_name: &str,
535 weight: FontWeight,
536 style: FontStyle,
537 features: &FontFeatures,
538 fallbacks: Option<&FontFallbacks>,
539 ) -> Option<FontId> {
540 // try to find target font in custom font collection first
541 unsafe {
542 self.get_font_id_from_font_collection(
543 family_name,
544 weight,
545 style,
546 features,
547 fallbacks,
548 false,
549 )
550 .or_else(|| {
551 self.get_font_id_from_font_collection(
552 family_name,
553 weight,
554 style,
555 features,
556 fallbacks,
557 true,
558 )
559 })
560 .or_else(|| {
561 self.update_system_font_collection();
562 self.get_font_id_from_font_collection(
563 family_name,
564 weight,
565 style,
566 features,
567 fallbacks,
568 true,
569 )
570 })
571 }
572 }
573
574 fn layout_line(
575 &mut self,
576 text: &str,
577 font_size: Pixels,
578 font_runs: &[FontRun],
579 ) -> Result<LineLayout> {
580 if font_runs.is_empty() {
581 return Ok(LineLayout {
582 font_size,
583 ..Default::default()
584 });
585 }
586 unsafe {
587 let text_renderer = self.components.text_renderer.clone();
588 let text_wide = text.encode_utf16().collect_vec();
589
590 let mut utf8_offset = 0usize;
591 let mut utf16_offset = 0u32;
592 let text_layout = {
593 let first_run = &font_runs[0];
594 let font_info = &self.fonts[first_run.font_id.0];
595 let collection = if font_info.is_system_font {
596 &self.system_font_collection
597 } else {
598 &self.custom_font_collection
599 };
600 let format: IDWriteTextFormat1 = self
601 .components
602 .factory
603 .CreateTextFormat(
604 &HSTRING::from(&font_info.font_family),
605 collection,
606 font_info.font_face.GetWeight(),
607 font_info.font_face.GetStyle(),
608 DWRITE_FONT_STRETCH_NORMAL,
609 font_size.0,
610 &HSTRING::from(&self.components.locale),
611 )?
612 .cast()?;
613 if let Some(ref fallbacks) = font_info.fallbacks {
614 format.SetFontFallback(fallbacks)?;
615 }
616
617 let layout = self.components.factory.CreateTextLayout(
618 &text_wide,
619 &format,
620 f32::INFINITY,
621 f32::INFINITY,
622 )?;
623 let current_text = &text[utf8_offset..(utf8_offset + first_run.len)];
624 utf8_offset += first_run.len;
625 let current_text_utf16_length = current_text.encode_utf16().count() as u32;
626 let text_range = DWRITE_TEXT_RANGE {
627 startPosition: utf16_offset,
628 length: current_text_utf16_length,
629 };
630 layout.SetTypography(&font_info.features, text_range)?;
631 utf16_offset += current_text_utf16_length;
632
633 layout
634 };
635
636 let mut first_run = true;
637 let mut ascent = Pixels::default();
638 let mut descent = Pixels::default();
639 for run in font_runs {
640 if first_run {
641 first_run = false;
642 let mut metrics = vec![DWRITE_LINE_METRICS::default(); 4];
643 let mut line_count = 0u32;
644 text_layout.GetLineMetrics(Some(&mut metrics), &mut line_count as _)?;
645 ascent = px(metrics[0].baseline);
646 descent = px(metrics[0].height - metrics[0].baseline);
647 continue;
648 }
649 let font_info = &self.fonts[run.font_id.0];
650 let current_text = &text[utf8_offset..(utf8_offset + run.len)];
651 utf8_offset += run.len;
652 let current_text_utf16_length = current_text.encode_utf16().count() as u32;
653
654 let collection = if font_info.is_system_font {
655 &self.system_font_collection
656 } else {
657 &self.custom_font_collection
658 };
659 let text_range = DWRITE_TEXT_RANGE {
660 startPosition: utf16_offset,
661 length: current_text_utf16_length,
662 };
663 utf16_offset += current_text_utf16_length;
664 text_layout.SetFontCollection(collection, text_range)?;
665 text_layout
666 .SetFontFamilyName(&HSTRING::from(&font_info.font_family), text_range)?;
667 text_layout.SetFontSize(font_size.0, text_range)?;
668 text_layout.SetFontStyle(font_info.font_face.GetStyle(), text_range)?;
669 text_layout.SetFontWeight(font_info.font_face.GetWeight(), text_range)?;
670 text_layout.SetTypography(&font_info.features, text_range)?;
671 }
672
673 let mut runs = Vec::new();
674 let renderer_context = RendererContext {
675 text_system: self,
676 index_converter: StringIndexConverter::new(text),
677 runs: &mut runs,
678 width: 0.0,
679 };
680 text_layout.Draw(
681 Some(&renderer_context as *const _ as _),
682 &text_renderer.0,
683 0.0,
684 0.0,
685 )?;
686 let width = px(renderer_context.width);
687
688 Ok(LineLayout {
689 font_size,
690 width,
691 ascent,
692 descent,
693 runs,
694 len: text.len(),
695 })
696 }
697 }
698
699 fn font_metrics(&self, font_id: FontId) -> FontMetrics {
700 unsafe {
701 let font_info = &self.fonts[font_id.0];
702 let mut metrics = std::mem::zeroed();
703 font_info.font_face.GetMetrics(&mut metrics);
704
705 FontMetrics {
706 units_per_em: metrics.Base.designUnitsPerEm as _,
707 ascent: metrics.Base.ascent as _,
708 descent: -(metrics.Base.descent as f32),
709 line_gap: metrics.Base.lineGap as _,
710 underline_position: metrics.Base.underlinePosition as _,
711 underline_thickness: metrics.Base.underlineThickness as _,
712 cap_height: metrics.Base.capHeight as _,
713 x_height: metrics.Base.xHeight as _,
714 bounding_box: Bounds {
715 origin: Point {
716 x: metrics.glyphBoxLeft as _,
717 y: metrics.glyphBoxBottom as _,
718 },
719 size: Size {
720 width: (metrics.glyphBoxRight - metrics.glyphBoxLeft) as _,
721 height: (metrics.glyphBoxTop - metrics.glyphBoxBottom) as _,
722 },
723 },
724 }
725 }
726 }
727
728 fn create_glyph_run_analysis(
729 &self,
730 params: &RenderGlyphParams,
731 scale: f32,
732 ) -> Result<IDWriteGlyphRunAnalysis> {
733 let font = &self.fonts[params.font_id.0];
734 let glyph_id = [params.glyph_id.0 as u16];
735 let advance = [0.0];
736 let offset = [DWRITE_GLYPH_OFFSET::default()];
737 let glyph_run = DWRITE_GLYPH_RUN {
738 fontFace: unsafe { std::mem::transmute_copy(&font.font_face) },
739 fontEmSize: params.font_size.0,
740 glyphCount: 1,
741 glyphIndices: glyph_id.as_ptr(),
742 glyphAdvances: advance.as_ptr(),
743 glyphOffsets: offset.as_ptr(),
744 isSideways: BOOL(0),
745 bidiLevel: 0,
746 };
747 let transform = DWRITE_MATRIX {
748 m11: params.scale_factor * scale,
749 m12: 0.0,
750 m21: 0.0,
751 m22: params.scale_factor * scale,
752 dx: 0.0,
753 dy: 0.0,
754 };
755 let subpixel_shift = params
756 .subpixel_variant
757 .map(|v| v as f32 / SUBPIXEL_VARIANTS as f32);
758 let baseline_origin_x = subpixel_shift.x * scale / params.scale_factor;
759 let baseline_origin_y = subpixel_shift.y * scale / params.scale_factor;
760
761 let mut rendering_mode = DWRITE_RENDERING_MODE1::default();
762 let mut grid_fit_mode = DWRITE_GRID_FIT_MODE::default();
763 unsafe {
764 font.font_face.GetRecommendedRenderingMode(
765 params.font_size.0,
766 // The dpi here seems that it has the same effect with `Some(&transform)`
767 1.0,
768 1.0,
769 Some(&transform),
770 false,
771 DWRITE_OUTLINE_THRESHOLD_ANTIALIASED,
772 DWRITE_MEASURING_MODE_NATURAL,
773 &self.components.render_params,
774 &mut rendering_mode,
775 &mut grid_fit_mode,
776 )?;
777 }
778
779 let glyph_analysis = unsafe {
780 self.components.factory.CreateGlyphRunAnalysis(
781 &glyph_run,
782 Some(&transform),
783 rendering_mode,
784 DWRITE_MEASURING_MODE_NATURAL,
785 grid_fit_mode,
786 // We're using cleartype not grayscale for monochrome is because it provides better quality
787 // DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE,
788 DWRITE_TEXT_ANTIALIAS_MODE_GRAYSCALE,
789 baseline_origin_x,
790 baseline_origin_y,
791 )
792 }?;
793 Ok(glyph_analysis)
794 }
795
796 fn raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
797 let glyph_analysis = self.create_glyph_run_analysis(params, 1.0)?;
798
799 let bounds = unsafe { glyph_analysis.GetAlphaTextureBounds(DWRITE_TEXTURE_CLEARTYPE_3x1)? };
800 // Some glyphs cannot be drawn with ClearType, such as bitmap fonts. In that case
801 // GetAlphaTextureBounds() supposedly returns an empty RECT, but I haven't tested that yet.
802 if !unsafe { IsRectEmpty(&bounds) }.as_bool() {
803 Ok(Bounds {
804 origin: point((bounds.left as i32).into(), (bounds.top as i32).into()),
805 size: size(
806 (bounds.right - bounds.left).into(),
807 (bounds.bottom - bounds.top).into(),
808 ),
809 })
810 } else {
811 // If it's empty, retry with grayscale AA.
812 let bounds =
813 unsafe { glyph_analysis.GetAlphaTextureBounds(DWRITE_TEXTURE_ALIASED_1x1)? };
814
815 if bounds.right < bounds.left {
816 Ok(Bounds {
817 origin: point(0.into(), 0.into()),
818 size: size(0.into(), 0.into()),
819 })
820 } else {
821 Ok(Bounds {
822 origin: point(
823 (bounds.left as i32 - 1).into(),
824 (bounds.top as i32 - 1).into(),
825 ),
826 size: size(
827 (bounds.right - bounds.left + 2).into(),
828 (bounds.bottom - bounds.top + 2).into(),
829 ),
830 })
831 }
832 }
833 }
834
835 fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId> {
836 let font_info = &self.fonts[font_id.0];
837 let codepoints = [ch as u32];
838 let mut glyph_indices = vec![0u16; 1];
839 unsafe {
840 font_info
841 .font_face
842 .GetGlyphIndices(codepoints.as_ptr(), 1, glyph_indices.as_mut_ptr())
843 .log_err()
844 }
845 .map(|_| GlyphId(glyph_indices[0] as u32))
846 }
847
848 fn rasterize_glyph(
849 &self,
850 params: &RenderGlyphParams,
851 glyph_bounds: Bounds<DevicePixels>,
852 ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
853 if glyph_bounds.size.width.0 == 0 || glyph_bounds.size.height.0 == 0 {
854 anyhow::bail!("glyph bounds are empty");
855 }
856
857 let bitmap_data = if params.is_emoji {
858 if let Ok(color) = self.rasterize_color(¶ms, glyph_bounds) {
859 color
860 } else {
861 let monochrome = self.rasterize_monochrome(params, glyph_bounds)?;
862 monochrome
863 .into_iter()
864 .flat_map(|pixel| [0, 0, 0, pixel])
865 .collect::<Vec<_>>()
866 }
867 } else {
868 self.rasterize_monochrome(params, glyph_bounds)?
869 };
870
871 Ok((glyph_bounds.size, bitmap_data))
872 }
873
874 fn rasterize_monochrome(
875 &self,
876 params: &RenderGlyphParams,
877 glyph_bounds: Bounds<DevicePixels>,
878 ) -> Result<Vec<u8>> {
879 let mut bitmap_data =
880 vec![0u8; glyph_bounds.size.width.0 as usize * glyph_bounds.size.height.0 as usize * 4];
881
882 let glyph_analysis = self.create_glyph_run_analysis(params, 2.0)?;
883 unsafe {
884 glyph_analysis.CreateAlphaTexture(
885 // We're using cleartype not grayscale for monochrome is because it provides better quality
886 // DWRITE_TEXTURE_CLEARTYPE_3x1,
887 DWRITE_TEXTURE_ALIASED_1x1,
888 &RECT {
889 left: glyph_bounds.origin.x.0 * 2,
890 top: glyph_bounds.origin.y.0 * 2,
891 right: glyph_bounds.size.width.0 * 2 + glyph_bounds.origin.x.0 * 2,
892 bottom: glyph_bounds.size.height.0 * 2 + glyph_bounds.origin.y.0 * 2,
893 },
894 &mut bitmap_data,
895 )?;
896 }
897
898 let bitmap_factory = self.components.bitmap_factory.resolve()?;
899 let bitmap = unsafe {
900 bitmap_factory.CreateBitmapFromMemory(
901 glyph_bounds.size.width.0 as u32 * 2,
902 glyph_bounds.size.height.0 as u32 * 2,
903 // &GUID_WICPixelFormat24bppRGB,
904 &GUID_WICPixelFormat8bppGray,
905 glyph_bounds.size.width.0 as u32 * 2,
906 &bitmap_data,
907 )
908 }?;
909
910 // let grayscale_bitmap =
911 // unsafe { WICConvertBitmapSource(&GUID_WICPixelFormat8bppGray, &bitmap) }?;
912 let scaler = unsafe { bitmap_factory.CreateBitmapScaler()? };
913 unsafe {
914 scaler.Initialize(
915 &bitmap,
916 glyph_bounds.size.width.0 as u32,
917 glyph_bounds.size.height.0 as u32,
918 WICBitmapInterpolationModeHighQualityCubic,
919 )?;
920 }
921
922 let mut bitmap_data =
923 vec![0u8; glyph_bounds.size.width.0 as usize * glyph_bounds.size.height.0 as usize];
924 unsafe {
925 scaler.CopyPixels(
926 std::ptr::null() as _,
927 glyph_bounds.size.width.0 as u32,
928 &mut bitmap_data,
929 )
930 }?;
931
932 Ok(bitmap_data)
933 }
934
935 fn rasterize_color(
936 &self,
937 params: &RenderGlyphParams,
938 glyph_bounds: Bounds<DevicePixels>,
939 ) -> Result<Vec<u8>> {
940 let bitmap_size = glyph_bounds.size;
941 let subpixel_shift = params
942 .subpixel_variant
943 .map(|v| v as f32 / SUBPIXEL_VARIANTS as f32);
944 let baseline_origin_x = subpixel_shift.x / params.scale_factor;
945 let baseline_origin_y = subpixel_shift.y / params.scale_factor;
946
947 let transform = DWRITE_MATRIX {
948 m11: params.scale_factor,
949 m12: 0.0,
950 m21: 0.0,
951 m22: params.scale_factor,
952 dx: 0.0,
953 dy: 0.0,
954 };
955
956 let font = &self.fonts[params.font_id.0];
957 let glyph_id = [params.glyph_id.0 as u16];
958 let advance = [glyph_bounds.size.width.0 as f32];
959 let offset = [DWRITE_GLYPH_OFFSET {
960 advanceOffset: -glyph_bounds.origin.x.0 as f32 / params.scale_factor,
961 ascenderOffset: glyph_bounds.origin.y.0 as f32 / params.scale_factor,
962 }];
963 let glyph_run = DWRITE_GLYPH_RUN {
964 fontFace: unsafe { std::mem::transmute_copy(&font.font_face) },
965 fontEmSize: params.font_size.0,
966 glyphCount: 1,
967 glyphIndices: glyph_id.as_ptr(),
968 glyphAdvances: advance.as_ptr(),
969 glyphOffsets: offset.as_ptr(),
970 isSideways: BOOL(0),
971 bidiLevel: 0,
972 };
973
974 // todo: support formats other than COLR
975 let color_enumerator = unsafe {
976 self.components.factory.TranslateColorGlyphRun(
977 Vector2::new(baseline_origin_x, baseline_origin_y),
978 &glyph_run,
979 None,
980 DWRITE_GLYPH_IMAGE_FORMATS_COLR,
981 DWRITE_MEASURING_MODE_NATURAL,
982 Some(&transform),
983 0,
984 )
985 }?;
986
987 let mut glyph_layers = Vec::new();
988 loop {
989 let color_run = unsafe { color_enumerator.GetCurrentRun() }?;
990 let color_run = unsafe { &*color_run };
991 let image_format = color_run.glyphImageFormat & !DWRITE_GLYPH_IMAGE_FORMATS_TRUETYPE;
992 if image_format == DWRITE_GLYPH_IMAGE_FORMATS_COLR {
993 let color_analysis = unsafe {
994 self.components.factory.CreateGlyphRunAnalysis(
995 &color_run.Base.glyphRun as *const _,
996 Some(&transform),
997 DWRITE_RENDERING_MODE1_NATURAL_SYMMETRIC,
998 DWRITE_MEASURING_MODE_NATURAL,
999 DWRITE_GRID_FIT_MODE_DEFAULT,
1000 DWRITE_TEXT_ANTIALIAS_MODE_CLEARTYPE,
1001 baseline_origin_x,
1002 baseline_origin_y,
1003 )
1004 }?;
1005
1006 let color_bounds =
1007 unsafe { color_analysis.GetAlphaTextureBounds(DWRITE_TEXTURE_CLEARTYPE_3x1) }?;
1008
1009 let color_size = size(
1010 color_bounds.right - color_bounds.left,
1011 color_bounds.bottom - color_bounds.top,
1012 );
1013 if color_size.width > 0 && color_size.height > 0 {
1014 let mut alpha_data =
1015 vec![0u8; (color_size.width * color_size.height * 3) as usize];
1016 unsafe {
1017 color_analysis.CreateAlphaTexture(
1018 DWRITE_TEXTURE_CLEARTYPE_3x1,
1019 &color_bounds,
1020 &mut alpha_data,
1021 )
1022 }?;
1023
1024 let run_color = {
1025 let run_color = color_run.Base.runColor;
1026 Rgba {
1027 r: run_color.r,
1028 g: run_color.g,
1029 b: run_color.b,
1030 a: run_color.a,
1031 }
1032 };
1033 let bounds = bounds(point(color_bounds.left, color_bounds.top), color_size);
1034 let alpha_data = alpha_data
1035 .chunks_exact(3)
1036 .flat_map(|chunk| [chunk[0], chunk[1], chunk[2], 255])
1037 .collect::<Vec<_>>();
1038 glyph_layers.push(GlyphLayerTexture::new(
1039 &self.components.gpu_state,
1040 run_color,
1041 bounds,
1042 &alpha_data,
1043 )?);
1044 }
1045 }
1046
1047 let has_next = unsafe { color_enumerator.MoveNext() }
1048 .map(|e| e.as_bool())
1049 .unwrap_or(false);
1050 if !has_next {
1051 break;
1052 }
1053 }
1054
1055 let gpu_state = &self.components.gpu_state;
1056 let params_buffer = {
1057 let desc = D3D11_BUFFER_DESC {
1058 ByteWidth: std::mem::size_of::<GlyphLayerTextureParams>() as u32,
1059 Usage: D3D11_USAGE_DYNAMIC,
1060 BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,
1061 CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
1062 MiscFlags: 0,
1063 StructureByteStride: 0,
1064 };
1065
1066 let mut buffer = None;
1067 unsafe {
1068 gpu_state
1069 .device
1070 .CreateBuffer(&desc, None, Some(&mut buffer))
1071 }?;
1072 [buffer]
1073 };
1074
1075 let render_target_texture = {
1076 let mut texture = None;
1077 let desc = D3D11_TEXTURE2D_DESC {
1078 Width: bitmap_size.width.0 as u32,
1079 Height: bitmap_size.height.0 as u32,
1080 MipLevels: 1,
1081 ArraySize: 1,
1082 Format: DXGI_FORMAT_B8G8R8A8_UNORM,
1083 SampleDesc: DXGI_SAMPLE_DESC {
1084 Count: 1,
1085 Quality: 0,
1086 },
1087 Usage: D3D11_USAGE_DEFAULT,
1088 BindFlags: D3D11_BIND_RENDER_TARGET.0 as u32,
1089 CPUAccessFlags: 0,
1090 MiscFlags: 0,
1091 };
1092 unsafe {
1093 gpu_state
1094 .device
1095 .CreateTexture2D(&desc, None, Some(&mut texture))
1096 }?;
1097 texture.unwrap()
1098 };
1099
1100 let render_target_view = {
1101 let desc = D3D11_RENDER_TARGET_VIEW_DESC {
1102 Format: DXGI_FORMAT_B8G8R8A8_UNORM,
1103 ViewDimension: D3D11_RTV_DIMENSION_TEXTURE2D,
1104 Anonymous: D3D11_RENDER_TARGET_VIEW_DESC_0 {
1105 Texture2D: D3D11_TEX2D_RTV { MipSlice: 0 },
1106 },
1107 };
1108 let mut rtv = None;
1109 unsafe {
1110 gpu_state.device.CreateRenderTargetView(
1111 &render_target_texture,
1112 Some(&desc),
1113 Some(&mut rtv),
1114 )
1115 }?;
1116 [rtv]
1117 };
1118
1119 let staging_texture = {
1120 let mut texture = None;
1121 let desc = D3D11_TEXTURE2D_DESC {
1122 Width: bitmap_size.width.0 as u32,
1123 Height: bitmap_size.height.0 as u32,
1124 MipLevels: 1,
1125 ArraySize: 1,
1126 Format: DXGI_FORMAT_B8G8R8A8_UNORM,
1127 SampleDesc: DXGI_SAMPLE_DESC {
1128 Count: 1,
1129 Quality: 0,
1130 },
1131 Usage: D3D11_USAGE_STAGING,
1132 BindFlags: 0,
1133 CPUAccessFlags: D3D11_CPU_ACCESS_READ.0 as u32,
1134 MiscFlags: 0,
1135 };
1136 unsafe {
1137 gpu_state
1138 .device
1139 .CreateTexture2D(&desc, None, Some(&mut texture))
1140 }?;
1141 texture.unwrap()
1142 };
1143
1144 let device_context = &gpu_state.device_context;
1145 unsafe { device_context.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP) };
1146 unsafe { device_context.VSSetShader(&gpu_state.vertex_shader, None) };
1147 unsafe { device_context.PSSetShader(&gpu_state.pixel_shader, None) };
1148 unsafe { device_context.VSSetConstantBuffers(0, Some(¶ms_buffer)) };
1149 unsafe { device_context.PSSetConstantBuffers(0, Some(¶ms_buffer)) };
1150 unsafe { device_context.OMSetRenderTargets(Some(&render_target_view), None) };
1151 unsafe { device_context.PSSetSamplers(0, Some(&gpu_state.sampler)) };
1152 unsafe { device_context.OMSetBlendState(&gpu_state.blend_state, None, 0xffffffff) };
1153
1154 for layer in glyph_layers {
1155 let params = GlyphLayerTextureParams {
1156 run_color: layer.run_color,
1157 bounds: layer.bounds,
1158 };
1159 unsafe {
1160 let mut dest = std::mem::zeroed();
1161 gpu_state.device_context.Map(
1162 params_buffer[0].as_ref().unwrap(),
1163 0,
1164 D3D11_MAP_WRITE_DISCARD,
1165 0,
1166 Some(&mut dest),
1167 )?;
1168 std::ptr::copy_nonoverlapping(¶ms as *const _, dest.pData as *mut _, 1);
1169 gpu_state
1170 .device_context
1171 .Unmap(params_buffer[0].as_ref().unwrap(), 0);
1172 };
1173
1174 let texture = [Some(layer.texture_view)];
1175 unsafe { device_context.PSSetShaderResources(0, Some(&texture)) };
1176
1177 let viewport = [D3D11_VIEWPORT {
1178 TopLeftX: layer.bounds.origin.x as f32,
1179 TopLeftY: layer.bounds.origin.y as f32,
1180 Width: layer.bounds.size.width as f32,
1181 Height: layer.bounds.size.height as f32,
1182 MinDepth: 0.0,
1183 MaxDepth: 1.0,
1184 }];
1185 unsafe { device_context.RSSetViewports(Some(&viewport)) };
1186
1187 unsafe { device_context.Draw(4, 0) };
1188 }
1189
1190 unsafe { device_context.CopyResource(&staging_texture, &render_target_texture) };
1191
1192 let mapped_data = {
1193 let mut mapped_data = D3D11_MAPPED_SUBRESOURCE::default();
1194 unsafe {
1195 device_context.Map(
1196 &staging_texture,
1197 0,
1198 D3D11_MAP_READ,
1199 0,
1200 Some(&mut mapped_data),
1201 )
1202 }?;
1203 mapped_data
1204 };
1205 let mut rasterized =
1206 vec![0u8; (bitmap_size.width.0 as u32 * bitmap_size.height.0 as u32 * 4) as usize];
1207
1208 for y in 0..bitmap_size.height.0 as usize {
1209 let width = bitmap_size.width.0 as usize;
1210 unsafe {
1211 std::ptr::copy_nonoverlapping::<u8>(
1212 (mapped_data.pData as *const u8).byte_add(mapped_data.RowPitch as usize * y),
1213 rasterized
1214 .as_mut_ptr()
1215 .byte_add(width * y * std::mem::size_of::<u32>()),
1216 width * std::mem::size_of::<u32>(),
1217 )
1218 };
1219 }
1220
1221 Ok(rasterized)
1222 }
1223
1224 fn get_typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>> {
1225 unsafe {
1226 let font = &self.fonts[font_id.0].font_face;
1227 let glyph_indices = [glyph_id.0 as u16];
1228 let mut metrics = [DWRITE_GLYPH_METRICS::default()];
1229 font.GetDesignGlyphMetrics(glyph_indices.as_ptr(), 1, metrics.as_mut_ptr(), false)?;
1230
1231 let metrics = &metrics[0];
1232 let advance_width = metrics.advanceWidth as i32;
1233 let advance_height = metrics.advanceHeight as i32;
1234 let left_side_bearing = metrics.leftSideBearing;
1235 let right_side_bearing = metrics.rightSideBearing;
1236 let top_side_bearing = metrics.topSideBearing;
1237 let bottom_side_bearing = metrics.bottomSideBearing;
1238 let vertical_origin_y = metrics.verticalOriginY;
1239
1240 let y_offset = vertical_origin_y + bottom_side_bearing - advance_height;
1241 let width = advance_width - (left_side_bearing + right_side_bearing);
1242 let height = advance_height - (top_side_bearing + bottom_side_bearing);
1243
1244 Ok(Bounds {
1245 origin: Point {
1246 x: left_side_bearing as f32,
1247 y: y_offset as f32,
1248 },
1249 size: Size {
1250 width: width as f32,
1251 height: height as f32,
1252 },
1253 })
1254 }
1255 }
1256
1257 fn get_advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
1258 unsafe {
1259 let font = &self.fonts[font_id.0].font_face;
1260 let glyph_indices = [glyph_id.0 as u16];
1261 let mut metrics = [DWRITE_GLYPH_METRICS::default()];
1262 font.GetDesignGlyphMetrics(glyph_indices.as_ptr(), 1, metrics.as_mut_ptr(), false)?;
1263
1264 let metrics = &metrics[0];
1265
1266 Ok(Size {
1267 width: metrics.advanceWidth as f32,
1268 height: 0.0,
1269 })
1270 }
1271 }
1272
1273 fn all_font_names(&self) -> Vec<String> {
1274 let mut result =
1275 get_font_names_from_collection(&self.system_font_collection, &self.components.locale);
1276 result.extend(get_font_names_from_collection(
1277 &self.custom_font_collection,
1278 &self.components.locale,
1279 ));
1280 result
1281 }
1282}
1283
1284impl Drop for DirectWriteState {
1285 fn drop(&mut self) {
1286 unsafe {
1287 let _ = self
1288 .components
1289 .factory
1290 .UnregisterFontFileLoader(&self.components.in_memory_loader);
1291 }
1292 }
1293}
1294
1295struct GlyphLayerTexture {
1296 run_color: Rgba,
1297 bounds: Bounds<i32>,
1298 texture: ID3D11Texture2D,
1299 texture_view: ID3D11ShaderResourceView,
1300}
1301
1302impl GlyphLayerTexture {
1303 pub fn new(
1304 gpu_state: &GPUState,
1305 run_color: Rgba,
1306 bounds: Bounds<i32>,
1307 alpha_data: &[u8],
1308 ) -> Result<Self> {
1309 let texture_size = bounds.size;
1310
1311 let desc = D3D11_TEXTURE2D_DESC {
1312 Width: texture_size.width as u32,
1313 Height: texture_size.height as u32,
1314 MipLevels: 1,
1315 ArraySize: 1,
1316 Format: DXGI_FORMAT_R8G8B8A8_UNORM,
1317 SampleDesc: DXGI_SAMPLE_DESC {
1318 Count: 1,
1319 Quality: 0,
1320 },
1321 Usage: D3D11_USAGE_DEFAULT,
1322 BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,
1323 CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,
1324 MiscFlags: 0,
1325 };
1326
1327 let texture = {
1328 let mut texture: Option<ID3D11Texture2D> = None;
1329 unsafe {
1330 gpu_state
1331 .device
1332 .CreateTexture2D(&desc, None, Some(&mut texture))?
1333 };
1334 texture.unwrap()
1335 };
1336 let texture_view = {
1337 let mut view: Option<ID3D11ShaderResourceView> = None;
1338 unsafe {
1339 gpu_state
1340 .device
1341 .CreateShaderResourceView(&texture, None, Some(&mut view))?
1342 };
1343 view.unwrap()
1344 };
1345
1346 unsafe {
1347 gpu_state.device_context.UpdateSubresource(
1348 &texture,
1349 0,
1350 None,
1351 alpha_data.as_ptr() as _,
1352 (texture_size.width * 4) as u32,
1353 0,
1354 )
1355 };
1356
1357 Ok(GlyphLayerTexture {
1358 run_color,
1359 bounds,
1360 texture,
1361 texture_view,
1362 })
1363 }
1364}
1365
1366#[repr(C)]
1367struct GlyphLayerTextureParams {
1368 bounds: Bounds<i32>,
1369 run_color: Rgba,
1370}
1371
1372struct TextRendererWrapper(pub IDWriteTextRenderer);
1373
1374impl TextRendererWrapper {
1375 pub fn new(locale_str: &str) -> Self {
1376 let inner = TextRenderer::new(locale_str);
1377 TextRendererWrapper(inner.into())
1378 }
1379}
1380
1381#[implement(IDWriteTextRenderer)]
1382struct TextRenderer {
1383 locale: String,
1384}
1385
1386impl TextRenderer {
1387 pub fn new(locale_str: &str) -> Self {
1388 TextRenderer {
1389 locale: locale_str.to_owned(),
1390 }
1391 }
1392}
1393
1394struct RendererContext<'t, 'a, 'b> {
1395 text_system: &'t mut DirectWriteState,
1396 index_converter: StringIndexConverter<'a>,
1397 runs: &'b mut Vec<ShapedRun>,
1398 width: f32,
1399}
1400
1401#[derive(Debug)]
1402struct ClusterAnalyzer<'t> {
1403 utf16_idx: usize,
1404 glyph_idx: usize,
1405 glyph_count: usize,
1406 cluster_map: &'t [u16],
1407}
1408
1409impl<'t> ClusterAnalyzer<'t> {
1410 pub fn new(cluster_map: &'t [u16], glyph_count: usize) -> Self {
1411 ClusterAnalyzer {
1412 utf16_idx: 0,
1413 glyph_idx: 0,
1414 glyph_count,
1415 cluster_map,
1416 }
1417 }
1418}
1419
1420impl Iterator for ClusterAnalyzer<'_> {
1421 type Item = (usize, usize);
1422
1423 fn next(&mut self) -> Option<(usize, usize)> {
1424 if self.utf16_idx >= self.cluster_map.len() {
1425 return None; // No more clusters
1426 }
1427 let start_utf16_idx = self.utf16_idx;
1428 let current_glyph = self.cluster_map[start_utf16_idx] as usize;
1429
1430 // Find the end of current cluster (where glyph index changes)
1431 let mut end_utf16_idx = start_utf16_idx + 1;
1432 while end_utf16_idx < self.cluster_map.len()
1433 && self.cluster_map[end_utf16_idx] as usize == current_glyph
1434 {
1435 end_utf16_idx += 1;
1436 }
1437
1438 let utf16_len = end_utf16_idx - start_utf16_idx;
1439
1440 // Calculate glyph count for this cluster
1441 let next_glyph = if end_utf16_idx < self.cluster_map.len() {
1442 self.cluster_map[end_utf16_idx] as usize
1443 } else {
1444 self.glyph_count
1445 };
1446
1447 let glyph_count = next_glyph - current_glyph;
1448
1449 // Update state for next call
1450 self.utf16_idx = end_utf16_idx;
1451 self.glyph_idx = next_glyph;
1452
1453 Some((utf16_len, glyph_count))
1454 }
1455}
1456
1457#[allow(non_snake_case)]
1458impl IDWritePixelSnapping_Impl for TextRenderer_Impl {
1459 fn IsPixelSnappingDisabled(
1460 &self,
1461 _clientdrawingcontext: *const ::core::ffi::c_void,
1462 ) -> windows::core::Result<BOOL> {
1463 Ok(BOOL(0))
1464 }
1465
1466 fn GetCurrentTransform(
1467 &self,
1468 _clientdrawingcontext: *const ::core::ffi::c_void,
1469 transform: *mut DWRITE_MATRIX,
1470 ) -> windows::core::Result<()> {
1471 unsafe {
1472 *transform = DWRITE_MATRIX {
1473 m11: 1.0,
1474 m12: 0.0,
1475 m21: 0.0,
1476 m22: 1.0,
1477 dx: 0.0,
1478 dy: 0.0,
1479 };
1480 }
1481 Ok(())
1482 }
1483
1484 fn GetPixelsPerDip(
1485 &self,
1486 _clientdrawingcontext: *const ::core::ffi::c_void,
1487 ) -> windows::core::Result<f32> {
1488 Ok(1.0)
1489 }
1490}
1491
1492#[allow(non_snake_case)]
1493impl IDWriteTextRenderer_Impl for TextRenderer_Impl {
1494 fn DrawGlyphRun(
1495 &self,
1496 clientdrawingcontext: *const ::core::ffi::c_void,
1497 _baselineoriginx: f32,
1498 _baselineoriginy: f32,
1499 _measuringmode: DWRITE_MEASURING_MODE,
1500 glyphrun: *const DWRITE_GLYPH_RUN,
1501 glyphrundescription: *const DWRITE_GLYPH_RUN_DESCRIPTION,
1502 _clientdrawingeffect: windows::core::Ref<windows::core::IUnknown>,
1503 ) -> windows::core::Result<()> {
1504 let glyphrun = unsafe { &*glyphrun };
1505 let glyph_count = glyphrun.glyphCount as usize;
1506 if glyph_count == 0 || glyphrun.fontFace.is_none() {
1507 return Ok(());
1508 }
1509 let desc = unsafe { &*glyphrundescription };
1510 let context = unsafe {
1511 &mut *(clientdrawingcontext as *const RendererContext as *mut RendererContext)
1512 };
1513 let font_face = glyphrun.fontFace.as_ref().unwrap();
1514 // This `cast()` action here should never fail since we are running on Win10+, and
1515 // `IDWriteFontFace3` requires Win10
1516 let font_face = &font_face.cast::<IDWriteFontFace3>().unwrap();
1517 let Some((font_identifier, font_struct, color_font)) =
1518 get_font_identifier_and_font_struct(font_face, &self.locale)
1519 else {
1520 return Ok(());
1521 };
1522
1523 let font_id = if let Some(id) = context
1524 .text_system
1525 .font_id_by_identifier
1526 .get(&font_identifier)
1527 {
1528 *id
1529 } else {
1530 context.text_system.select_font(&font_struct)
1531 };
1532
1533 let glyph_ids = unsafe { std::slice::from_raw_parts(glyphrun.glyphIndices, glyph_count) };
1534 let glyph_advances =
1535 unsafe { std::slice::from_raw_parts(glyphrun.glyphAdvances, glyph_count) };
1536 let glyph_offsets =
1537 unsafe { std::slice::from_raw_parts(glyphrun.glyphOffsets, glyph_count) };
1538 let cluster_map =
1539 unsafe { std::slice::from_raw_parts(desc.clusterMap, desc.stringLength as usize) };
1540
1541 let mut cluster_analyzer = ClusterAnalyzer::new(cluster_map, glyph_count);
1542 let mut utf16_idx = desc.textPosition as usize;
1543 let mut glyph_idx = 0;
1544 let mut glyphs = Vec::with_capacity(glyph_count);
1545 for (cluster_utf16_len, cluster_glyph_count) in cluster_analyzer {
1546 context.index_converter.advance_to_utf16_ix(utf16_idx);
1547 utf16_idx += cluster_utf16_len;
1548 for (cluster_glyph_idx, glyph_id) in glyph_ids
1549 [glyph_idx..(glyph_idx + cluster_glyph_count)]
1550 .iter()
1551 .enumerate()
1552 {
1553 let id = GlyphId(*glyph_id as u32);
1554 let is_emoji = color_font
1555 && is_color_glyph(font_face, id, &context.text_system.components.factory);
1556 let this_glyph_idx = glyph_idx + cluster_glyph_idx;
1557 glyphs.push(ShapedGlyph {
1558 id,
1559 position: point(
1560 px(context.width + glyph_offsets[this_glyph_idx].advanceOffset),
1561 px(0.0),
1562 ),
1563 index: context.index_converter.utf8_ix,
1564 is_emoji,
1565 });
1566 context.width += glyph_advances[this_glyph_idx];
1567 }
1568 glyph_idx += cluster_glyph_count;
1569 }
1570 context.runs.push(ShapedRun { font_id, glyphs });
1571 Ok(())
1572 }
1573
1574 fn DrawUnderline(
1575 &self,
1576 _clientdrawingcontext: *const ::core::ffi::c_void,
1577 _baselineoriginx: f32,
1578 _baselineoriginy: f32,
1579 _underline: *const DWRITE_UNDERLINE,
1580 _clientdrawingeffect: windows::core::Ref<windows::core::IUnknown>,
1581 ) -> windows::core::Result<()> {
1582 Err(windows::core::Error::new(
1583 E_NOTIMPL,
1584 "DrawUnderline unimplemented",
1585 ))
1586 }
1587
1588 fn DrawStrikethrough(
1589 &self,
1590 _clientdrawingcontext: *const ::core::ffi::c_void,
1591 _baselineoriginx: f32,
1592 _baselineoriginy: f32,
1593 _strikethrough: *const DWRITE_STRIKETHROUGH,
1594 _clientdrawingeffect: windows::core::Ref<windows::core::IUnknown>,
1595 ) -> windows::core::Result<()> {
1596 Err(windows::core::Error::new(
1597 E_NOTIMPL,
1598 "DrawStrikethrough unimplemented",
1599 ))
1600 }
1601
1602 fn DrawInlineObject(
1603 &self,
1604 _clientdrawingcontext: *const ::core::ffi::c_void,
1605 _originx: f32,
1606 _originy: f32,
1607 _inlineobject: windows::core::Ref<IDWriteInlineObject>,
1608 _issideways: BOOL,
1609 _isrighttoleft: BOOL,
1610 _clientdrawingeffect: windows::core::Ref<windows::core::IUnknown>,
1611 ) -> windows::core::Result<()> {
1612 Err(windows::core::Error::new(
1613 E_NOTIMPL,
1614 "DrawInlineObject unimplemented",
1615 ))
1616 }
1617}
1618
1619struct StringIndexConverter<'a> {
1620 text: &'a str,
1621 utf8_ix: usize,
1622 utf16_ix: usize,
1623}
1624
1625impl<'a> StringIndexConverter<'a> {
1626 fn new(text: &'a str) -> Self {
1627 Self {
1628 text,
1629 utf8_ix: 0,
1630 utf16_ix: 0,
1631 }
1632 }
1633
1634 #[allow(dead_code)]
1635 fn advance_to_utf8_ix(&mut self, utf8_target: usize) {
1636 for (ix, c) in self.text[self.utf8_ix..].char_indices() {
1637 if self.utf8_ix + ix >= utf8_target {
1638 self.utf8_ix += ix;
1639 return;
1640 }
1641 self.utf16_ix += c.len_utf16();
1642 }
1643 self.utf8_ix = self.text.len();
1644 }
1645
1646 fn advance_to_utf16_ix(&mut self, utf16_target: usize) {
1647 for (ix, c) in self.text[self.utf8_ix..].char_indices() {
1648 if self.utf16_ix >= utf16_target {
1649 self.utf8_ix += ix;
1650 return;
1651 }
1652 self.utf16_ix += c.len_utf16();
1653 }
1654 self.utf8_ix = self.text.len();
1655 }
1656}
1657
1658impl Into<DWRITE_FONT_STYLE> for FontStyle {
1659 fn into(self) -> DWRITE_FONT_STYLE {
1660 match self {
1661 FontStyle::Normal => DWRITE_FONT_STYLE_NORMAL,
1662 FontStyle::Italic => DWRITE_FONT_STYLE_ITALIC,
1663 FontStyle::Oblique => DWRITE_FONT_STYLE_OBLIQUE,
1664 }
1665 }
1666}
1667
1668impl From<DWRITE_FONT_STYLE> for FontStyle {
1669 fn from(value: DWRITE_FONT_STYLE) -> Self {
1670 match value.0 {
1671 0 => FontStyle::Normal,
1672 1 => FontStyle::Italic,
1673 2 => FontStyle::Oblique,
1674 _ => unreachable!(),
1675 }
1676 }
1677}
1678
1679impl Into<DWRITE_FONT_WEIGHT> for FontWeight {
1680 fn into(self) -> DWRITE_FONT_WEIGHT {
1681 DWRITE_FONT_WEIGHT(self.0 as i32)
1682 }
1683}
1684
1685impl From<DWRITE_FONT_WEIGHT> for FontWeight {
1686 fn from(value: DWRITE_FONT_WEIGHT) -> Self {
1687 FontWeight(value.0 as f32)
1688 }
1689}
1690
1691fn get_font_names_from_collection(
1692 collection: &IDWriteFontCollection1,
1693 locale: &str,
1694) -> Vec<String> {
1695 unsafe {
1696 let mut result = Vec::new();
1697 let family_count = collection.GetFontFamilyCount();
1698 for index in 0..family_count {
1699 let Some(font_family) = collection.GetFontFamily(index).log_err() else {
1700 continue;
1701 };
1702 let Some(localized_family_name) = font_family.GetFamilyNames().log_err() else {
1703 continue;
1704 };
1705 let Some(family_name) = get_name(localized_family_name, locale).log_err() else {
1706 continue;
1707 };
1708 result.push(family_name);
1709 }
1710
1711 result
1712 }
1713}
1714
1715fn get_font_identifier_and_font_struct(
1716 font_face: &IDWriteFontFace3,
1717 locale: &str,
1718) -> Option<(FontIdentifier, Font, bool)> {
1719 let postscript_name = get_postscript_name(font_face, locale).log_err()?;
1720 let localized_family_name = unsafe { font_face.GetFamilyNames().log_err() }?;
1721 let family_name = get_name(localized_family_name, locale).log_err()?;
1722 let weight = unsafe { font_face.GetWeight() };
1723 let style = unsafe { font_face.GetStyle() };
1724 let identifier = FontIdentifier {
1725 postscript_name,
1726 weight: weight.0,
1727 style: style.0,
1728 };
1729 let font_struct = Font {
1730 family: family_name.into(),
1731 features: FontFeatures::default(),
1732 weight: weight.into(),
1733 style: style.into(),
1734 fallbacks: None,
1735 };
1736 let is_emoji = unsafe { font_face.IsColorFont().as_bool() };
1737 Some((identifier, font_struct, is_emoji))
1738}
1739
1740#[inline]
1741fn get_font_identifier(font_face: &IDWriteFontFace3, locale: &str) -> Option<FontIdentifier> {
1742 let weight = unsafe { font_face.GetWeight().0 };
1743 let style = unsafe { font_face.GetStyle().0 };
1744 get_postscript_name(font_face, locale)
1745 .log_err()
1746 .map(|postscript_name| FontIdentifier {
1747 postscript_name,
1748 weight,
1749 style,
1750 })
1751}
1752
1753#[inline]
1754fn get_postscript_name(font_face: &IDWriteFontFace3, locale: &str) -> Result<String> {
1755 let mut info = None;
1756 let mut exists = BOOL(0);
1757 unsafe {
1758 font_face.GetInformationalStrings(
1759 DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME,
1760 &mut info,
1761 &mut exists,
1762 )?
1763 };
1764 if !exists.as_bool() || info.is_none() {
1765 anyhow::bail!("No postscript name found for font face");
1766 }
1767
1768 get_name(info.unwrap(), locale)
1769}
1770
1771// https://learn.microsoft.com/en-us/windows/win32/api/dwrite/ne-dwrite-dwrite_font_feature_tag
1772fn apply_font_features(
1773 direct_write_features: &IDWriteTypography,
1774 features: &FontFeatures,
1775) -> Result<()> {
1776 let tag_values = features.tag_value_list();
1777 if tag_values.is_empty() {
1778 return Ok(());
1779 }
1780
1781 // All of these features are enabled by default by DirectWrite.
1782 // If you want to (and can) peek into the source of DirectWrite
1783 let mut feature_liga = make_direct_write_feature("liga", 1);
1784 let mut feature_clig = make_direct_write_feature("clig", 1);
1785 let mut feature_calt = make_direct_write_feature("calt", 1);
1786
1787 for (tag, value) in tag_values {
1788 if tag.as_str() == "liga" && *value == 0 {
1789 feature_liga.parameter = 0;
1790 continue;
1791 }
1792 if tag.as_str() == "clig" && *value == 0 {
1793 feature_clig.parameter = 0;
1794 continue;
1795 }
1796 if tag.as_str() == "calt" && *value == 0 {
1797 feature_calt.parameter = 0;
1798 continue;
1799 }
1800
1801 unsafe {
1802 direct_write_features.AddFontFeature(make_direct_write_feature(&tag, *value))?;
1803 }
1804 }
1805 unsafe {
1806 direct_write_features.AddFontFeature(feature_liga)?;
1807 direct_write_features.AddFontFeature(feature_clig)?;
1808 direct_write_features.AddFontFeature(feature_calt)?;
1809 }
1810
1811 Ok(())
1812}
1813
1814#[inline]
1815const fn make_direct_write_feature(feature_name: &str, parameter: u32) -> DWRITE_FONT_FEATURE {
1816 let tag = make_direct_write_tag(feature_name);
1817 DWRITE_FONT_FEATURE {
1818 nameTag: tag,
1819 parameter,
1820 }
1821}
1822
1823#[inline]
1824const fn make_open_type_tag(tag_name: &str) -> u32 {
1825 let bytes = tag_name.as_bytes();
1826 debug_assert!(bytes.len() == 4);
1827 u32::from_le_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
1828}
1829
1830#[inline]
1831const fn make_direct_write_tag(tag_name: &str) -> DWRITE_FONT_FEATURE_TAG {
1832 DWRITE_FONT_FEATURE_TAG(make_open_type_tag(tag_name))
1833}
1834
1835#[inline]
1836fn get_name(string: IDWriteLocalizedStrings, locale: &str) -> Result<String> {
1837 let mut locale_name_index = 0u32;
1838 let mut exists = BOOL(0);
1839 unsafe {
1840 string.FindLocaleName(
1841 &HSTRING::from(locale),
1842 &mut locale_name_index,
1843 &mut exists as _,
1844 )?
1845 };
1846 if !exists.as_bool() {
1847 unsafe {
1848 string.FindLocaleName(
1849 DEFAULT_LOCALE_NAME,
1850 &mut locale_name_index as _,
1851 &mut exists as _,
1852 )?
1853 };
1854 anyhow::ensure!(exists.as_bool(), "No localised string for {locale}");
1855 }
1856
1857 let name_length = unsafe { string.GetStringLength(locale_name_index) }? as usize;
1858 let mut name_vec = vec![0u16; name_length + 1];
1859 unsafe {
1860 string.GetString(locale_name_index, &mut name_vec)?;
1861 }
1862
1863 Ok(String::from_utf16_lossy(&name_vec[..name_length]))
1864}
1865
1866fn get_system_ui_font_name() -> SharedString {
1867 unsafe {
1868 let mut info: LOGFONTW = std::mem::zeroed();
1869 let font_family = if SystemParametersInfoW(
1870 SPI_GETICONTITLELOGFONT,
1871 std::mem::size_of::<LOGFONTW>() as u32,
1872 Some(&mut info as *mut _ as _),
1873 SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS(0),
1874 )
1875 .log_err()
1876 .is_none()
1877 {
1878 // https://learn.microsoft.com/en-us/windows/win32/uxguide/vis-fonts
1879 // Segoe UI is the Windows font intended for user interface text strings.
1880 "Segoe UI".into()
1881 } else {
1882 let font_name = String::from_utf16_lossy(&info.lfFaceName);
1883 font_name.trim_matches(char::from(0)).to_owned().into()
1884 };
1885 log::info!("Use {} as UI font.", font_family);
1886 font_family
1887 }
1888}
1889
1890// One would think that with newer DirectWrite method: IDWriteFontFace4::GetGlyphImageFormats
1891// but that doesn't seem to work for some glyphs, say ❤
1892fn is_color_glyph(
1893 font_face: &IDWriteFontFace3,
1894 glyph_id: GlyphId,
1895 factory: &IDWriteFactory5,
1896) -> bool {
1897 let glyph_run = DWRITE_GLYPH_RUN {
1898 fontFace: unsafe { std::mem::transmute_copy(font_face) },
1899 fontEmSize: 14.0,
1900 glyphCount: 1,
1901 glyphIndices: &(glyph_id.0 as u16),
1902 glyphAdvances: &0.0,
1903 glyphOffsets: &DWRITE_GLYPH_OFFSET {
1904 advanceOffset: 0.0,
1905 ascenderOffset: 0.0,
1906 },
1907 isSideways: BOOL(0),
1908 bidiLevel: 0,
1909 };
1910 unsafe {
1911 factory.TranslateColorGlyphRun(
1912 Vector2::default(),
1913 &glyph_run as _,
1914 None,
1915 DWRITE_GLYPH_IMAGE_FORMATS_COLR
1916 | DWRITE_GLYPH_IMAGE_FORMATS_SVG
1917 | DWRITE_GLYPH_IMAGE_FORMATS_PNG
1918 | DWRITE_GLYPH_IMAGE_FORMATS_JPEG
1919 | DWRITE_GLYPH_IMAGE_FORMATS_PREMULTIPLIED_B8G8R8A8,
1920 DWRITE_MEASURING_MODE_NATURAL,
1921 None,
1922 0,
1923 )
1924 }
1925 .is_ok()
1926}
1927
1928const DEFAULT_LOCALE_NAME: PCWSTR = windows::core::w!("en-US");
1929
1930#[cfg(test)]
1931mod tests {
1932 use crate::platform::windows::direct_write::ClusterAnalyzer;
1933
1934 #[test]
1935 fn test_cluster_map() {
1936 let cluster_map = [0];
1937 let mut analyzer = ClusterAnalyzer::new(&cluster_map, 1);
1938 let next = analyzer.next();
1939 assert_eq!(next, Some((1, 1)));
1940 let next = analyzer.next();
1941 assert_eq!(next, None);
1942
1943 let cluster_map = [0, 1, 2];
1944 let mut analyzer = ClusterAnalyzer::new(&cluster_map, 3);
1945 let next = analyzer.next();
1946 assert_eq!(next, Some((1, 1)));
1947 let next = analyzer.next();
1948 assert_eq!(next, Some((1, 1)));
1949 let next = analyzer.next();
1950 assert_eq!(next, Some((1, 1)));
1951 let next = analyzer.next();
1952 assert_eq!(next, None);
1953 // 👨👩👧👦👩💻
1954 let cluster_map = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4];
1955 let mut analyzer = ClusterAnalyzer::new(&cluster_map, 5);
1956 let next = analyzer.next();
1957 assert_eq!(next, Some((11, 4)));
1958 let next = analyzer.next();
1959 assert_eq!(next, Some((5, 1)));
1960 let next = analyzer.next();
1961 assert_eq!(next, None);
1962 // 👩💻
1963 let cluster_map = [0, 0, 0, 0, 0];
1964 let mut analyzer = ClusterAnalyzer::new(&cluster_map, 1);
1965 let next = analyzer.next();
1966 assert_eq!(next, Some((5, 1)));
1967 let next = analyzer.next();
1968 assert_eq!(next, None);
1969 }
1970}