box2d-rust 0.1.0

Pure Rust port of the Box2D v3 2D physics engine
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

// Tree validation from dynamic_tree.c. The C versions are compiled in only
// with B2_ENABLE_VALIDATION; here they always run when called (they are only
// invoked explicitly and from rebuild) and assert in debug builds.
// SPDX-FileCopyrightText: 2023 Erin Catto
// SPDX-License-Identifier: MIT

use super::{DynamicTree, ALLOCATED_NODE, ENLARGED_NODE};
use crate::core::NULL_INDEX;
use crate::math_functions::{aabb_contains, max_int};

impl DynamicTree {
    /// Compute the height of a sub-tree. (static b2ComputeHeight)
    fn compute_height(&self, node_id: i32) -> i32 {
        debug_assert!(0 <= node_id && node_id < self.node_capacity());
        let node = &self.nodes[node_id as usize];

        if node.is_leaf() {
            return 0;
        }

        let height1 = self.compute_height(node.child1);
        let height2 = self.compute_height(node.child2);
        1 + max_int(height1, height2)
    }

    /// (static b2ValidateStructure)
    fn validate_structure(&self, index: i32) {
        if index == NULL_INDEX {
            return;
        }

        if index == self.root {
            debug_assert!(self.nodes[index as usize].parent == NULL_INDEX);
        }

        let node = &self.nodes[index as usize];

        debug_assert!(node.flags == 0 || (node.flags & ALLOCATED_NODE) != 0);

        if node.is_leaf() {
            debug_assert!(node.height == 0);
            return;
        }

        let child1 = node.child1;
        let child2 = node.child2;

        debug_assert!(0 <= child1 && child1 < self.node_capacity());
        debug_assert!(0 <= child2 && child2 < self.node_capacity());

        debug_assert!(self.nodes[child1 as usize].parent == index);
        debug_assert!(self.nodes[child2 as usize].parent == index);

        if (self.nodes[child1 as usize].flags | self.nodes[child2 as usize].flags) & ENLARGED_NODE
            != 0
        {
            debug_assert!(node.flags & ENLARGED_NODE != 0);
        }

        self.validate_structure(child1);
        self.validate_structure(child2);
    }

    /// (static b2ValidateMetrics)
    fn validate_metrics(&self, index: i32) {
        if index == NULL_INDEX {
            return;
        }

        let node = &self.nodes[index as usize];

        if node.is_leaf() {
            debug_assert!(node.height == 0);
            return;
        }

        let child1 = node.child1;
        let child2 = node.child2;

        debug_assert!(0 <= child1 && child1 < self.node_capacity());
        debug_assert!(0 <= child2 && child2 < self.node_capacity());

        let height1 = self.nodes[child1 as usize].height;
        let height2 = self.nodes[child2 as usize].height;
        let height = 1 + if height1 > height2 { height1 } else { height2 };
        debug_assert!(node.height == height);

        debug_assert!(aabb_contains(node.aabb, self.nodes[child1 as usize].aabb));
        debug_assert!(aabb_contains(node.aabb, self.nodes[child2 as usize].aabb));

        let category_bits =
            self.nodes[child1 as usize].category_bits | self.nodes[child2 as usize].category_bits;
        debug_assert!(node.category_bits == category_bits);

        self.validate_metrics(child1);
        self.validate_metrics(child2);
    }

    /// Validate this tree. For testing. (b2DynamicTree_Validate)
    pub fn validate(&self) {
        if self.root == NULL_INDEX {
            return;
        }

        self.validate_structure(self.root);
        self.validate_metrics(self.root);

        let mut free_count = 0;
        let mut free_index = self.free_list;
        while free_index != NULL_INDEX {
            debug_assert!(0 <= free_index && free_index < self.node_capacity());
            free_index = self.nodes[free_index as usize].next;
            free_count += 1;
        }

        let height = self.height();
        let computed_height = self.compute_height(self.root);
        debug_assert!(height == computed_height);
        let _ = (height, computed_height);

        debug_assert!(self.node_count + free_count == self.node_capacity());
        let _ = free_count;
    }

    /// Validate this tree has no enlarged AABBs. For testing.
    /// (b2DynamicTree_ValidateNoEnlarged)
    pub fn validate_no_enlarged(&self) {
        for node in &self.nodes {
            if node.flags & ALLOCATED_NODE != 0 {
                debug_assert!(node.flags & ENLARGED_NODE == 0);
            }
        }
    }
}