oximedia-virtual 0.1.8

Virtual production and LED wall tools for OxiMedia
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

//! In-Camera VFX (ICVFX) compositing subsystem
//!
//! Provides real-time compositing of foreground and background elements
//! with depth-based blending for in-camera visual effects.

pub mod background;
pub mod composite;
pub mod depth;
pub mod foreground;
pub mod frustum_tracking;
pub mod tiled;

pub use tiled::TiledCompositor;

use serde::{Deserialize, Serialize};

/// Composite layer
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompositeLayer {
    /// Layer name
    pub name: String,
    /// Layer opacity (0.0 - 1.0)
    pub opacity: f32,
    /// Layer enabled
    pub enabled: bool,
    /// Blend mode
    pub blend_mode: BlendMode,
}

impl CompositeLayer {
    /// Create new composite layer
    #[must_use]
    pub fn new(name: String) -> Self {
        Self {
            name,
            opacity: 1.0,
            enabled: true,
            blend_mode: BlendMode::Normal,
        }
    }
}

/// Blend mode for compositing
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum BlendMode {
    /// Normal alpha blending
    Normal,
    /// Additive blending
    Add,
    /// Multiply blending
    Multiply,
    /// Screen blending
    Screen,
    /// Overlay blending
    Overlay,
}

impl BlendMode {
    /// Apply blend mode to two colors
    #[must_use]
    pub fn blend(&self, base: [f32; 3], blend: [f32; 3], alpha: f32) -> [f32; 3] {
        match self {
            BlendMode::Normal => Self::blend_normal(base, blend, alpha),
            BlendMode::Add => Self::blend_add(base, blend, alpha),
            BlendMode::Multiply => Self::blend_multiply(base, blend, alpha),
            BlendMode::Screen => Self::blend_screen(base, blend, alpha),
            BlendMode::Overlay => Self::blend_overlay(base, blend, alpha),
        }
    }

    fn blend_normal(base: [f32; 3], blend: [f32; 3], alpha: f32) -> [f32; 3] {
        [
            base[0] * (1.0 - alpha) + blend[0] * alpha,
            base[1] * (1.0 - alpha) + blend[1] * alpha,
            base[2] * (1.0 - alpha) + blend[2] * alpha,
        ]
    }

    fn blend_add(base: [f32; 3], blend: [f32; 3], alpha: f32) -> [f32; 3] {
        [
            (base[0] + blend[0] * alpha).min(1.0),
            (base[1] + blend[1] * alpha).min(1.0),
            (base[2] + blend[2] * alpha).min(1.0),
        ]
    }

    fn blend_multiply(base: [f32; 3], blend: [f32; 3], _alpha: f32) -> [f32; 3] {
        [base[0] * blend[0], base[1] * blend[1], base[2] * blend[2]]
    }

    fn blend_screen(base: [f32; 3], blend: [f32; 3], _alpha: f32) -> [f32; 3] {
        [
            1.0 - (1.0 - base[0]) * (1.0 - blend[0]),
            1.0 - (1.0 - base[1]) * (1.0 - blend[1]),
            1.0 - (1.0 - base[2]) * (1.0 - blend[2]),
        ]
    }

    fn blend_overlay(base: [f32; 3], blend: [f32; 3], _alpha: f32) -> [f32; 3] {
        let overlay = |b: f32, s: f32| {
            if b < 0.5 {
                2.0 * b * s
            } else {
                1.0 - 2.0 * (1.0 - b) * (1.0 - s)
            }
        };

        [
            overlay(base[0], blend[0]),
            overlay(base[1], blend[1]),
            overlay(base[2], blend[2]),
        ]
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_composite_layer() {
        let layer = CompositeLayer::new("Test Layer".to_string());
        assert_eq!(layer.name, "Test Layer");
        assert_eq!(layer.opacity, 1.0);
        assert!(layer.enabled);
    }

    #[test]
    fn test_blend_normal() {
        let base = [1.0, 0.5, 0.0];
        let blend = [0.0, 0.5, 1.0];
        let result = BlendMode::Normal.blend(base, blend, 0.5);

        assert!((result[0] - 0.5).abs() < 1e-6);
        assert!((result[1] - 0.5).abs() < 1e-6);
        assert!((result[2] - 0.5).abs() < 1e-6);
    }

    #[test]
    fn test_blend_add() {
        let base = [0.5, 0.5, 0.5];
        let blend = [0.5, 0.5, 0.5];
        let result = BlendMode::Add.blend(base, blend, 1.0);

        assert!((result[0] - 1.0).abs() < 1e-6);
        assert!((result[1] - 1.0).abs() < 1e-6);
        assert!((result[2] - 1.0).abs() < 1e-6);
    }

    #[test]
    fn test_blend_multiply() {
        let base = [1.0, 0.5, 0.25];
        let blend = [0.5, 0.5, 0.5];
        let result = BlendMode::Multiply.blend(base, blend, 1.0);

        assert!((result[0] - 0.5).abs() < 1e-6);
        assert!((result[1] - 0.25).abs() < 1e-6);
        assert!((result[2] - 0.125).abs() < 1e-6);
    }
}