diff --git a/TODO.md b/TODO.md index 21585ca..701035e 100644 --- a/TODO.md +++ b/TODO.md @@ -2,4 +2,7 @@ TODO List: - [ ] 在extrude的构造里考虑reference normal和起点切线反向的情形，并处理对应的顶点向量（反转点的下标） - [ ] 允许profile的process有非闭合的情况 - [ ] 为helixline增加手性标签，以便于控制helixline的方向 -- [ ] 将line_evaluation里的distance转为signed_distance \ No newline at end of file +- [ ] 将line_evaluation里的distance转为signed_distance + +theta改为带符号版本 +想办法保证平面曲线走向是CCW \ No newline at end of file diff --git a/application/experiment/test_complex_1.cpp b/application/experiment/test_complex_1.cpp new file mode 100644 index 0000000..0e3a13a --- /dev/null +++ b/application/experiment/test_complex_1.cpp @@ -0,0 +1,158 @@ +#include +#include +#include "data/data_type.hpp" +#include "io_blobtree.h" +#include "io_primitive.h" +#include "mimalloc.h" +#include "primitive/simple/box.hpp" +#include "primitive_descriptor.h" + +#include + +int main() +{ + mi_version(); + + helixline_axis_descriptor_t axis_desc{}; + axis_desc.axis_start = {0, 0, 0}; + axis_desc.axis_end = {0, 0, 1}; + axis_desc.is_righthanded = true; + axis_desc.radius = 1.; + axis_desc.advance_per_round = .5; + axis_desc.start_direction = {1, 0, 0}; + + polyline_pattern_descriptor_t pattern_desc{}; + pattern_desc.anchor = {0, 0}; + std::vector points{ + vector2d{-.8, 0}, + vector2d{.8, 0}, + vector2d{-.8, 0} + }; + pattern_desc.point_number = 3; + pattern_desc.points = points.data(); + std::vector bulges{1., 1.}; + pattern_desc.bulge_number = 2; + pattern_desc.bulges = bulges.data(); + + auto primitive_data_center = create_primitive_data_center(); + auto main_cylinder = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(main_cylinder, {8, 8, 30}); + auto input_cylinder1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder1, {4, 4, 52}); + primitive_apply_translation(input_cylinder1, {0, 0, 30}); + auto input_cylinder2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder2, {6, 6, 4}); + primitive_apply_translation(input_cylinder2, {0, 0, 31}); + auto input_cylinder3 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder3, {6, 6, 4}); + primitive_apply_translation(input_cylinder3, {0, 0, 37}); + auto input_cylinder4 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder4, {5, 5, 2}); + primitive_apply_translation(input_cylinder4, {0, 0, 41.5}); + auto input_cylinder5 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder5, {5, 5, 2}); + primitive_apply_translation(input_cylinder5, {0, 0, 44}); + auto input_cylinder6 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(input_cylinder6, {5, 5, 15}); + primitive_apply_translation(input_cylinder6, {0, 0, 46.5}); + auto output_cylinder1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(output_cylinder1, {5, 5, 30}); + primitive_apply_translation(output_cylinder1, {0, 0, -30}); + auto output_cylinder2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(output_cylinder2, {6, 6, 4}); + primitive_apply_translation(output_cylinder2, {0, 0, -4}); + auto output_cylinder3 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(output_cylinder3, {6, 6, 24}); + primitive_apply_translation(output_cylinder3, {0, 0, -30}); + auto output_cylinder4 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(output_cylinder4, {7, 7, 1}); + primitive_apply_translation(output_cylinder4, {0, 0, -31}); + auto output_cylinder5 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(output_cylinder5, {9, 9, 4}); + primitive_apply_translation(output_cylinder5, {0, 0, -35}); + + auto inner_cylinder = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(inner_cylinder, {3, 3, 52}); + primitive_apply_translation(inner_cylinder, {0, 0, 30}); + + auto key1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(key1, {1, 10, 5}); + primitive_apply_rotation(key1, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(key1, {0, 0, 72}); + + auto key2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(key2, {1, 13, 5}); + primitive_apply_rotation(key2, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(key2, {0, 5, 14}); + + auto hole1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_SPHERE); + primitive_apply_scale(hole1, {1.5, 1.5, 1.5}); + primitive_apply_rotation(hole1, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(hole1, {0, 5.5, 32.5}); + + auto hole2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_SPHERE); + primitive_apply_scale(hole2, {1.5, 1.5, 1.5}); + primitive_apply_rotation(hole2, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(hole2, {-5.5, 0, 32.5}); + + // auto circle_pattern = create_pattern(primitive_data_center, &pattern_desc, PATTERN_TYPE_POLYLINE); + // auto righthand_axis = create_extrude_axis(primitive_data_center, &axis_desc, AXIS_TYPE_EXTRUDE_HELIXLINE); + // auto helix1 = create_param_primitive(&righthand_axis, &circle_pattern, primitive_data_center, PRIMITIVE_TYPE_EXTRUDE); + std::cout << "primitive created..." << std::endl; + + auto runtime_blobtree = create_blobtree(); + auto node_iter1 = blobtree_add_primitive_node(runtime_blobtree, main_cylinder); + auto node_iter2 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder1); + auto node_iter3 = blobtree_add_operation_node(runtime_blobtree, node_iter1, node_iter2, UNION_OP); + auto node_iter4 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder2); + auto node_iter5 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder3); + auto node_iter6 = blobtree_add_operation_node(runtime_blobtree, node_iter3, node_iter4, UNION_OP); + auto node_iter7 = blobtree_add_operation_node(runtime_blobtree, node_iter6, node_iter5, UNION_OP); + auto node_iter8 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder4); + auto node_iter9 = blobtree_add_operation_node(runtime_blobtree, node_iter8, node_iter7, UNION_OP); + auto node_iter10 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder5); + auto node_iter11 = blobtree_add_operation_node(runtime_blobtree, node_iter9, node_iter10, UNION_OP); + auto node_iter12 = blobtree_add_primitive_node(runtime_blobtree, input_cylinder6); + auto node_iter13 = blobtree_add_operation_node(runtime_blobtree, node_iter11, node_iter12, UNION_OP); + auto node_iter14 = blobtree_add_primitive_node(runtime_blobtree, output_cylinder1); + auto node_iter15 = blobtree_add_operation_node(runtime_blobtree, node_iter13, node_iter14, UNION_OP); + auto node_iter16 = blobtree_add_primitive_node(runtime_blobtree, output_cylinder2); + auto node_iter17 = blobtree_add_operation_node(runtime_blobtree, node_iter15, node_iter16, UNION_OP); + auto node_iter18 = blobtree_add_primitive_node(runtime_blobtree, output_cylinder3); + auto node_iter19 = blobtree_add_operation_node(runtime_blobtree, node_iter17, node_iter18, UNION_OP); + auto node_iter20 = blobtree_add_primitive_node(runtime_blobtree, output_cylinder4); + auto node_iter21 = blobtree_add_operation_node(runtime_blobtree, node_iter19, node_iter20, UNION_OP); + auto node_iter22 = blobtree_add_primitive_node(runtime_blobtree, output_cylinder5); + auto node_iter23 = blobtree_add_operation_node(runtime_blobtree, node_iter21, node_iter22, UNION_OP); + auto node_iter24 = blobtree_add_primitive_node(runtime_blobtree, inner_cylinder); + auto node_iter25 = blobtree_add_operation_node(runtime_blobtree, node_iter23, node_iter24, DIFFERENCE_OP); + auto node_iter26 = blobtree_add_primitive_node(runtime_blobtree, key1); + auto node_iter27 = blobtree_add_operation_node(runtime_blobtree, node_iter25, node_iter26, DIFFERENCE_OP); + auto node_iter28 = blobtree_add_primitive_node(runtime_blobtree, key2); + auto node_iter29 = blobtree_add_operation_node(runtime_blobtree, node_iter27, node_iter28, UNION_OP); + auto node_iter30 = blobtree_add_primitive_node(runtime_blobtree, hole1); + auto node_iter31 = blobtree_add_operation_node(runtime_blobtree, node_iter29, node_iter30, DIFFERENCE_OP); + auto node_iter32 = blobtree_add_primitive_node(runtime_blobtree, hole2); + auto node_iter33 = blobtree_add_operation_node(runtime_blobtree, node_iter31, node_iter32, DIFFERENCE_OP); + auto baked_blobtree = bake_blobtree(runtime_blobtree); + destroy_blobtree(runtime_blobtree); + + std::cout << "blobtree created..." << std::endl; + + s_settings settings{}; + settings.resolution = 63; + settings.scene_aabb_margin = 1e-5; + settings.restricted_primitive_bounding_test = true; + settings.integrand_density = 32; + auto solver = create_solver(baked_blobtree, settings); + + auto result = generate_polymesh(solver); + print_statistics(solver); + + destroy_solver(solver); + destroy_baked_blobtree(baked_blobtree); + // destroy_primitive(main_sphere); + destroy_primitive_data_center(primitive_data_center); + + return 0; +} \ No newline at end of file diff --git a/application/experiment/test_complex_2.cpp b/application/experiment/test_complex_2.cpp new file mode 100644 index 0000000..a65e81f --- /dev/null +++ b/application/experiment/test_complex_2.cpp @@ -0,0 +1,222 @@ +#include +#include +#include "io_blobtree.h" +#include "io_primitive.h" +#include "math/math_defs.hpp" +#include "mimalloc.h" +#include "primitive_descriptor.h" + +#include + +#define CONCAT(a, b) a ## b +#define CONCAT_INDIRECT(a, b) CONCAT(a, b) + +#define INC_1 2 +#define INC_2 3 +#define INC_3 4 +#define INC_4 5 +#define INC_5 6 +#define INC_6 7 +#define INC_7 8 +#define INC_8 9 +#define INC_9 10 +#define INC_10 11 +#define INC_11 12 +#define INC_12 13 +#define INC_13 14 +#define INC_14 15 +#define INC_15 16 +#define INC_16 17 +#define INC_17 18 +#define INC_18 19 +#define INC_19 20 +#define INC_20 21 +#define INC_21 22 +#define INC_22 23 +#define INC_23 24 +#define INC_24 25 +#define INC_25 26 +#define INC_26 27 +#define INC_27 28 +#define INC_28 29 +#define INC_29 30 +#define INC_30 31 +#define INC_31 32 + +#define ADD2_1 3 +#define ADD2_2 4 +#define ADD2_3 5 +#define ADD2_4 6 +#define ADD2_5 7 +#define ADD2_6 8 +#define ADD2_7 9 +#define ADD2_8 10 +#define ADD2_9 11 +#define ADD2_10 12 +#define ADD2_11 13 +#define ADD2_12 14 +#define ADD2_13 15 +#define ADD2_14 16 +#define ADD2_15 17 +#define ADD2_16 18 +#define ADD2_17 19 +#define ADD2_18 20 +#define ADD2_19 21 +#define ADD2_20 22 +#define ADD2_21 23 +#define ADD2_22 24 +#define ADD2_23 25 +#define ADD2_24 26 +#define ADD2_25 27 +#define ADD2_26 28 +#define ADD2_27 29 +#define ADD2_28 30 +#define ADD2_29 31 +#define ADD2_30 32 +#define ADD2_31 33 + +#define INC(x) CONCAT_INDIRECT(INC_, x) +#define ADD2(x) CONCAT_INDIRECT(ADD2_, x) + +#define tree_add_primitive(num, prim) \ + auto CONCAT_INDIRECT(node_iter, num) = blobtree_add_primitive_node(runtime_blobtree, prim); +#define tree_add_op(num, op) \ + auto CONCAT_INDIRECT(node_iter, ADD2(num)) = blobtree_add_operation_node( \ + runtime_blobtree, CONCAT_INDIRECT(node_iter, num), CONCAT_INDIRECT(node_iter, INC(num)), op); + +int main() +{ + mi_version(); + + auto primitive_data_center = create_primitive_data_center(); + + auto c1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c1, {3, 3, 16}); + + auto c2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c2, {4, 4, 12}); + primitive_apply_translation(c2, {0, 0, 2}); + + auto c3 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c3, {4, 4, 10}); + primitive_apply_rotation(c3, {0, sqrt_2 / 2, 0, sqrt_2 / 2}); + primitive_apply_translation(c3, {-4, 0, 8}); + + auto c4 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c4, {2, 2, 6}); + primitive_apply_rotation(c4, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c4, {0, 0, 8}); + + auto c5 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c5, {3, 3, 10}); + primitive_apply_rotation(c5, {0, sqrt_2 / 2, 0, sqrt_2 / 2}); + primitive_apply_translation(c5, {-2, 0, 8}); + + auto c6 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c6, {3, 3, 2}); + primitive_apply_rotation(c6, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c6, {0, 6, 8}); + + auto c7 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_rotation(c7, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c7, {2.5, 7, 10.5}); + + auto c8 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_rotation(c8, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c8, {-2.5, 7, 5.5}); + + auto c9 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_rotation(c9, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c9, {-2.5, 7, 10.5}); + + auto c10 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_rotation(c10, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c10, {2.5, 7, 5.5}); + + auto c11 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c11, {2, 2, 1}); + primitive_apply_rotation(c11, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c11, {0, 7, 8}); + + auto c12 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c12, {1, 1, 4}); + primitive_apply_rotation(c12, {-sqrt_2 / 2, 0, 0, sqrt_2 / 2}); + primitive_apply_translation(c12, {0, 7, 8}); + + auto c13 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c13, {1, 1, 16}); + + auto c14 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c14, {2, 2, 3}); + + auto c15 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c15, {2, 2, 3}); + primitive_apply_translation(c15, {0, 0, 13}); + + auto c16 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c16, {1, 1, 8}); + primitive_apply_rotation(c16, {0, sqrt_2 / 2, 0, sqrt_2 / 2}); + primitive_apply_translation(c16, {0, 0, 8}); + + auto c17 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); + primitive_apply_scale(c17, {2, 2, 3}); + primitive_apply_rotation(c17, {0, sqrt_2 / 2, 0, sqrt_2 / 2}); + primitive_apply_translation(c17, {5, 0, 8}); + + std::cout << "primitive created..." << std::endl; + + auto runtime_blobtree = create_blobtree(); + tree_add_primitive(1, c1); + tree_add_primitive(2, c2); + tree_add_op(1, UNION_OP); + tree_add_primitive(4, c3); + tree_add_op(3, UNION_OP); + tree_add_primitive(6, c4); + tree_add_op(5, UNION_OP); + tree_add_primitive(8, c5); + tree_add_op(7, UNION_OP); + tree_add_primitive(10, c6); + tree_add_op(9, UNION_OP); + tree_add_primitive(12, c7); + tree_add_op(11, UNION_OP); + tree_add_primitive(14, c8); + tree_add_op(13, UNION_OP); + tree_add_primitive(16, c9); + tree_add_op(15, UNION_OP); + tree_add_primitive(18, c10); + tree_add_op(17, UNION_OP); + tree_add_primitive(20, c11); + tree_add_op(19, DIFFERENCE_OP); + tree_add_primitive(22, c12); + tree_add_op(21, UNION_OP); + tree_add_primitive(24, c13); + tree_add_op(23, DIFFERENCE_OP); + tree_add_primitive(26, c14); + tree_add_op(25, DIFFERENCE_OP); + tree_add_primitive(28, c15); + tree_add_op(27, DIFFERENCE_OP); + tree_add_primitive(30, c16); + tree_add_op(29, DIFFERENCE_OP); + tree_add_primitive(32, c17); + tree_add_op(31, DIFFERENCE_OP); + auto baked_blobtree = bake_blobtree(runtime_blobtree); + destroy_blobtree(runtime_blobtree); + + std::cout << "blobtree created..." << std::endl; + + s_settings settings{}; + settings.resolution = 63; + settings.scene_aabb_margin = 1e-5; + settings.restricted_primitive_bounding_test = true; + settings.integrand_density = 32; + auto solver = create_solver(baked_blobtree, settings); + + auto result = generate_polymesh(solver); + print_statistics(solver); + + destroy_solver(solver); + destroy_baked_blobtree(baked_blobtree); + destroy_primitive_data_center(primitive_data_center); + + return 0; +} \ No newline at end of file diff --git a/application/main.cpp b/application/main.cpp index ab4be20..754a7a4 100644 --- a/application/main.cpp +++ b/application/main.cpp @@ -1,29 +1,32 @@ #include #include +#include "mimalloc.h" #include int main() { + mi_version(); + auto primitive_data_center = create_primitive_data_center(); auto sphere1 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); // auto sphere2 = create_primitive(primitive_data_center, PRIMITIVE_TYPE_SPHERE); auto cylinder = create_primitive(primitive_data_center, PRIMITIVE_TYPE_CYLINDER); primitive_apply_translation(sphere1, {0.0, 0.0, 0.5}); - // primitive_apply_scale(cylinder, {1, 1, 2}); + primitive_apply_scale(cylinder, {2, 1, 1}); std::cout << "primitive created..." << std::endl; auto runtime_blobtree = create_blobtree(); auto node_iter1 = blobtree_add_primitive_node(runtime_blobtree, cylinder); - auto node_iter2 = blobtree_add_primitive_node(runtime_blobtree, sphere1); - auto node_iter3 = blobtree_add_operation_node(runtime_blobtree, node_iter1, node_iter2, INTERSECTION_OP); + // auto node_iter2 = blobtree_add_primitive_node(runtime_blobtree, sphere1); + // auto node_iter3 = blobtree_add_operation_node(runtime_blobtree, node_iter1, node_iter2, INTERSECTION_OP); auto baked_blobtree = bake_blobtree(runtime_blobtree); destroy_blobtree(runtime_blobtree); std::cout << "blobtree created..." << std::endl; s_settings settings{}; - settings.resolution = 21; + settings.resolution = 63; settings.scene_aabb_margin = 1e-5; settings.restricted_primitive_bounding_test = true; settings.integrand_density = 32; diff --git a/application/test_box.cpp b/application/test_box.cpp new file mode 100644 index 0000000..47e2580 --- /dev/null +++ b/application/test_box.cpp @@ -0,0 +1,38 @@ +#include +#include +#include "mimalloc.h" + +#include + +int main() +{ + mi_version(); + + auto primitive_data_center = create_primitive_data_center(); + auto box = create_primitive(primitive_data_center, PRIMITIVE_TYPE_BOX); + std::cout << "primitive created..." << std::endl; + + auto runtime_blobtree = create_blobtree(); + auto node_iter1 = blobtree_add_primitive_node(runtime_blobtree, box); + auto baked_blobtree = bake_blobtree(runtime_blobtree); + destroy_blobtree(runtime_blobtree); + + std::cout << "blobtree created..." << std::endl; + + s_settings settings{}; + settings.resolution = 21; + settings.scene_aabb_margin = 1e-5; + settings.restricted_primitive_bounding_test = true; + settings.integrand_density = 32; + auto solver = create_solver(baked_blobtree, settings); + + auto result = generate_polymesh(solver); + print_statistics(solver); + + destroy_solver(solver); + destroy_baked_blobtree(baked_blobtree); + destroy_primitive(box); + destroy_primitive_data_center(primitive_data_center); + + return 0; +} \ No newline at end of file diff --git a/application/test_extrude.cpp b/application/test_extrude.cpp new file mode 100644 index 0000000..e4816f3 --- /dev/null +++ b/application/test_extrude.cpp @@ -0,0 +1,85 @@ +#include +#include +#include +#include "io_primitive.h" +#include "math/math_defs.hpp" +#include "mimalloc.h" +#include "primitive_descriptor.h" + +#include + +int main() +{ + helixline_axis_descriptor_t axis_desc{}; + axis_desc.axis_start = {0, 0, 0}; + axis_desc.axis_end = {0, 0, 13}; + axis_desc.is_righthanded = true; + axis_desc.radius = 1.; + axis_desc.advance_per_round = 1; + axis_desc.start_direction = {1, 0, 0}; + + // polyline_axis_descriptor_t axis_desc{}; + // std::vector points_{ + // vector3d{0, 0, 0}, + // vector3d{0, 1, 1} + // }; + // axis_desc.point_number = 2; + // axis_desc.points = points_.data(); + // std::vector bulges_{std::tan(pi / 8)}; + // axis_desc.bulge_number = 1; + // axis_desc.bulges = bulges_.data(); + // axis_desc.reference_normal = {1, 0, 0}; + // axis_desc.is_closed = false; + + polyline_pattern_descriptor_t pattern_desc{}; + pattern_desc.anchor = {0, 0}; + std::vector points{ + vector2d{-.1, 0}, + vector2d{.1, 0}, + vector2d{-.1, 0} + }; + pattern_desc.point_number = 3; + pattern_desc.points = points.data(); + std::vector bulges{1., 1.}; + pattern_desc.bulge_number = 2; + pattern_desc.bulges = bulges.data(); + + auto primitive_data_center = create_primitive_data_center(); + auto pattern = create_pattern(primitive_data_center, &pattern_desc, PATTERN_TYPE_POLYLINE); + auto axis = create_extrude_axis(primitive_data_center, &axis_desc, AXIS_TYPE_EXTRUDE_HELIXLINE); + auto extrude = create_param_primitive(&axis, &pattern, primitive_data_center, PRIMITIVE_TYPE_EXTRUDE); + std::cout << "primitive created..." << std::endl; + + auto runtime_blobtree = create_blobtree(); + auto node_iter1 = blobtree_add_primitive_node(runtime_blobtree, extrude); + auto baked_blobtree = bake_blobtree(runtime_blobtree); + destroy_blobtree(runtime_blobtree); + + std::cout << "blobtree created..." << std::endl; + + s_settings settings{}; + settings.resolution = 32; + settings.scene_aabb_margin = 1e-5; + settings.restricted_primitive_bounding_test = true; + settings.integrand_density = 32; + auto solver = create_solver(baked_blobtree, settings); + + auto result = generate_polymesh(solver); + // auto integrator = generate_integral_scheme(solver); + print_statistics(solver); + + // integrand_handle_t handle{1., 0, 0, 0}; + // std::cout << "surface area: " << calculate_surface_integrand(integrator, handle) << std::endl; + // std::cout << "volume: " << calculate_volume_integrand(integrator, handle) << std::endl; + // std::cout << "baseline (by polymesh): \n"; + // auto baseline_integral = polymesh_area_and_volume(solver); + // std::cout << "surface area: " << baseline_integral.area << std::endl; + // std::cout << "volume: " << baseline_integral.volume << std::endl; + + destroy_solver(solver); + destroy_baked_blobtree(baked_blobtree); + destroy_primitive(extrude); + destroy_primitive_data_center(primitive_data_center); + + return 0; +} \ No newline at end of file diff --git a/application/test_mimalloc.cpp b/application/test_mimalloc.cpp new file mode 100644 index 0000000..1d3485d --- /dev/null +++ b/application/test_mimalloc.cpp @@ -0,0 +1,18 @@ +#include +#include +#include + +int main() { + // 使用标准的C接口分配内存 + void* p = malloc(128); + + // 检查这块内存是否属于mimalloc管理 + if (mi_heap_of(p) != NULL) { + printf("✅ 重定向成功！标准malloc已经被mimalloc接管\n"); + } else { + printf("❌ 重定向失败，内存仍由系统分配器管理\n"); + } + + free(p); + return 0; +} \ No newline at end of file diff --git a/application/xmake.lua b/application/xmake.lua index 9aae8ad..77e7f14 100644 --- a/application/xmake.lua +++ b/application/xmake.lua @@ -10,4 +10,36 @@ target("test_frontend") set_kind("binary") add_deps("frontend") add_files("main.cpp") +target_end() + +target("test_extrude") + set_kind("binary") + add_deps("frontend") + add_files("test_extrude.cpp") +target_end() + +target("test_mimalloc") + set_kind("binary") + add_deps("frontend") + add_files("test_mimalloc.cpp") +target_end() + +target("test_complex_1") + set_kind("binary") + set_group("experiment/complex_scene") + add_deps("frontend") + add_files("experiment/test_complex_1.cpp") +target_end() + +target("test_complex_2") + set_kind("binary") + set_group("experiment/complex_scene") + add_deps("frontend") + add_files("experiment/test_complex_2.cpp") +target_end() + +target("test_box") + set_kind("binary") + add_deps("frontend") + add_files("test_box.cpp") target_end() \ No newline at end of file diff --git a/network_process/src/network_process.cpp b/network_process/src/network_process.cpp index 3228702..fcae5ce 100644 --- a/network_process/src/network_process.cpp +++ b/network_process/src/network_process.cpp @@ -315,15 +315,15 @@ ISNP_API void build_implicit_network_by_blobtree(const s_settings& s export_active_patch_obj(iso_pts, iso_faces, patches, active_patch_label, "halfpatch_final"); #endif - // chain postprocessing - output_icurve_relation_graph.nodes<0>().resize(tree.subfaces.size()); - filter_chains(iso_faces, - patches, - patch_chain_triangles, - active_patch_label, - vertex_old_index_to_unique_index, - chains, - output_icurve_relation_graph); + // // chain postprocessing + // output_icurve_relation_graph.nodes<0>().resize(tree.subfaces.size()); + // filter_chains(iso_faces, + // patches, + // patch_chain_triangles, + // active_patch_label, + // vertex_old_index_to_unique_index, + // chains, + // output_icurve_relation_graph); } } } diff --git a/shared_module/math/math_defs.hpp b/shared_module/math/math_defs.hpp index f839b0f..d6b77ff 100644 --- a/shared_module/math/math_defs.hpp +++ b/shared_module/math/math_defs.hpp @@ -9,6 +9,7 @@ static constexpr auto two_pi = pi * 2; static constexpr auto pi_div_2 = pi / 2; static constexpr auto inv_pi = 1. / pi; static constexpr auto inv_two_pi = 1. / two_pi; +static constexpr auto two_div_pi = 2 / pi; static constexpr auto sqrt_2 = 1.4142135623730951; static constexpr auto sqrt_3 = 1.7320508075688772; static constexpr auto infinity = std::numeric_limits::infinity(); @@ -55,4 +56,22 @@ inline auto corrected_atan2(double y, double x) { auto v = atan2(y, x); return v < 0 ? v + two_pi : v; +} + +inline auto accurate_sin_cos(double x, bool is_cosine) noexcept +{ + if (x == 0) return is_cosine ? 1. : 0.; + + int q; + const auto r = std::remquo(x, pi_div_2, &q); + q = (q + (is_cosine ? 1 : 0)) & 3; + + switch (q) { + case 0: return std::copysign(std::sin(r), x); + case 1: return std::copysign(std::cos(r), x); + case 2: return std::copysign(-std::sin(r), x); + case 3: return std::copysign(-std::cos(r), x); + } + + return .0; } \ No newline at end of file diff --git a/shared_module/utils/marked_ptr.hpp b/shared_module/utils/marked_ptr.hpp index c91452f..480b974 100644 --- a/shared_module/utils/marked_ptr.hpp +++ b/shared_module/utils/marked_ptr.hpp @@ -12,7 +12,7 @@ struct marked_ptr { marked_ptr(T* ptr, size_t mark) : ptr((T*)((size_t)ptr | (mark & mask))) {} - T* get_ptr() const { return (T*)((size_t)ptr & ~1); } + T* get_ptr() const { return (T*)((size_t)ptr & ~mask); } size_t get_mark() const { return (size_t)ptr & mask; } diff --git a/shared_module/xmake.lua b/shared_module/xmake.lua index 1e2f3fa..4a02a0d 100644 --- a/shared_module/xmake.lua +++ b/shared_module/xmake.lua @@ -1,4 +1,4 @@ --- add_requires("mimalloc", {configs = {shared = false}}) +add_requires("mimalloc-adjust", {configs = {shared = true, override = true}}) add_requires("parallel-hashmap") add_requires("range-v3") add_requires("eigen") @@ -6,10 +6,10 @@ add_requires("eigen") add_requires("xxhash") target("shared_module") - set_kind("static") + set_kind("headeronly") add_includedirs("./", {public = true}) - add_files("*.cpp") - add_packages("parallel-hashmap", "range-v3", "eigen", "xxhash", {public = true}) + -- add_files("*.cpp") + add_packages("mimalloc-adjust", "parallel-hashmap", "range-v3", "eigen", "xxhash", {public = true}) -- add_rules("library.headeronly.distribute.header", {projectdir = os.scriptdir()}) add_rules("library.force.distribute.header", {headers = path.join(os.scriptdir(), "include", "**", "*.h")}) target_end() \ No newline at end of file diff --git a/xmake/packages/m/mimalloc-adjust/xmake.lua b/xmake/packages/m/mimalloc-adjust/xmake.lua index 92abd48..2e4088b 100644 --- a/xmake/packages/m/mimalloc-adjust/xmake.lua +++ b/xmake/packages/m/mimalloc-adjust/xmake.lua @@ -6,6 +6,11 @@ package("mimalloc-adjust") set_urls("https://github.com/microsoft/mimalloc/archive/refs/tags/$(version).zip", "https://github.com/microsoft/mimalloc.git") + add_versions("v3.2.8", "63302742e911c8724c2bcc192aea51fc8921c7916ca8a68b037280d72126dfb5") + add_versions("v3.1.5", "3cf724ec469198f23505d157893331f9d062e982c38b2c92a7fb789d7ddb67d9") + add_versions("v3.0.3", "08a917e331164cd77052377f1e6d86de7febc8663dc117648319e662c0d4e6a4") + + add_versions("v2.2.4", "664667a48c9f101d979bbe4e41ee631da49d2024e30d66b7779b6ba4279af367") add_versions("v2.1.7", "fa61cf01e3dd869b35275bfd8be95bfde77f0b65dfa7e34012c09a66e1ea463f") add_versions("v2.1.2", "86281c918921c1007945a8a31e5ad6ae9af77e510abfec20d000dd05d15123c7") add_versions("v2.0.7", "ddb32937aabddedd0d3a57bf68158d4e53ecf9e051618df3331a67182b8b0508") @@ -24,47 +29,93 @@ package("mimalloc-adjust") add_versions("v1.7.0", "13f3c82bca3a95233c5e29adb5675ab2b772f0ade23184d822079578c9d6c698") add_versions("v1.6.7", "5a12aac020650876615a2ce3dd8adc8b208cdcee4d9e6bcfc33b3fbe307f0dbf") + add_configs("secure", {description = "Use a secured version of mimalloc", default = false, type = "boolean"}) + add_configs("rltgenrandom", {description = "Use a RtlGenRandom instead of BCrypt", default = false, type = "boolean"}) + add_configs("override", {description = "Enable global C interface override for dynamic library", default = false, type = "boolean"}) + if is_plat("windows") then + add_configs("etw", {description = "Enable Event tracing for Windows", default = false, type = "boolean"}) + end + + add_deps("cmake") + + if is_plat("windows") then + add_syslinks("advapi32", "bcrypt") + elseif is_plat("linux") then + add_syslinks("pthread") + elseif is_plat("android") then + add_syslinks("atomic") + end + on_install(function (package) - package:add("defines", "MI_SHARED_LIB") - - io.writefile("xmake.lua", [[ - target("mimalloc") - set_kind("shared") - set_optimize("fastest") - add_files("src/static.c") - add_includedirs("include") - if is_plat("windows") then - add_syslinks("psapi", "shell32", "user32", "advapi32", "bcrypt") - add_defines("_CRT_SECURE_NO_WARNINGS") - elseif is_plat("linux") then - add_syslinks("pthread") - elseif is_plat("android") then - add_syslinks("atomic") - end - add_defines("MI_SHARED_LIB") - add_defines("MI_SHARED_LIB_EXPORT", "MI_XMALLOC=1") - add_defines("MI_MALLOC_OVERRIDE=1") - ]]) - import("package.tools.xmake").install(package) - - if package:is_plat("windows") then - os.trycp("build/**.dll", package:installdir("bin")) - os.trycp("build/**.lib", package:installdir("lib")) - elseif package:is_plat("mingw") then - os.trycp("build/**.dll", package:installdir("bin")) - os.trycp("build/**.a", package:installdir("lib")) - elseif package:is_plat("macosx") then - os.trycp("build/*.dylib", package:installdir("bin")) - os.trycp("build/*.dylib", package:installdir("lib")) - os.trycp("build/*.a", package:installdir("lib")) + if package:is_plat("windows") and package:config("shared") then + package:add("defines", "MI_SHARED_LIB") + end + + if package:is_plat("wasm") then + package:add("ldflags", "-sMALLOC=emmalloc") + end + + local configs = { + "-DMI_BUILD_TESTS=OFF", + "-DMI_BUILD_OBJECT=OFF", + } + -- Enable global C interface override only when shared library and override option are both enabled + table.insert(configs, "-DMI_OVERRIDE=" .. (package:config("override") and package:config("shared") and "ON" or "OFF")) + + table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:is_debug() and "Debug" or "Release")) + table.insert(configs, "-DMI_DEBUG_FULL=" .. (package:is_debug() and "ON" or "OFF")) + table.insert(configs, "-DMI_BUILD_STATIC=" .. (package:config("shared") and "OFF" or "ON")) + table.insert(configs, "-DMI_BUILD_SHARED=" .. (package:config("shared") and "ON" or "OFF")) + table.insert(configs, "-DMI_SECURE=" .. (package:config("secure") and "ON" or "OFF")) + table.insert(configs, "-DMI_TRACK_ETW=" .. (package:config("etw") and "ON" or "OFF")) + + -- --x64:mimalloc-redirect.lib/dll x86:mimalloc-redirect32.lib/dll + -- if package:version():le("2.0.1") and package:config("shared") and package:is_plat("windows") and package:is_arch("x86") then + -- io.replace("CMakeLists.txt", "-redirect.", "-redirect32.", {plain = true}) + -- end + -- if package:version():ge("2.2.4") and package:config("shared") and package:is_plat("windows", "mingw") and not package:is_arch64() then + -- io.replace("CMakeLists.txt", "-redirect${MIMALLOC_REDIRECT_SUFFIX}", "-redirect32", {plain = true}) + -- end + local cxflags + if package:config("rltgenrandom") then + if xmake:version():ge("2.5.1") then + cxflags = "-DMI_USE_RTLGENRANDOM" + else + -- it will be deprecated after xmake/v2.5.1 + package:configs().cxflags = "-DMI_USE_RTLGENRANDOM" + end + end + + if package:gitref() or package:version():ge("2.1.2") then + table.insert(configs, "-DMI_INSTALL_TOPLEVEL=ON") + import("package.tools.cmake").install(package, configs, {cxflags = cxflags}) + + if package:is_plat("windows") and package:is_debug() then + local dir = package:installdir(package:config("shared") and "bin" or "lib") + os.cp(path.join(package:builddir(), "mimalloc-debug.pdb"), dir) + end else - os.trycp("build/*.so", package:installdir("bin")) - os.trycp("build/*.so", package:installdir("lib")) - os.trycp("build/*.a", package:installdir("lib")) + import("package.tools.cmake").build(package, configs, {builddir = "build", cxflags = cxflags}) + + if package:is_plat("windows") then + os.trycp("build/**.dll", package:installdir("bin")) + os.trycp("build/**.lib", package:installdir("lib")) + elseif package:is_plat("mingw") then + os.trycp("build/**.dll", package:installdir("bin")) + os.trycp("build/**.a", package:installdir("lib")) + elseif package:is_plat("macosx") then + os.trycp("build/*.dylib", package:installdir("bin")) + os.trycp("build/*.dylib", package:installdir("lib")) + os.trycp("build/*.a", package:installdir("lib")) + else + os.trycp("build/*.so", package:installdir("bin")) + os.trycp("build/*.so", package:installdir("lib")) + os.trycp("build/*.a", package:installdir("lib")) + end + os.cp("include", package:installdir()) end - os.cp("include", package:installdir()) end) on_test(function (package) assert(package:has_cfuncs("mi_malloc", {includes = "mimalloc.h"})) - end) \ No newline at end of file + end)