【开发日志】2023.06 ZENO----ReadGLTF、GLB

已于 2023-07-04 18:15:11 修改
阅读量282 收藏
点赞数 1
分类专栏： 开发日志 ZENO 文章标签： c++
于 2023-06-29 18:00:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Angelloveyatou/article/details/131461658
版权

 google/draco: Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics. (github.com)https://github.com/google/draco

#include <zeno/zeno.h>
#include <zeno/utils/logger.h>
#include <zeno/utils/fileio.h>
#include <zeno/types/PrimitiveObject.h>
#include <zeno/types/PrimitiveTools.h>
#include <zeno/types/NumericObject.h>
#include <zeno/types/UserData.h>
#include <zeno/extra/GlobalState.h>
#include <zeno/utils/string.h>
#include "rapidjson/document.h"

namespace zeno {

namespace zeno_gltf {

enum class ComponentType {
    GL_BYTE = 0x1400,
    GL_UNSIGNED_BYTE = 0x1401,
    GL_SHORT = 0x1402,
    GL_UNSIGNED_SHORT = 0x1403,
    GL_INT = 0x1404,
    GL_UNSIGNED_INT = 0x1405,
    GL_FLOAT = 0x1406,
    GL_DOUBLE = 0x140A,
};
enum class Type {
    SCALAR,
    VEC2,
    VEC3,
    VEC4,
};
struct Accessor {
    int bufferView;
    int count;
    ComponentType componentType;
    Type type;
};
struct BufferView {
    int buffer;
    int byteOffset;
    int byteLength;
    int byteStride;
};

struct GLBHeader {
    uint32_t magic;
    uint32_t version;
    uint32_t length;
};

struct ReadGLTF : zeno::INode {
    virtual void apply() override {
        auto path = get_input2<std::string>("path");
        std::vector<std::vector<char>> buffers;
        rapidjson::Document root;

        if (zeno::ends_with(path, ".glb", false)) {
            std::ifstream file(path.c_str(), std::ios::binary);
            // Read 12-byte header
            GLBHeader header;
            file.read(reinterpret_cast<char *>(&header), sizeof(GLBHeader));
            if (header.magic != 0x46546C67) {
                return;
            }
            // Read JSON chunk
            uint32_t jsonChunkLength;
            file.read(reinterpret_cast<char *>(&jsonChunkLength), sizeof(uint32_t));
            uint32_t jsonChunkType;
            file.read(reinterpret_cast<char *>(&jsonChunkType), sizeof(uint32_t));

            std::vector<char> jsonBuffer(jsonChunkLength);
            file.read(jsonBuffer.data(), jsonChunkLength);

            // Parse JSON
            std::string json(jsonBuffer.begin(), jsonBuffer.end());
            root.Parse(json.c_str());
            //        std::ofstream outputFile("d:\\1.json");
            //        outputFile << json;

            // Read binary chunk
            uint32_t binaryChunkLength;
            file.read(reinterpret_cast<char *>(&binaryChunkLength), sizeof(uint32_t));
            uint32_t binaryChunkType;
            file.read(reinterpret_cast<char *>(&binaryChunkType), sizeof(uint32_t));

            std::vector<char> binaryBuffer(binaryChunkLength);
            file.read(binaryBuffer.data(), binaryChunkLength);

            // Parse Bin
            buffers.push_back(binaryBuffer);
        }
        else {
            auto json = zeno::file_get_content(path);
            root.Parse(json.c_str());

            zeno::log_info("buffers {}", root["buffers"].Size());
            for (auto i = 0; i < root["buffers"].Size(); i++) {
                std::filesystem::path p = path;
                auto parent = p.parent_path().string();
                std::string bin_path = parent + '/' + root["buffers"][i]["uri"].GetString();
                auto buffer = zeno::file_get_binary(bin_path);
                zeno::log_info("{}", bin_path);
                buffers.push_back(buffer);
            }
        }

        std::vector<Accessor> accessors;
        {
            for (auto i = 0; i < root["accessors"].Size(); i++) {
                const auto & a = root["accessors"][i];
                Accessor accessor;
                accessor.bufferView = a.HasMember("bufferView")? a["bufferView"].GetInt():0;
                accessor.count = a["count"].GetInt();
                accessor.componentType = ComponentType(a["componentType"].GetInt());
                std::string str_type = a["type"].GetString();
                if (str_type == "SCALAR") {
                    accessor.type = Type::SCALAR;
                }
                else if (str_type == "VEC2") {
                    accessor.type = Type::VEC2;
                }
                else if (str_type == "VEC3") {
                    accessor.type = Type::VEC3;
                }
                else if (str_type == "VEC4") {
                    accessor.type = Type::VEC4;
                }
                accessors.push_back(accessor);
            }
        }
        std::vector<BufferView> bufferViews;
        {
            for (auto i = 0; i < root["bufferViews"].Size(); i++) {
                const auto & v = root["bufferViews"][i];
                BufferView bufferView;
                bufferView.buffer = v["buffer"].GetInt();
                bufferView.byteOffset = v.HasMember("byteOffset")? v["byteOffset"].GetInt() : 0;
                bufferView.byteStride = v.HasMember("byteStride")? v["byteStride"].GetInt() : 0;
                bufferView.byteLength = v["byteLength"].GetInt();
                bufferViews.push_back(bufferView);
            }
        }
        auto prim = std::make_shared<zeno::PrimitiveObject>();
        {
            const auto &mesh = root["meshes"][0];
            const auto &primitive = mesh["primitives"][0];
            {
                const auto &position = primitive["attributes"]["POSITION"].GetInt();
                const auto &acc = accessors[position];
                const auto &bv = bufferViews[acc.bufferView];
                auto reader = BinaryReader(buffers[bv.buffer]);
                reader.seek_from_begin(bv.byteOffset);
                prim->resize(acc.count);
                for (auto i = 0; i < acc.count; i++) {
                    prim->verts[i] = reader.read_LE<vec3f>();
                }
            }
            {
                auto index = primitive["indices"].GetInt();
                const auto &acc = accessors[index];
                const auto &bv = bufferViews[acc.bufferView];
                auto reader = BinaryReader(buffers[bv.buffer]);
                reader.seek_from_begin(bv.byteOffset);
                auto count = acc.count / 3;
                prim->tris.resize(count);
                if (acc.componentType == ComponentType::GL_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = reader.read_LE<int8_t>();
                        auto f1 = reader.read_LE<int8_t>();
                        auto f2 = reader.read_LE<int8_t>();
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = reader.read_LE<uint8_t>();
                        auto f1 = reader.read_LE<uint8_t>();
                        auto f2 = reader.read_LE<uint8_t>();
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = reader.read_LE<int16_t>();
                        auto f1 = reader.read_LE<int16_t>();
                        auto f2 = reader.read_LE<int16_t>();
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = reader.read_LE<uint16_t>();
                        auto f1 = reader.read_LE<uint16_t>();
                        auto f2 = reader.read_LE<uint16_t>();
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = reader.read_LE<int32_t>();
                        auto f1 = reader.read_LE<int32_t>();
                        auto f2 = reader.read_LE<int32_t>();
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = (int)(reader.read_LE<uint32_t>());
                        auto f1 = (int)(reader.read_LE<uint32_t>());
                        auto f2 = (int)(reader.read_LE<uint32_t>());
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_FLOAT) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = (int)(reader.read_LE<float>());
                        auto f1 = (int)(reader.read_LE<float>());
                        auto f2 = (int)(reader.read_LE<float>());
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else if (acc.componentType == ComponentType::GL_DOUBLE) {
                    for (auto i = 0; i < count; i++) {
                        auto f0 = (int)(reader.read_LE<double>());
                        auto f1 = (int)(reader.read_LE<double>());
                        auto f2 = (int)(reader.read_LE<double>());
                        prim->tris[i] = {f0, f1, f2};
                    }
                }
                else {
                    zeno::log_info("not support componentType for face: {}", int(acc.componentType));
                }
            }
            {
                const auto &normal = primitive["attributes"]["NORMAL"].GetInt();
                const auto &acc = accessors[normal];
                const auto &bv = bufferViews[acc.bufferView];
                auto reader = BinaryReader(buffers[bv.buffer]);
                reader.seek_from_begin(bv.byteOffset);
                auto count = acc.count/3;
                auto &n = prim->verts.add_attr<vec3f>("nrm");
                if (acc.componentType == ComponentType::GL_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int8_t>());
                        auto n1 = (float)(reader.read_LE<int8_t>());
                        auto n2 = (float)(reader.read_LE<int8_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint8_t>());
                        auto n1 = (float)(reader.read_LE<uint8_t>());
                        auto n2 = (float)(reader.read_LE<uint8_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int16_t>());
                        auto n1 = (float)(reader.read_LE<int16_t>());
                        auto n2 = (float)(reader.read_LE<int16_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint16_t>());
                        auto n1 = (float)(reader.read_LE<uint16_t>());
                        auto n2 = (float)(reader.read_LE<uint16_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int32_t>());
                        auto n1 = (float)(reader.read_LE<int32_t>());
                        auto n2 = (float)(reader.read_LE<int32_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint32_t>());
                        auto n1 = (float)(reader.read_LE<uint32_t>());
                        auto n2 = (float)(reader.read_LE<uint32_t>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_FLOAT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<float>());
                        auto n1 = (float)(reader.read_LE<float>());
                        auto n2 = (float)(reader.read_LE<float>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else if (acc.componentType == ComponentType::GL_DOUBLE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<double>());
                        auto n1 = (float)(reader.read_LE<double>());
                        auto n2 = (float)(reader.read_LE<double>());
                        zeno::vec3f vn = {n0, n1, n2};
                        n[i] = vn;
                    }
                }
                else {
                    zeno::log_info("no support componentType for normal: {}", int(acc.componentType));
                }
            }
            {
                int T0 = 0;
                if (primitive["attributes"].HasMember("TEXCOORD_0")){
                    T0 = primitive["attributes"]["TEXCOORD_0"].GetInt();
                }
                const auto &acc = accessors[T0];
                const auto &bv = bufferViews[acc.bufferView];
                auto reader = BinaryReader(buffers[bv.buffer]);
                reader.seek_from_begin(bv.byteOffset);
                auto count = acc.count/4;
                prim->uvs.resize(count);
                auto &uv = prim->uvs;
                if (acc.componentType == ComponentType::GL_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int8_t>());
                        auto n1 = (float)(reader.read_LE<int8_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_BYTE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint8_t>());
                        auto n1 = (float)(reader.read_LE<uint8_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int16_t>());
                        auto n1 = (float)(reader.read_LE<int16_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_SHORT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint16_t>());
                        auto n1 = (float)(reader.read_LE<uint16_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<int32_t>());
                        auto n1 = (float)(reader.read_LE<int32_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_UNSIGNED_INT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<uint32_t>());
                        auto n1 = (float)(reader.read_LE<uint32_t>());
                        uv[i] = {n0,n1};
                    }
                }
                else if (acc.componentType == ComponentType::GL_FLOAT) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<float>());
                        auto n1 = (float)(reader.read_LE<float>());
                        vec2f uu = {n0,n1};
                        uv[i] = uu;
                    }
                }
                else if (acc.componentType == ComponentType::GL_DOUBLE) {
                    for (auto i = 0; i < count; i++) {
                        auto n0 = (float)(reader.read_LE<double>());
                        auto n1 = (float)(reader.read_LE<double>());
                        uv[i] = {n0,n1};
                    }
                }
                else {
                    zeno::log_info("no support componentType for uv: {}", int(acc.componentType));
                }
            }
        }
        set_output("prim", std::move(prim));
    }
};
ZENDEFNODE(ReadGLTF, {
    {
        { "readpath", "path" },
    },
    {
        { "prim" },
    },
    {},
    { "primitive" },
});
}
}

EndlessDaydream
关注
专栏目录
Unity加载draco算法压缩的GLB模型文件
心疼你的一切博客
10-25 1252
随着模型的格式越来越多，不得不加除了FBX还得加载GLB文件所以写篇博客记录一下。
gltf格式解析
3D空间
06-29 2639
gltf官网：https://github.com/KhronosGroup/glTF 官方文档：gltf20-reference-guide.pdf gltf查看器：https://gltf-viewer.donmccurdy.com/ gltf格式解析教程：https://github.com/KhronosGroup/glTF-Tutorials/blob/master/gltfTutorial/README.md 下面是用python解析gltf到json和bytess数据示例 d.
unity加载draco算法压缩为glb的模型
10-26
1.unity加载draco算法压缩为glb的模型 下载之后关闭unity替换文件夹中所有文件即可
glTF格式介绍（8）——解析一个Box的glTF文件
MeteorChenBo的博客
01-18 9737
glTF格式介绍总目录：https://blog.csdn.net/qq_31709249/article/details/86477520 在以前的系列文章中，已经介绍了glTF文件的文件结构，而且拿了一个最简单的例子——三角形的glTF文件简单解析了一下。这一节来解析一个稍微复杂一点的glTF文件——正方形模型。正方形模型来源于glTF官方示例，里面有很多glTF格式的模型，下载下来可以用w...
【开发日志】2023.06 ZENO----HumanPose
Endlessdaydream
06-25 210
Github开源人体姿态识别项目OpenPose中文文档 - 知乎 (zhihu.com)
【开发日志】2023.04 ZENO----Composite----CompNormalMap
Endlessdaydream
04-23 676
CompNormalMap 将灰度图像转换为法线贴图
【开发日志】2023.06 ZENO----ObjectRecog----ImageStitching
Endlessdaydream
06-12 233
orb、sift
【开发日志】2023.05 ZENO----Image Processing----ImageInRange
Endlessdaydream
05-08 131
Image Processing----ImageInRange、ImageInRange_gray
【开发日志】2023.06 ZENO----ObjectRecog----Image3DAnalyze
Endlessdaydream
06-23 216
Image3DAnalyze
【开发日志】2023.05 ZENO----ApplyNormalMap----法线贴图、纹理映射
Endlessdaydream
05-17 235
NormalMap Back To Sphere
科学计算器ZENO-5000
04-06
**jQuery Dev Architect UI application**暗示了ZENO-5000在开发过程中可能使用了专门的工具和框架，如jQuery UI，来加速界面构建和交互设计。这些工具通常包含预设的组件和特效，可以帮助开发者快速搭建专业级别的...
Zeno-开源
07-03
Zeno :registered:是一个用于构建Web 群件系统的Java 库。 该库提供用于内容管理、用户管理以及电子邮件界面和通知服务的设施。
p5.js-svg:面向p5.js的SVG运行时
05-13
p5.j​​s-svg p5.SVG的主要目标是为p5.js提供SVG运行时，以便我们可以在<svg>中使用p5强大的API进行绘制，将内容保存到svg文件中，并且无需光栅化即可处理现有的SVG文件。...Copyright (c) 2015 Zeno Zeng
ug-qpp-timing-analyzer-ch.pdf
04-26
Intel® Quartus® Prime Pro Edition是英特尔公司推出的一款高级FPGA（现场可编程门阵列）和CPLD（复杂可编程逻辑设备）开发工具，它提供了全面的设计实现流程，包括设计输入、综合、布局布线以及设备编程等功能。...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 1108
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 348
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++——智能指针
最新发布
Wangx_wang的博客
11-12 574
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
caridle的专栏
11-08 706
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 314
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
ERROR: Could not find a version that satisfies the requirement zeno-build (from versions: none) ERROR: No matching distribution found for zeno-build
06-01
这个错误信息通常表示您的 Python 环境中没有名为 zeno-build 的包或库。请注意，这个包可能不是一个公共的 Python 包，而是一个私有的包或库。 如果您确定需要安装 zeno-build 包，您可以尝试以下方法： 1. 检查您的拼写是否正确。确保您正确拼写了 zeno-build。 2. 确定您使用的是正确的 pip 命令。如果您使用的是 Python 2.x 版本，请使用 pip2 命令。如果您使用的是 Python 3.x 版本，请使用 pip3 命令。 3. 如果您已经安装了 zeno-build，您可以尝试升级它。运行以下命令： ``` pip install --upgrade zeno-build ``` 4. 如果您无法通过 pip 安装 zeno-build，您可以尝试从源代码安装。首先，下载源代码并解压缩它。然后，从源代码目录中运行以下命令： ``` python setup.py install ``` 如果您仍然无法安装 zeno-build，请考虑检查该包的文档或联系该包的开发人员以获取更多帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值