Fast-Quadric-Mesh-Simplification/Main.cpp at master · inventables/Fast-Quadric-Mesh-Simplification · GitHub

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
// Simple wrapper for Sven Forstmann's mesh simplification tool
//
// http://voxels.blogspot.com/2014/05/quadric-mesh-simplification-with-source.html
// https://github.com/sp4cerat/Fast-Quadric-Mesh-Simplification
//
// Forked from
// https://github.com/myMiniFactory/Fast-Quadric-Mesh-Simplification/
//
// This version targets WASM and avoids stdio dependencies and instead exposes
// raw buffer versions of the simplify API
//

#include "Simplify.h"
#include <stdint.h>
#include <vector>

// Define the format types for the raw API
enum MeshFormat {
    FORMAT_OBJ = 0,
    FORMAT_STL = 1
};

// Process buffers directly without file I/O, stdio, or timing functions
int simplify_raw(const uint8_t* input_buffer, size_t input_size, MeshFormat input_format,
                uint8_t** output_buffer, size_t* output_size, MeshFormat output_format,
                float reduceFraction, float agressiveness) {

    // Clear any existing data
    Simplify::vertices.clear();
    Simplify::triangles.clear();

    // Load based on input format
    bool load_success = false;
    if (input_format == FORMAT_OBJ) {
        load_success = Simplify::load_obj(input_buffer, input_size);
    } else if (input_format == FORMAT_STL) {
        load_success = Simplify::load_stl(input_buffer, input_size);
    } else {
        return InvalidInFormat;
    }

    if (!load_success) {
        return LoadError;
    }

    // Basic validation
    if ((Simplify::triangles.size() < 3) || (Simplify::vertices.size() < 3)) {
        return InvalidMesh;
    }

    // Calculate target triangle count
    int target_count = Simplify::triangles.size() >> 1;

    if (reduceFraction > 1.0) reduceFraction = 1.0;
    if (reduceFraction <= 0.0) {
        return InvalidFraction;
    }
    target_count = round((float)Simplify::triangles.size() * reduceFraction);

    if (target_count < 4) {
        return InvalidTargetCount;
    }

    // Perform simplification
    int startSize = Simplify::triangles.size();
    Simplify::simplify_mesh(target_count, agressiveness);

    if (Simplify::triangles.size() >= startSize) {
        return LargerMesh;
    }

    // Write output to buffer based on format
    bool write_success = false;
    if (output_format == FORMAT_OBJ) {
        write_success = Simplify::write_obj(output_buffer, output_size);
    } else if (output_format == FORMAT_STL) {
        write_success = Simplify::write_stl(output_buffer, output_size);
    } else {
        return InvalidOutFormat;
    }

    if (!write_success) {
        return WriteError;
    }

    return EXIT_SUCCESS;
}

#ifdef __EMSCRIPTEN__

extern "C" {

int simplify(const uint8_t* input_buffer, size_t input_size,
                    uint8_t** output_buffer, size_t* output_size,
                    float reduceFraction, float agressiveness) {
    return simplify_raw(input_buffer, input_size, FORMAT_STL,
                        output_buffer, output_size, FORMAT_STL,
                        reduceFraction, agressiveness);
}

}

#else

// Stub main for non-WASM builds
int main(int argc, const char * argv[]) {}

#endif