glwfr 0.3.2

Make graphics with OpenGL.
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

//! # Light Module
//!
//! This module provides structures for managing different types of lights in a 3D scene.
//!
//! ## Usage
//!
//! ```rust
//! use glwfr::cgmath::{Deg, Vector3};
//! use glwfr::light::{Light, LightType};
//!
//! fn main() {
//!     // Create a point light
//!     let mut point_light = Light::new(LightType::Point {
//!         position: Vector3::new(1.0, 2.0, 3.0),
//!         color: Vector3::new(1.0, 1.0, 1.0),
//!         intensity: 1.0,
//!     });
//!
//!     // Change the light's color and intensity
//!     point_light.set_color(Vector3::new(1.0, 0.5, 0.0));
//!     point_light.set_intensity(2.0);
//!
//!     // Convert the light to shader data
//!     let shader_data = point_light.to_shader_data();
//! }
//! ```

use cgmath::*;

/// Represents the type of light in a 3D scene.
pub enum LightType {
    /// A point light with a position, color, and intensity.
    Point {
        position: Vector3<f32>, // Position of the light
        color: Vector3<f32>,    // Color of the light (RGB)
        intensity: f32,         // Intensity of the light
    },
    /// A directional light with a direction, color, and intensity.
    Directional {
        direction: Vector3<f32>, // Direction of the light
        color: Vector3<f32>,     // Color of the light (RGB)
        intensity: f32,          // Intensity of the light
    },
    /// A spot light with a position, direction, color, intensity, and angle.
    Spot {
        position: Vector3<f32>,  // Position of the light
        direction: Vector3<f32>, // Direction of the light
        color: Vector3<f32>,     // Color of the light (RGB)
        intensity: f32,          // Intensity of the light
        angle: Deg<f32>,         // Angle of the spotlight cone
    },
}

/// Represents a light in a 3D scene.
pub struct Light {
    /// The type of light and its parameters.
    pub light_type: LightType,
}

impl Light {
    /// Creates a new light with the specified type.
    ///
    /// # Arguments
    ///
    /// * `light_type` - The type of light and its parameters.
    ///
    /// # Returns
    ///
    /// A new `Light` instance.
    pub fn new(light_type: LightType) -> Self {
        Self { light_type }
    }

    /// Converts the light into shader-friendly data.
    ///
    /// # Returns
    ///
    /// A `LightShaderData` instance containing the light's properties.
    pub fn to_shader_data(&self) -> LightShaderData {
        match &self.light_type {
            LightType::Point {
                position,
                color,
                intensity,
            } => LightShaderData {
                position: *position,
                direction: Vector3::new(0.0, 0.0, 0.0), // Not used for point lights
                color: *color,
                intensity: *intensity,
                angle: 0.0, // Not used for point lights
            },
            LightType::Directional {
                direction,
                color,
                intensity,
            } => LightShaderData {
                position: Vector3::new(0.0, 0.0, 0.0), // Not used for directional lights
                direction: *direction,
                color: *color,
                intensity: *intensity,
                angle: 0.0, // Not used for directional lights
            },
            LightType::Spot {
                position,
                direction,
                color,
                intensity,
                angle,
            } => LightShaderData {
                position: *position,
                direction: *direction,
                color: *color,
                intensity: *intensity,
                angle: angle.0.to_radians(),
            },
        }
    }

    /// Sets the color of the light.
    ///
    /// # Arguments
    ///
    /// * `color` - The new color of the light.
    pub fn set_color(&mut self, color: Vector3<f32>) {
        match &mut self.light_type {
            LightType::Point { color: c, .. } => *c = color,
            LightType::Directional { color: c, .. } => *c = color,
            LightType::Spot { color: c, .. } => *c = color,
        }
    }

    /// Sets the intensity of the light.
    ///
    /// # Arguments
    ///
    /// * `intensity` - The new intensity of the light.
    pub fn set_intensity(&mut self, intensity: f32) {
        match &mut self.light_type {
            LightType::Point { intensity: i, .. } => *i = intensity,
            LightType::Directional { intensity: i, .. } => *i = intensity,
            LightType::Spot { intensity: i, .. } => *i = intensity,
        }
    }
}

/// Represents light data in a format suitable for shaders.
#[derive(Clone, Copy)]
pub struct LightShaderData {
    /// The position of the light (for point and spot lights).
    pub position: Vector3<f32>,
    /// The direction of the light (for directional and spot lights).
    pub direction: Vector3<f32>,
    /// The color of the light.
    pub color: Vector3<f32>,
    /// The intensity of the light.
    pub intensity: f32,
    /// The angle of the spotlight cone (for spot lights).
    pub angle: f32,
}