pybevy 0.2.1

PyBevy: A Python Real-Time Engine Built on Bevy
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

//! Compile-time layout assertions for View API component types
//!
//! This module ensures that our assumptions about component memory layouts
//! are validated at compile time. If Bevy changes the layout of any component
//! in a future version, the build will fail rather than causing subtle bugs.
//!
//! These assertions are critical for the View API which relies on direct
//! memory access via field offsets for performance.

use bevy::{
    light::{DirectionalLight, PointLight, SpotLight},
    transform::components::Transform,
};

/// Verify Transform has stable size (48 bytes on current Rust/Bevy)
///
/// Layout: rotation (0-15), translation (16-27), scale (28-39), padding (40-47)
/// Total: 48 bytes (16-byte aligned, likely for SIMD)
///
/// IMPORTANT: Rust reordered fields! Declaration order is translation/rotation/scale,
/// but actual memory order is rotation/translation/scale (by alignment requirement).
const _: () = {
    assert!(
        std::mem::size_of::<Transform>() == 48,
        "Transform size changed! Expected 48 bytes (16-byte aligned). \
         This affects View API direct memory access."
    );
};

/// Verify Transform field offsets remain stable
///
/// These specific offsets are enforced to catch any layout changes.
/// The View API depends on these offsets for direct memory access.
const _: () = {
    const ROTATION: usize = std::mem::offset_of!(Transform, rotation);
    const TRANSLATION: usize = std::mem::offset_of!(Transform, translation);
    const SCALE: usize = std::mem::offset_of!(Transform, scale);

    // Enforce the actual layout observed on current Rust/Bevy
    // Rust reordered fields by alignment: rotation (16-byte) first, then Vec3s
    assert!(
        ROTATION == 0,
        "Transform.rotation offset changed! Expected 0, affects View API"
    );
    assert!(
        TRANSLATION == 16,
        "Transform.translation offset changed! Expected 16, affects View API"
    );
    assert!(
        SCALE == 28,
        "Transform.scale offset changed! Expected 28, affects View API"
    );
};

const _: () = {
    const SIZE: usize = std::mem::size_of::<PointLight>();

    // Verify all field offsets are within bounds
    assert!(
        std::mem::offset_of!(PointLight, intensity) < SIZE,
        "PointLight::intensity offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(PointLight, range) < SIZE,
        "PointLight::range offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(PointLight, radius) < SIZE,
        "PointLight::radius offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(PointLight, shadow_depth_bias) < SIZE,
        "PointLight::shadow_depth_bias offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(PointLight, shadow_normal_bias) < SIZE,
        "PointLight::shadow_normal_bias offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(PointLight, shadow_map_near_z) < SIZE,
        "PointLight::shadow_map_near_z offset out of bounds"
    );
};

const _: () = {
    const SIZE: usize = std::mem::size_of::<DirectionalLight>();

    assert!(
        std::mem::offset_of!(DirectionalLight, illuminance) < SIZE,
        "DirectionalLight::illuminance offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(DirectionalLight, shadow_depth_bias) < SIZE,
        "DirectionalLight::shadow_depth_bias offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(DirectionalLight, shadow_normal_bias) < SIZE,
        "DirectionalLight::shadow_normal_bias offset out of bounds"
    );
};

const _: () = {
    const SIZE: usize = std::mem::size_of::<SpotLight>();

    assert!(
        std::mem::offset_of!(SpotLight, intensity) < SIZE,
        "SpotLight::intensity offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, range) < SIZE,
        "SpotLight::range offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, radius) < SIZE,
        "SpotLight::radius offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, shadow_depth_bias) < SIZE,
        "SpotLight::shadow_depth_bias offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, shadow_normal_bias) < SIZE,
        "SpotLight::shadow_normal_bias offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, shadow_map_near_z) < SIZE,
        "SpotLight::shadow_map_near_z offset out of bounds"
    );
    assert!(
        std::mem::offset_of!(SpotLight, outer_angle) < SIZE,
        "SpotLight::outer_angle offset out of bounds"
    );
};