cranpose-render-common 0.1.174

Common rendering contracts for Cranpose
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

use cranpose_ui_graphics::{GraphicsLayer, Point, Rect};

use crate::graph::{ProjectiveTransform, quad_bounds};

pub(crate) fn layer_scale_x(layer: &GraphicsLayer) -> f32 {
    layer.scale * layer.scale_x
}

pub(crate) fn layer_scale_y(layer: &GraphicsLayer) -> f32 {
    layer.scale * layer.scale_y
}

pub fn layer_uniform_scale(layer: &GraphicsLayer) -> f32 {
    layer_scale_x(layer).min(layer_scale_y(layer))
}

pub(crate) fn layer_affine_is_identity(layer: &GraphicsLayer) -> bool {
    layer.scale == 1.0
        && layer.scale_x == 1.0
        && layer.scale_y == 1.0
        && layer.translation_x == 0.0
        && layer.translation_y == 0.0
}

pub fn apply_layer_affine_to_rect(rect: Rect, layer_bounds: Rect, layer: &GraphicsLayer) -> Rect {
    if layer_affine_is_identity(layer) {
        return rect;
    }
    let scale_x = layer_scale_x(layer);
    let scale_y = layer_scale_y(layer);
    let (pivot_x, pivot_y) = layer_rotation_pivot(layer_bounds, layer);
    Rect {
        x: pivot_x + (rect.x - pivot_x) * scale_x + layer.translation_x,
        y: pivot_y + (rect.y - pivot_y) * scale_y + layer.translation_y,
        width: rect.width * scale_x,
        height: rect.height * scale_y,
    }
}

/// Point counterpart of [`apply_layer_affine_to_rect`]: scale about the layer
/// pivot, then translate. Rotation/perspective are deliberately excluded — the
/// affine space is the one SDF shapes are evaluated in, with rotation carried
/// by the deformed quad instead.
pub fn apply_layer_affine_to_point(
    point: Point,
    layer_bounds: Rect,
    layer: &GraphicsLayer,
) -> Point {
    if layer_affine_is_identity(layer) {
        return point;
    }
    let (pivot_x, pivot_y) = layer_rotation_pivot(layer_bounds, layer);
    Point::new(
        pivot_x + (point.x - pivot_x) * layer_scale_x(layer) + layer.translation_x,
        pivot_y + (point.y - pivot_y) * layer_scale_y(layer) + layer.translation_y,
    )
}

fn layer_rotation_pivot(layer_bounds: Rect, layer: &GraphicsLayer) -> (f32, f32) {
    (
        layer_bounds.x + layer_bounds.width * layer.transform_origin.pivot_fraction_x,
        layer_bounds.y + layer_bounds.height * layer.transform_origin.pivot_fraction_y,
    )
}

pub(crate) fn layer_scales_or_rotates(layer: &GraphicsLayer) -> bool {
    layer_scale_x(layer) != 1.0 || layer_scale_y(layer) != 1.0 || layer_has_rotation(layer)
}

fn layer_has_rotation(layer: &GraphicsLayer) -> bool {
    layer.rotation_x.abs() > f32::EPSILON
        || layer.rotation_y.abs() > f32::EPSILON
        || layer.rotation_z.abs() > f32::EPSILON
}

/// Where the layer's turns -- about x, then y, then z -- take the x and y
/// axes of its plane, in three dimensions.
fn rotation_axes(layer: &GraphicsLayer) -> [[f32; 3]; 2] {
    let (sin_x, cos_x) = layer.rotation_x.to_radians().sin_cos();
    let (sin_y, cos_y) = layer.rotation_y.to_radians().sin_cos();
    let (sin_z, cos_z) = layer.rotation_z.to_radians().sin_cos();
    [
        [cos_z * cos_y, sin_z * cos_y, -sin_y],
        [
            cos_z * sin_x * sin_y - sin_z * cos_x,
            sin_z * sin_x * sin_y + cos_z * cos_x,
            sin_x * cos_y,
        ],
    ]
}

/// How far the camera a tilted layer is seen from stands before its plane.
fn camera_distance(layer: &GraphicsLayer) -> f32 {
    const CAMERA_DISTANCE_SCALE: f32 = 72.0;
    (layer.camera_distance * CAMERA_DISTANCE_SCALE).max(1.0)
}

fn apply_rotation_and_perspective(
    point: [f32; 2],
    pivot: (f32, f32),
    layer: &GraphicsLayer,
) -> [f32; 2] {
    if !layer_has_rotation(layer) {
        return point;
    }
    let (x, y) = (point[0] - pivot.0, point[1] - pivot.1);
    let [x_axis, y_axis] = rotation_axes(layer);
    let [turned_x, turned_y, turned_z] = [0, 1, 2].map(|axis| x * x_axis[axis] + y * y_axis[axis]);
    let camera_distance = camera_distance(layer);
    let perspective = camera_distance / (camera_distance - turned_z).max(1.0);
    [
        pivot.0 + turned_x * perspective,
        pivot.1 + turned_y * perspective,
    ]
}

fn apply_layer_to_point(point: [f32; 2], pivot: (f32, f32), layer: &GraphicsLayer) -> [f32; 2] {
    let scaled = [
        pivot.0 + (point[0] - pivot.0) * layer_scale_x(layer),
        pivot.1 + (point[1] - pivot.1) * layer_scale_y(layer),
    ];
    let rotated = apply_rotation_and_perspective(scaled, pivot, layer);
    [
        rotated[0] + layer.translation_x,
        rotated[1] + layer.translation_y,
    ]
}

pub fn apply_layer_to_quad(rect: Rect, layer_bounds: Rect, layer: &GraphicsLayer) -> [[f32; 2]; 4] {
    let quad = [
        [rect.x, rect.y],
        [rect.x + rect.width, rect.y],
        [rect.x, rect.y + rect.height],
        [rect.x + rect.width, rect.y + rect.height],
    ];
    if layer_affine_is_identity(layer) && !layer_has_rotation(layer) {
        return quad;
    }
    let pivot = layer_rotation_pivot(layer_bounds, layer);
    quad.map(|point| apply_layer_to_point(point, pivot, layer))
}

pub fn apply_layer_to_rect(rect: Rect, layer_bounds: Rect, layer: &GraphicsLayer) -> Rect {
    quad_bounds(apply_layer_to_quad(rect, layer_bounds, layer))
}

pub fn layer_transform_to_parent(
    local_bounds: Rect,
    placement: Point,
    layer: &GraphicsLayer,
) -> ProjectiveTransform {
    // Local space keeps the node's origin at `placement`, wherever the
    // layer's bounds sit in it, so a layer bounded at a coordinator away
    // from the node's origin clips and pivots there without moving content.
    //
    // The matrix is the layer's own scale, turn and camera, not a fit to
    // where they take its corners: a fit's rounding grows with the distance
    // from the origin, and a turned cell far down a screen came out skewed
    // by it, too skewed to draw in place.
    let (pivot_x, pivot_y) = layer_rotation_pivot(local_bounds, layer);
    let [x_axis, y_axis] = rotation_axes(layer);
    let (scale_x, scale_y) = (layer_scale_x(layer), layer_scale_y(layer));
    let camera_distance = camera_distance(layer);
    let turn = ProjectiveTransform::from_homogeneous([
        [x_axis[0] * scale_x, y_axis[0] * scale_y, 0.0],
        [x_axis[1] * scale_x, y_axis[1] * scale_y, 0.0],
        [
            -x_axis[2] * scale_x / camera_distance,
            -y_axis[2] * scale_y / camera_distance,
            1.0,
        ],
    ]);
    let placed = ProjectiveTransform::translation(-pivot_x, -pivot_y)
        .then(turn)
        .then(ProjectiveTransform::translation(pivot_x, pivot_y))
        .then(ProjectiveTransform::translation(
            placement.x + layer.translation_x,
            placement.y + layer.translation_y,
        ));
    ProjectiveTransform::from_homogeneous(placed.matrix())
}

#[cfg(test)]
#[path = "tests/layer_transform_tests.rs"]
mod tests;