// 官方 ASCII OFF 格式插件(VDE 微内核 P4-21;纯 C ABI,不链接内核)。 // // 读:OFF / COFF(Object File Format)。 // - 首 token OFF 或 COFF(大小写不敏感),counts 行可与首 token 同行; // - counts = 顶点数 面数 [边数],边数读取后忽略; // - '#' 注释与空行可出现在任意位置; // - 顶点行读取 x y z,行尾附加字段(如 COFF 颜色)忽略; // - 面行格式为 k i0 i1 ... i(k-1),k >= 3,索引 0-based、 // 必须小于顶点数;按扇形 (i0, i(j-1), ij) 三角化; // - 显式错误:空文件/坏头/counts 非法/截断/索引越界/超出上限/多余数据。 // 写:所有实体经宿主 body_tessellate 摊平成三角面后合并为一个 ASCII OFF // (顶点数为各实体三角化结果之和,面数为三角面数,边数固定 0)。 // 所有几何能力经宿主服务表获得,插件不链接内核。 #include #include #include #include #include #include #include #include "../common/format_plugin_common.h" namespace { using vde_plugin_common::MeshAccumulator; using vde_plugin_common::fail; using vde_plugin_common::is_space_char; using vde_plugin_common::lower_copy; using vde_plugin_common::read_file_bytes; using vde_plugin_common::validate_common_host; using vde_plugin_common::validate_read_host; using vde_plugin_common::validate_write_host; using vde_plugin_common::write_file_bytes; constexpr std::uint64_t kMaxVertices = 20000000ull; constexpr std::uint64_t kMaxFaces = 20000000ull; constexpr std::uint64_t kMaxFaceVertices = 1000000ull; constexpr std::size_t kMaxTriangles = 50000000u; std::vector split_ws(const std::string& line) { std::vector tokens; std::size_t i = 0; while (i < line.size()) { while (i < line.size() && is_space_char(line[i])) ++i; if (i >= line.size()) break; const std::size_t begin = i; while (i < line.size() && !is_space_char(line[i])) ++i; tokens.push_back(line.substr(begin, i - begin)); } return tokens; } bool parse_uint_token(const std::string& token, std::uint64_t* out) { if (token.empty() || !out) return false; std::uint64_t value = 0; for (char c : token) { if (c < '0' || c > '9') return false; const std::uint64_t digit = static_cast(c - '0'); if (value > (UINT64_MAX - digit) / 10ull) return false; value = value * 10ull + digit; } *out = value; return true; } bool parse_real_token(const std::string& token, double* out) { if (token.empty() || !out) return false; char* parse_end = nullptr; const double value = std::strtod(token.c_str(), &parse_end); if (parse_end != token.c_str() + token.size()) return false; if (!std::isfinite(value)) return false; *out = value; return true; } /// 逐行读取内容行:跳过空行、跳过 '#' 起始或行内注释、去掉行尾 CR。 struct LineReader { const char* cursor = nullptr; const char* end = nullptr; bool next_content_line(std::string* line) { if (!cursor || !end || !line) return false; while (cursor < end) { const char* line_end = cursor; while (line_end < end && *line_end != '\n') ++line_end; line->assign(cursor, static_cast(line_end - cursor)); cursor = (line_end < end) ? line_end + 1 : end; if (!line->empty() && line->back() == '\r') line->pop_back(); const std::size_t comment = line->find('#'); if (comment != std::string::npos) line->resize(comment); std::size_t begin = 0; while (begin < line->size() && is_space_char((*line)[begin])) ++begin; std::size_t finish = line->size(); while (finish > begin && is_space_char((*line)[finish - 1])) --finish; if (finish > begin) { *line = line->substr(begin, finish - begin); return true; } } return false; } }; bool parse_off(const char* data, std::size_t size, MeshAccumulator* mesh, std::string* error) { if (!data || size == 0) { if (error) *error = "off: 空文件"; return false; } // 容忍 UTF-8 BOM(部分文本编辑器会写入)。 if (size >= 3 && static_cast(data[0]) == 0xEF && static_cast(data[1]) == 0xBB && static_cast(data[2]) == 0xBF) { data += 3; size -= 3; } LineReader reader{data, data + size}; std::string line; if (!reader.next_content_line(&line)) { if (error) *error = "off: 空文件"; return false; } std::vector tokens = split_ws(line); if (tokens.empty()) { if (error) *error = "off: 空文件"; return false; } const std::string magic = lower_copy(tokens[0]); if (magic != "off" && magic != "coff") { if (error) *error = "off: 文件头不是 OFF/COFF"; return false; } std::vector count_tokens(tokens.begin() + 1, tokens.end()); if (count_tokens.empty()) { if (!reader.next_content_line(&line)) { if (error) *error = "off: 缺少 counts 行"; return false; } count_tokens = split_ws(line); } if (count_tokens.size() < 2 || count_tokens.size() > 3) { if (error) *error = "off: counts 行必须包含 2 或 3 个非负整数"; return false; } std::uint64_t vertex_count = 0; std::uint64_t face_count = 0; if (!parse_uint_token(count_tokens[0], &vertex_count) || !parse_uint_token(count_tokens[1], &face_count)) { if (error) *error = "off: counts 行包含非法整数"; return false; } if (count_tokens.size() == 3) { std::uint64_t edge_count = 0; if (!parse_uint_token(count_tokens[2], &edge_count)) { if (error) *error = "off: counts 行包含非法整数"; return false; } (void)edge_count; // OFF 的边数不参与网格构建 } if (vertex_count > kMaxVertices) { if (error) *error = "off: 顶点数量超过上限"; return false; } if (face_count > kMaxFaces) { if (error) *error = "off: 面数量超过上限"; return false; } for (std::uint64_t i = 0; i < vertex_count; ++i) { if (!reader.next_content_line(&line)) { if (error) *error = "off: 顶点数据被截断"; return false; } const std::vector fields = split_ws(line); if (fields.size() < 3) { if (error) *error = "off: 顶点行数据不足(需要 x y z)"; return false; } double xyz[3] = {0.0, 0.0, 0.0}; for (int axis = 0; axis < 3; ++axis) { if (!parse_real_token(fields[static_cast(axis)], &xyz[axis])) { if (error) *error = "off: 顶点坐标非法"; return false; } } mesh->add_vertex(xyz[0], xyz[1], xyz[2]); } std::vector face_indices; for (std::uint64_t f = 0; f < face_count; ++f) { if (!reader.next_content_line(&line)) { if (error) *error = "off: 面数据被截断"; return false; } const std::vector fields = split_ws(line); if (fields.empty()) { if (error) *error = "off: 面行为空"; return false; } std::uint64_t k = 0; if (!parse_uint_token(fields[0], &k)) { if (error) *error = "off: 面顶点数非法"; return false; } if (k < 3) { if (error) *error = "off: 面顶点数小于 3"; return false; } if (k > kMaxFaceVertices) { if (error) *error = "off: 单面顶点数超过上限"; return false; } if (k > static_cast(fields.size() - 1)) { if (error) *error = "off: 面索引被截断"; return false; } if (k > vertex_count) { if (error) *error = "off: 面顶点数超过顶点总数"; return false; } face_indices.clear(); face_indices.reserve(static_cast(k)); for (std::uint64_t j = 0; j < k; ++j) { std::uint64_t index = 0; if (!parse_uint_token(fields[static_cast(1 + j)], &index)) { if (error) *error = "off: 面索引非法"; return false; } if (index >= vertex_count) { if (error) *error = "off: 面索引越界"; return false; } face_indices.push_back(static_cast(index)); } for (std::size_t i = 2; i < face_indices.size(); ++i) { // 重复索引形成的退化三角面直接跳过(与内核网格导入口径一致)。 mesh->add_triangle(face_indices[0], face_indices[i - 1], face_indices[i]); if (mesh->triangle_count() > kMaxTriangles) { if (error) *error = "off: 三角面数量超过上限"; return false; } } } if (reader.next_content_line(&line)) { if (error) *error = "off: 面数据后存在多余内容"; return false; } return true; } // ───────────────────────────────────────────────────────── // 写出 // ───────────────────────────────────────────────────────── bool collect_write_mesh(const VdePluginHost* host, const VdeBody* bodies, std::size_t count, MeshAccumulator* out, std::string* error) { if (!host || !out) return false; if (!bodies || count == 0) { if (error) *error = "off: 没有实体可写出"; return false; } for (std::size_t body_index = 0; body_index < count; ++body_index) { if (!bodies[body_index]) { if (error) *error = "off: 实体句柄为空"; return false; } VdeMeshData mesh{}; mesh.struct_size = static_cast(sizeof(VdeMeshData)); const int rc = host->body_tessellate(bodies[body_index], 0.01, &mesh); const auto release = [&]() { if (!host->free_buffer) return; host->free_buffer(mesh.positions); host->free_buffer(mesh.indices); host->free_buffer(mesh.normals); mesh.positions = nullptr; mesh.indices = nullptr; mesh.normals = nullptr; }; if (rc != VDE_PLUGIN_OK) { release(); if (error) *error = "off: 实体三角化失败"; return false; } if (!mesh.positions || !mesh.indices || mesh.num_triangles == 0) { release(); continue; // 空实体不贡献顶点/面 } if (mesh.num_vertices == 0) { release(); if (error) *error = "off: 三角化结果顶点为空"; return false; } const std::uint64_t vertex_total = static_cast(out->vertex_count()) + mesh.num_vertices; if (vertex_total > 0xFFFFFFFFull) { release(); if (error) *error = "off: 合并后顶点数量超过 uint32 范围"; return false; } const std::uint32_t offset = static_cast(out->vertex_count()); out->positions.reserve(out->positions.size() + mesh.num_vertices * 3u); for (std::size_t i = 0; i < mesh.num_vertices * 3u; ++i) out->positions.push_back(mesh.positions[i]); for (std::size_t t = 0; t < mesh.num_triangles; ++t) { const std::uint32_t a = mesh.indices[3u * t + 0u]; const std::uint32_t b = mesh.indices[3u * t + 1u]; const std::uint32_t c = mesh.indices[3u * t + 2u]; if (static_cast(a) >= mesh.num_vertices || static_cast(b) >= mesh.num_vertices || static_cast(c) >= mesh.num_vertices) { release(); if (error) *error = "off: 三角化索引越界"; return false; } out->add_triangle(offset + a, offset + b, offset + c); if (out->triangle_count() > kMaxTriangles) { release(); if (error) *error = "off: 三角面数量超过上限"; return false; } } release(); } if (out->empty()) { if (error) *error = "off: 实体三角化后没有三角面"; return false; } return true; } void append_number(std::string* out, double value) { char buffer[64]; const int written = std::snprintf(buffer, sizeof(buffer), "%.17g", value); if (written > 0) out->append(buffer, static_cast(written)); } std::string serialize_off(const MeshAccumulator& mesh) { std::string out; out.reserve(mesh.vertex_count() * 56u + mesh.triangle_count() * 28u + 64u); out += "OFF\n"; out += std::to_string(mesh.vertex_count()); out += ' '; out += std::to_string(mesh.triangle_count()); out += " 0\n"; for (std::size_t i = 0; i < mesh.vertex_count(); ++i) { append_number(&out, mesh.positions[3u * i + 0u]); out += ' '; append_number(&out, mesh.positions[3u * i + 1u]); out += ' '; append_number(&out, mesh.positions[3u * i + 2u]); out += '\n'; } for (std::size_t t = 0; t < mesh.triangle_count(); ++t) { out += "3 "; out += std::to_string(mesh.indices[3u * t + 0u]); out += ' '; out += std::to_string(mesh.indices[3u * t + 1u]); out += ' '; out += std::to_string(mesh.indices[3u * t + 2u]); out += '\n'; } return out; } // ───────────────────────────────────────────────────────── // 入口 // ───────────────────────────────────────────────────────── int off_read_memory_impl(const VdePluginHost* host, const void* data, std::size_t size, VdeBody** bodies, std::size_t* count) { if (bodies) *bodies = nullptr; if (count) *count = 0; if (!bodies || !count) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: 输出指针为空"); const int host_rc = validate_read_host(host); if (host_rc != VDE_PLUGIN_OK) return host_rc; if (!data || size == 0) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: 内存数据为空"); try { MeshAccumulator mesh; std::string error; if (!parse_off(static_cast(data), size, &mesh, &error)) return fail(host, VDE_PLUGIN_ERR_PARSE, error.c_str()); return vde_plugin_common::publish_single_body(host, mesh, bodies, count, "off"); } catch (const std::bad_alloc&) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 解析内存不足"); } catch (...) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 解析发生未知异常"); } } int off_read_file(const VdePluginHost* host, const char* path, VdeBody** bodies, std::size_t* count) { if (bodies) *bodies = nullptr; if (count) *count = 0; if (!bodies || !count) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: 输出指针为空"); const int host_rc = validate_read_host(host); if (host_rc != VDE_PLUGIN_OK) return host_rc; if (!path || !*path) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: 输入路径为空"); std::string bytes; if (!read_file_bytes(path, &bytes)) return fail(host, VDE_PLUGIN_ERR_IO, "off: 无法读取输入文件"); return off_read_memory_impl(host, bytes.data(), bytes.size(), bodies, count); } int off_read_memory(const VdePluginHost* host, const void* data, std::size_t size, VdeBody** bodies, std::size_t* count) { return off_read_memory_impl(host, data, size, bodies, count); } int off_write_file(const VdePluginHost* host, const char* path, const VdeBody* bodies, std::size_t count) { if (!path || !*path) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: 输出路径为空"); const int host_rc = validate_write_host(host); if (host_rc != VDE_PLUGIN_OK) return host_rc; try { MeshAccumulator mesh; std::string error; if (!collect_write_mesh(host, bodies, count, &mesh, &error)) return fail(host, VDE_PLUGIN_ERR_INTERNAL, error.c_str()); const std::string bytes = serialize_off(mesh); if (!write_file_bytes(path, bytes.data(), bytes.size())) return fail(host, VDE_PLUGIN_ERR_IO, "off: 写出文件失败"); return VDE_PLUGIN_OK; } catch (const std::bad_alloc&) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 写出内存不足"); } catch (...) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 写出发生未知异常"); } } int off_write_memory(const VdePluginHost* host, const VdeBody* bodies, std::size_t count, VdeBuffer* out) { if (out) { out->data = nullptr; out->size = 0; } if (!out) return fail(host, VDE_PLUGIN_ERR_INVALID_ARG, "off: out 为空"); const int host_rc = validate_write_host(host); if (host_rc != VDE_PLUGIN_OK) return host_rc; try { MeshAccumulator mesh; std::string error; if (!collect_write_mesh(host, bodies, count, &mesh, &error)) return fail(host, VDE_PLUGIN_ERR_INTERNAL, error.c_str()); const std::string bytes = serialize_off(mesh); void* buffer = host->alloc(bytes.size()); if (!buffer) return fail(host, VDE_PLUGIN_ERR_BUFFER, "off: 输出缓冲分配失败"); std::memcpy(buffer, bytes.data(), bytes.size()); out->data = buffer; out->size = bytes.size(); return VDE_PLUGIN_OK; } catch (const std::bad_alloc&) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 写出内存不足"); } catch (...) { return fail(host, VDE_PLUGIN_ERR_INTERNAL, "off: 写出发生未知异常"); } } int off_probe(const void* head, std::size_t head_size) { if (!head || head_size == 0) return 0; const char* p = static_cast(head); const char* end = p + head_size; if (head_size >= 3 && static_cast(p[0]) == 0xEF && static_cast(p[1]) == 0xBB && static_cast(p[2]) == 0xBF) { p += 3; } while (p < end) { const char* line_end = p; while (line_end < end && *line_end != '\n') ++line_end; const char* q = p; while (q < line_end && is_space_char(*q)) ++q; if (q < line_end && *q != '#') { const char* token_end = q; while (token_end < line_end && !is_space_char(*token_end)) ++token_end; const std::string token = lower_copy(std::string(q, token_end)); return (token == "off" || token == "coff") ? 100 : 0; } p = (line_end < end) ? line_end + 1 : end; } return 0; } const char* off_describe() { return "VDE official ASCII OFF format (OFF/COFF read; ASCII OFF write)"; } const VdeFormatPlugin kFormat = [] { VdeFormatPlugin format{}; format.struct_size = static_cast(sizeof(VdeFormatPlugin)); format.format_id = "off"; format.extensions = ".off"; format.probe = &off_probe; format.read_file = &off_read_file; format.read_memory = &off_read_memory; format.write_file = &off_write_file; format.write_memory = &off_write_memory; format.describe = &off_describe; return format; }(); } // namespace extern "C" { VDE_PLUGIN_EXPORT int vde_plugin_query(std::uint32_t host_abi_major, VdePluginInfo* info) { if (!info || info->struct_size < sizeof(VdePluginInfo)) return VDE_PLUGIN_ERR_ABI; if (host_abi_major != VDE_PLUGIN_ABI_MAJOR) return VDE_PLUGIN_ERR_ABI; info->id = "com.vde.official.off"; info->name = "VDE Official ASCII OFF Format"; info->version = "1.0.0"; info->kind = VDE_PLUGIN_KIND_FORMAT; info->abi_major = VDE_PLUGIN_ABI_MAJOR; info->abi_minor = VDE_PLUGIN_ABI_MINOR; info->capabilities = "format:off.read;format:off.write"; info->license = "Apache-2.0"; return VDE_PLUGIN_OK; } VDE_PLUGIN_EXPORT int vde_plugin_init(const VdePluginHost* host, VdePluginRegistration* reg) { if (!reg || reg->struct_size < sizeof(VdePluginRegistration)) return VDE_PLUGIN_ERR_ABI; const int host_rc = validate_common_host(host); if (host_rc != VDE_PLUGIN_OK) return host_rc; reg->kind = VDE_PLUGIN_KIND_FORMAT; reg->format = &kFormat; reg->generic = nullptr; reg->cae_solver = nullptr; reg->cam_strategy = nullptr; reg->gcs_solver = nullptr; reg->mesher = nullptr; reg->optimizer = nullptr; reg->io_batch = nullptr; return VDE_PLUGIN_OK; } VDE_PLUGIN_EXPORT void vde_plugin_shutdown() {} } // extern "C"