blob: 16b112ae05510460fc9816b4370177b610a2a1d9 [file] [log] [blame]
// Copyright 2022 The piet-gpu authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Also licensed under MIT license, at your choice.
use piet_gpu::{EncodedSceneRef, PixelFormat, RenderConfig};
use piet_gpu_hal::{QueryPool, Session};
use piet_scene::geometry::{Affine, Rect};
use piet_scene::glyph::pinot::{types::Tag, FontDataRef};
use piet_scene::glyph::{GlyphContext, GlyphProvider};
use piet_scene::resource::ResourceContext;
use piet_scene::scene::{Fragment, Scene};
/// State and resources for rendering a scene.
pub struct PgpuRenderer {
session: Session,
pgpu_renderer: Option<piet_gpu::Renderer>,
query_pool: QueryPool,
width: u32,
height: u32,
is_color: bool,
}
impl PgpuRenderer {
#[cfg(all(
not(target_arch = "wasm32"),
any(target_os = "ios", target_os = "macos")
))]
pub fn new(device: &metal::DeviceRef, queue: &metal::CommandQueueRef) -> Self {
let piet_device = piet_gpu_hal::Device::new_from_raw_mtl(device, &queue);
let session = Session::new(piet_device);
let query_pool = session.create_query_pool(12).unwrap();
Self {
session,
pgpu_renderer: None,
query_pool,
width: 0,
height: 0,
is_color: false,
}
}
#[cfg(all(
not(target_arch = "wasm32"),
any(target_os = "ios", target_os = "macos")
))]
pub fn render(
&mut self,
scene: &PgpuScene,
cmdbuf: &metal::CommandBufferRef,
target: &metal::TextureRef,
) -> u32 {
let is_color = target.pixel_format() != metal::MTLPixelFormat::R8Unorm;
let width = target.width() as u32;
let height = target.height() as u32;
if self.pgpu_renderer.is_none()
|| self.width != width
|| self.height != height
|| self.is_color != is_color
{
self.width = width;
self.height = height;
self.is_color = is_color;
let format = if is_color {
PixelFormat::Rgba8
} else {
PixelFormat::A8
};
let config = RenderConfig::new(width as usize, height as usize).pixel_format(format);
unsafe {
self.pgpu_renderer =
piet_gpu::Renderer::new_from_config(&self.session, config, 1).ok();
}
}
unsafe {
let mut cmd_buf = self.session.cmd_buf_from_raw_mtl(cmdbuf);
let dst_image = self
.session
.image_from_raw_mtl(target, self.width, self.height);
if let Some(renderer) = &mut self.pgpu_renderer {
renderer.upload_scene(&scene.encoded_scene(), 0).unwrap();
renderer.record(&mut cmd_buf, &self.query_pool, 0);
// TODO later: we can bind the destination image and avoid the copy.
cmd_buf.blit_image(&renderer.image_dev, &dst_image);
cmd_buf.flush();
}
}
0
}
pub fn release(&mut self, _id: u32) {
// TODO: worry about freeing resources / managing overlapping submits
}
}
/// Encoded streams and resources describing a vector graphics scene.
pub struct PgpuScene {
scene: Scene,
rcx: ResourceContext,
}
impl PgpuScene {
pub fn new() -> Self {
Self {
scene: Scene::default(),
rcx: ResourceContext::new(),
}
}
pub fn builder(&mut self) -> PgpuSceneBuilder {
self.rcx.advance();
PgpuSceneBuilder(piet_scene::scene::build_scene(
&mut self.scene,
&mut self.rcx,
))
}
fn encoded_scene<'a>(&'a self) -> EncodedSceneRef<'a, piet_scene::geometry::Affine> {
let d = self.scene.data();
EncodedSceneRef {
transform_stream: &d.transform_stream,
tag_stream: &d.tag_stream,
pathseg_stream: &d.pathseg_stream,
linewidth_stream: &d.linewidth_stream,
drawtag_stream: &d.drawtag_stream,
drawdata_stream: &d.drawdata_stream,
n_path: d.n_path,
n_pathseg: d.n_pathseg,
n_clip: d.n_clip,
ramp_data: self.rcx.ramp_data(),
}
}
}
/// Encoded streams and resources describing a vector graphics scene fragment.
pub struct PgpuSceneFragment(pub Fragment);
impl PgpuSceneFragment {
pub fn new() -> Self {
Self(Fragment::default())
}
pub fn builder(&mut self) -> PgpuSceneBuilder {
PgpuSceneBuilder(piet_scene::scene::build_fragment(&mut self.0))
}
}
/// Builder for constructing an encoded scene.
pub struct PgpuSceneBuilder<'a>(pub piet_scene::scene::Builder<'a>);
impl<'a> PgpuSceneBuilder<'a> {
pub fn add_glyph(&mut self, glyph: &PgpuGlyph, transform: &piet_scene::geometry::Affine) {
self.0.append(&glyph.fragment, Some(*transform));
}
pub fn finish(self) {
self.0.finish();
}
}
/// Tag and value for a font variation axis.
#[derive(Copy, Clone)]
#[repr(C)]
pub struct PgpuFontVariation {
/// Tag that specifies the axis.
pub tag: u32,
/// Requested setting for the axis.
pub value: f32,
}
/// Context for loading and scaling glyphs.
pub struct PgpuGlyphContext(GlyphContext);
impl PgpuGlyphContext {
pub fn new() -> Self {
Self(GlyphContext::new())
}
pub fn new_provider<'a>(
&'a mut self,
font_data: &'a [u8],
font_index: u32,
font_id: u64,
ppem: f32,
hint: bool,
variations: &[PgpuFontVariation],
) -> Option<PgpuGlyphProvider> {
let font = FontDataRef::new(font_data).and_then(|f| f.get(font_index))?;
Some(PgpuGlyphProvider(
self.0.new_provider(
&font,
Some(font_id),
ppem,
hint,
variations
.iter()
.map(|variation| (Tag(variation.tag), variation.value)),
),
))
}
}
/// Context for loading a scaling glyphs from a specific font.
pub struct PgpuGlyphProvider<'a>(GlyphProvider<'a>);
impl<'a> PgpuGlyphProvider<'a> {
pub fn get(&mut self, gid: u16) -> Option<PgpuGlyph> {
let fragment = self.0.get(gid)?;
Some(PgpuGlyph { fragment })
}
pub fn get_color(&mut self, palette_index: u16, gid: u16) -> Option<PgpuGlyph> {
let fragment = self.0.get_color(palette_index, gid)?;
Some(PgpuGlyph { fragment })
}
}
/// Encoded (possibly color) outline for a glyph.
pub struct PgpuGlyph {
fragment: Fragment,
}
impl PgpuGlyph {
pub fn bbox(&self, transform: Option<Affine>) -> Rect {
if let Some(transform) = &transform {
Rect::from_points(
self.fragment
.points()
.iter()
.map(|p| p.transform(transform)),
)
} else {
Rect::from_points(self.fragment.points())
}
}
}