molgfx-core 0.3.5

The semantic scene graph: columnar tables, GPU record layouts, the borrowed coordinate seam.
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

//! Literal values a program can name directly.

use super::super::compiler::finite;
use super::super::{
    BoolExpr, ColorExpr, Opcode, ScalarExpr, ValueKind, VectorExpr, VisualError, VisualStage,
};
use super::VisualProgramBuilder;

impl VisualProgramBuilder {
    /// Literal scalar.
    ///
    /// # Errors
    ///
    /// Returns [`VisualError`] when the value is not finite, or when the
    /// program has no instruction slot left.
    pub fn scalar(&mut self, value: f32) -> Result<ScalarExpr, VisualError> {
        finite(&[value])?;
        self.emit_at(
            ValueKind::Scalar,
            Opcode::Constant,
            [0; 3],
            [value, 0.0, 0.0, 0.0],
            VisualStage::Uniform,
        )
        .map(ScalarExpr)
    }

    /// Literal linear RGBA color.
    ///
    /// # Errors
    ///
    /// Returns [`VisualError`] when the value is not finite, or when the
    /// program has no instruction slot left.
    pub fn color(&mut self, value: [f32; 4]) -> Result<ColorExpr, VisualError> {
        finite(&value)?;
        self.emit_at(
            ValueKind::Color,
            Opcode::Constant,
            [0; 3],
            value,
            VisualStage::Uniform,
        )
        .map(ColorExpr)
    }

    /// Literal vector.
    ///
    /// # Errors
    ///
    /// Returns [`VisualError`] when the value is not finite, or when the
    /// program has no instruction slot left.
    pub fn vector(&mut self, value: [f32; 3]) -> Result<VectorExpr, VisualError> {
        finite(&value)?;
        self.emit_at(
            ValueKind::Vector,
            Opcode::Constant,
            [0; 3],
            [value[0], value[1], value[2], 0.0],
            VisualStage::Uniform,
        )
        .map(VectorExpr)
    }

    /// Literal boolean.
    ///
    /// # Errors
    ///
    /// Returns [`VisualError`] when the value is not finite, or when the
    /// program has no instruction slot left.
    pub fn boolean(&mut self, value: bool) -> Result<BoolExpr, VisualError> {
        self.emit_at(
            ValueKind::Bool,
            Opcode::Constant,
            [0; 3],
            [f32::from(u8::from(value)), 0.0, 0.0, 0.0],
            VisualStage::Uniform,
        )
        .map(BoolExpr)
    }
}