acadrust 0.6.7

A pure Rust library for reading and writing CAD files in DXF format (ASCII and Binary) and DWG format (Binary).
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

use super::super::transform;
use super::*;

pub(crate) fn mirror_face3d(e: &mut Face3D, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_face3d(e, transform);
    if transform::is_reflecting(transform) {
        std::mem::swap(&mut e.first_corner, &mut e.fourth_corner);
        std::mem::swap(&mut e.second_corner, &mut e.third_corner);
        let bits = e.invisible_edges.bits();
        e.invisible_edges =
            InvisibleEdgeFlags::from_bits((bits & !5) | ((bits & 1) << 2) | ((bits & 4) >> 2));
    }
    e.common.raw_record = None;
}

pub(crate) fn mirror_solid(e: &mut Solid, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_solid(e, transform);
    e.common.raw_record = None;
}

pub(crate) fn mirror_mesh(e: &mut Mesh, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_mesh(e, transform);
    e.common.raw_record = None;
}

pub(crate) fn mirror_polyface_mesh(e: &mut PolyfaceMesh, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_polyface_mesh(e, transform);
    if transform::is_reflecting(transform) {
        for face in &mut e.faces {
            face.reverse();
            face.common.raw_record = None;
        }
    }
    for vertex in &mut e.vertices {
        vertex.common.raw_record = None;
    }
    e.common.raw_record = None;
}

pub(crate) fn mirror_polygon_mesh(e: &mut PolygonMeshEntity, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    let reflecting = transform::is_reflecting(transform);
    transform::transform_polygon_mesh(e, transform);
    // POLYMESH stores its grid in M-major rows. ACAD reverses each M row
    // under a reflection so the smoothing surface and closure seams retain
    // their geometric edge ownership.
    if reflecting && e.m_vertex_count > 0 {
        let m = e.m_vertex_count as usize;
        for row in e.vertices.chunks_exact_mut(m) {
            row.reverse();
        }
    }
    e.common.raw_record = None;
}

pub(crate) fn mirror_solid3d(e: &mut Solid3D, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_solid3d(e, transform);
    e.common.raw_record = None;
}

pub(crate) fn mirror_region(e: &mut Region, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_region(e, transform);
    e.common.raw_record = None;
}

pub(crate) fn mirror_body(e: &mut Body, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_body(e, transform);
    e.common.raw_record = None;
}

pub(crate) fn mirror_surface(e: &mut Surface, transform: &Transform) {
    if !super::valid_transform(transform) {
        return;
    }
    transform::transform_surface(e, transform);
    e.common.raw_record = None;
}