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

已于 2023-07-04 18:15:11 修改
阅读量229 收藏
点赞数 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
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Zeno-开源
07-03
Zeno :registered:是一个用于构建Web 群件系统的Java 库。 该库提供用于内容管理、用户管理以及电子邮件界面和通知服务的设施。
科学计算器ZENO-5000
04-06
科学计算器ZENO-5000：HTML 5，CSS 3和客户端jQuery / JavaScript
【开发日志】2023.06 ZENO----HumanPose
Endlessdaydream
06-25 160
Github开源人体姿态识别项目OpenPose中文文档 - 知乎 (zhihu.com)
【开发日志】2023.04 ZENO----Composite----CompNormalMap
Endlessdaydream
04-23 579
CompNormalMap 将灰度图像转换为法线贴图
【开发日志】2023.06 ZENO----ObjectRecog----ImageStitching
Endlessdaydream
06-12 186
orb、sift
【开发日志】2023.05 ZENO----Image Processing----ImageInRange
Endlessdaydream
05-08 96
Image Processing----ImageInRange、ImageInRange_gray
【开发日志】2023.06 ZENO----ObjectRecog----Image3DAnalyze
Endlessdaydream
06-23 180
Image3DAnalyze
【开发日志】2023.05 ZENO----ApplyNormalMap----法线贴图、纹理映射
Endlessdaydream
05-17 194
NormalMap Back To Sphere
【开发日志】2023.06 ZENO----ObjectRecog----imageFeatureMatch 、PoseEstimation-Matrix
Endlessdaydream
06-14 161
perspective、fundamental、essential、homography Matrix
【开发日志】2023.06 ZENO----ImageComposite----ImageMatting（掩膜抠图）
Endlessdaydream
06-02 125
ImageMatting
【开发日志】2023.04 ZENO----Composite----CompImport、ReadImageFlie
Endlessdaydream
04-18 418
CompImport、ReadImageFlie
react-zeno:Zeno的React伴侣，一个针对Typescript进行了优化的Redux实现
05-17
React-Zeno常问问题这与Redux中间件兼容吗？ 为什么“消息”超过“动作”？ 为什么“ messageHandler”超过“ reducer”？ 未来的工作从Redux DevTools扩展发送消息切片内部讯息 芝诺是什么？ Zeno是Redux模式的一种...
ug-qpp-timing-analyzer-ch.pdf
04-26
Intel® Quartus® Prime Pro Edition 用 户指南中文版本，能够帮助大家学习时序约束
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
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 910
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 69
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 262
C语言如何在链表中的指定位置插⼊结点？
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，请考虑检查该包的文档或联系该包的开发人员以获取更多帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值