1、简介
官网地址:
https://www.khronos.org/gltf/
glTF™ 是一种免版税规范,用于通过引擎和应用程序高效传输和加载 3D 场景和模型。
glTF 定义了一种可扩展的发布格式,通过在整个行业中实现 3D 内容的互操作使用来简化创作工作流程和交互式服务。
glTF™(GL 传输格式)用于在 Web 和本机应用程序中传输和加载 3D 模型。glTF 减少了 3D 模型的大小以及解包和渲染这些模型所需的运行时处理。这种格式在 Web 上很常用,并且在 Unity3D、Unreal Engine 4 和 Godot 等各种 3D 引擎中都有支持。
glTF 的内部结构模仿了图形芯片在实时渲染时常用的内存缓冲区,因此可以将资产交付到桌面、Web 或移动客户端,并以最少的处理迅速显示。因此,在导出到 glTF 时,四边形和 n 边形会自动转换为三角形。
b3dm就是在原来gltf单个模型的基础之上,做了批量化的数据组织方式,多了feature table和batch table两个文件。3D Tiles 是一种开放规范,用于在桌面、Web 和移动应用程序中共享、可视化、融合和与大量异构 3D 地理空间内容交互。
1.1 层级结构
- glTF Object Hierarchy
这里来几张作者收集的结构图说明gltf的各种对象组成。
1.2 术语定义
glTF 规范使用常见的工程和图形术语,如image、buffer、texture等来识别和描述某些glTF结构及其属性、状态和行为。本节在规范的上下文中定义了这些术语的基本含义。规范文本提供了更完整的术语定义,并详细阐述、扩展或澄清了这些定义。当本节中定义的术语在规范中以规范语言使用时,规范中的定义支配并取代这些术语在其他技术上下文中(即规范之外)可能具有的任何含义。
-
accessor
An object describing the number and the format of data elements stored in a binary buffer. -
animation
An object describing the keyframe data, including timestamps, and the target property affected by it. -
back-facing
See facingness. -
buffer
An external or embedded resource that represents a linear array of bytes. -
buffer view
An object that represents a range of a specific buffer, and optional metadata that controls how the buffer’s content is interpreted. -
camera
An object defining the projection parameters that are used to render a scene. -
facingness
A classification of a triangle as either front-facing or back-facing, depending on the orientation (winding order) of its vertices. -
front-facing
See facingness. -
image
A two dimensional array of pixels encoded as a standardized bitstream, such as PNG. -
indexed geometry
A mesh primitive that uses a separate source of data (index values) to assemble the primitive’s topology. -
linear blend skinning
A skinning method that computes a per-vertex transformation matrix as a linear weighted sum of transformation matrices of the designated nodes. -
material
A parametrized approximation of visual properties of the real-world object being represented by a mesh primitive. -
mesh
A collection of mesh primitives. -
mesh primitive
An object binding indexed or non-indexed geometry with a material. -
mipmap
A set of image representations consecutively reduced by the factor of 2 in each dimension. -
morph target
An altered state of a mesh primitive defined as a set of difference values for its vertex attributes. -
node
An object defining the hierarchy relations and the local transform of its content. -
non-indexed geometry
A mesh primitive that uses linear order of vertex attribute values to assemble the primitive’s topology. -
normal
A unit XYZ vector defining the perpendicular to the surface. -
root node
A node that is not a child of any other node. -
sampler
An object that controls how image data is sampled. -
scene
An object containing a list of root nodes to render. -
skinning
The process of computing and applying individual transforms for each vertex of a mesh primitive. -
tangent
A unit XYZ vector defining a tangential direction on the surface. -
texture
An object that combines an image and its sampler. -
topology type
State that controls how vertices are assembled, e.g. as lists of triangles, strips of lines, etc. -
vertex attribute
A property associated with a vertex. -
winding order
The relative order in which vertices are defined within a triangle -
wrapping
A process of selecting an image pixel based on normalized texture coordinates.
2、glTF文件预览
2.1 VSCode(v2.0)
安装第三方扩展glTF Tool。
- 打开和预览gltf文件
- 打开和预览glb文件(gltf二进制格式)
2.2 glTF Viewer(v2.0, js)
https://gltf-viewer.donmccurdy.com/
2.3 babylon.js(v2.0,js)
https://sandbox.babylonjs.com/
Babylon.js Sandbox - View glTF, glb, obj and babylon files. Drag and drop gltf, glb, obj or babylon files to view them.
3、tinygltf (v2.0, C++)
https://github.com/syoyo/tinygltf
Header only C++11 tiny glTF 2.0 library
Header only C++ tiny glTF library(loader/saver).
TinyGLTF is a header only C++11 glTF 2.0 https://github.com/KhronosGroup/glTF library.
TinyGLTF uses Niels Lohmann’s json library(https://github.com/nlohmann/json), so now it requires C++11 compiler. If you are looking for old, C++03 version, please use devel-picojson branch(but not maintained anymore).
注意:目前该库仅支持glTF 2.0格式。
它的OpenGL示例编译依赖库需要额外下载。本身就是几个头文件直接使用。
3.1 下载和编译
cd C:\Users\tomcat\Desktop\test
git clone https://github.com/syoyo/tinygltf.git
cd tinygltf
mkdir bin
cd bin
cmake ..
## or
cmake -G "Visual Studio 15 2017" .. -A x64
.\\tools\\windows\\premake5.exe vs2017
- 从GitHub下载该库的源代码
- 通过CMake生成该库的vs2017的工程文件
- 生成的vs2017的工程文件的相关文件截图
- vs2017打开工程文件,进行编译库文件
- 也可以通过premake5来生成该库vs2017的工程文件,如下图所示:
- tinygltf自带例子中一个小例子编译后的运行结果
3.2 官网代码示例
/ Define these only in *one* .cc file.
#define TINYGLTF_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
// #define TINYGLTF_NOEXCEPTION // optional. disable exception handling.
#include "tiny_gltf.h"
using namespace tinygltf;
Model model;
TinyGLTF loader;
std::string err;
std::string warn;
bool ret = loader.LoadASCIIFromFile(&model, &err, &warn, argv[1]);
//bool ret = loader.LoadBinaryFromFile(&model, &err, &warn, argv[1]); // for binary glTF(.glb)
if (!warn.empty()) {
printf("Warn: %s\n", warn.c_str());
}
if (!err.empty()) {
printf("Err: %s\n", err.c_str());
}
if (!ret) {
printf("Failed to parse glTF\n");
return -1;
}
4、TinyGLTFLoader (v1.0, C++)
Tiny glTF loader, header only C++ glTF 1.x parsing library.
4.1 下载和编译
https://github.com/syoyo/tinygltfloader
注意:目前该库仅支持glTF 1.0格式。
这个库不需要编译,直接引用头文件.h就可以了。
4.2 picojson库
https://github.com/kazuho/picojson/
a header-file-only, JSON parser serializer in C++
copyright © 2009-2010 Cybozu Labs, Inc. Copyright © 2011-2015 Kazuho Oku
代码示例如下:
const char* json = "{\"a\":1}";
picojson::value v;
std::string err;
const char* json_end = picojson::parse(v, json, json + strlen(json), &err);
if (! err.empty()) {
std::cerr << err << std::endl;
}
picojson::value v;
// parse the input
std::cin >> v;
std::string err = picojson::get_last_error();
if (! err.empty()) {
std::cerr << err << std::endl;
exit(1);
}
// check if the type of the value is "object"
if (! v.is<picojson::object>()) {
std::cerr << "JSON is not an object" << std::endl;
exit(2);
}
// obtain a const reference to the map, and print the contents
const picojson::value::object& obj = v.get<picojson::object>();
for (picojson::value::object::const_iterator i = obj.begin();
i != obj.end();
++i) {
std::cout << i->first << ': ' << i->second.to_str() << std::endl;
}
4.3 官网代码示例
Copy stb_image.h, picojson.h and tiny_gltf_loader.h to your project.
// Define these only in *one* .cc file.
#define TINYGLTF_LOADER_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#include "tiny_gltf_loader.h"
using namespace tinygltf;
Scene scene;
TinyGLTFLoader loader;
std::string err;
bool ret = loader.LoadASCIIFromFile(scene, err, argv[1]);
//bool ret = loader.LoadBinaryFromFile(scene, err, argv[1]); // for binary glTF(.glb)
if (!err.empty()) {
printf("Err: %s\n", err.c_str());
}
if (!ret) {
printf("Failed to parse glTF\n");
return -1;
}
![【CAD开发】glTF和b3dm文件格式读取(C++,Python)](https://imgs.yssmx.com/Uploads/2023/04/400839-23.png)
![【CAD开发】glTF和b3dm文件格式读取(C++,Python)](https://imgs.yssmx.com/Uploads/2023/04/400839-24.png)
4.4 自己测试代码1
根据前面贴的结构图,编写代码遍历gltf1.0文件包含的所有几何数据(顶点、法线、面、纹理坐标、纹理图片数据等)。
//***********************************************************************
// Purpose: tiny_gltf_loader遍历gltf v1.0文件的几何数据
// Author: 爱看书的小沐
// Date: 2022-4-19
// Languages: C++
// Platform: Visual Studio 2017
// OS: Win10 win64
// ***********************************************************************
#define TINYGLTF_LOADER_IMPLEMENTATION
#define STB_IMAGE_IMPLEMENTATION
#include "tiny_gltf_loader.h"
void DumpNode(const tinygltf::Node &node, tinygltf::Scene &scene) {
for (size_t i = 0; i < node.meshes.size(); i++) {
std::map<std::string, tinygltf::Mesh>::const_iterator it_mesh = scene.meshes.find(node.meshes[i]);
if (it_mesh == scene.meshes.end()) {
continue;
}
const tinygltf::Mesh& mesh = it_mesh->second;
for (size_t i = 0; i < mesh.primitives.size(); i++) {
const tinygltf::Primitive &primitive = mesh.primitives[i];
if (primitive.indices.empty()) return;
///
// get texture data
tinygltf::Material &mat = scene.materials[primitive.material];
if (mat.values.find("diffuse") != mat.values.end()) {
std::string diffuseTexName = mat.values["diffuseTex"].string_value;
//std::string diffuseTexName2 = mat.values["diffuse"].string_value;
if (scene.textures.find(diffuseTexName) != scene.textures.end()) {
tinygltf::Texture &tex = scene.textures[diffuseTexName];
if (scene.images.find(tex.source) != scene.images.end()) {
tinygltf::Image &image = scene.images[tex.source];
image.image;
image.width;
image.height;
image.component;
image.image.size();
}
}
}
///
// get face data primitive.indices
const tinygltf::Accessor indexAccessor = scene.accessors[primitive.indices];
indexAccessor.type;
indexAccessor.componentType;
indexAccessor.byteStride;
indexAccessor.byteOffset;
indexAccessor.count;
const tinygltf::BufferView &bufferView = scene.bufferViews[indexAccessor.bufferView];
const tinygltf::Buffer &buffer = scene.buffers[bufferView.buffer];
printf("\n");
float* pointArr = NULL;
float* normalArr = NULL;
float* textureArr = NULL;
unsigned short* faceIndex = NULL;
int faceCount = 0;
int pointCount = 0;
int normalCount = 0;
int texCount = 0;
faceCount = indexAccessor.count;
faceIndex = new unsigned short[faceCount];
//assert(bufferView.byteLength == faceCount *sizeof(unsigned short));
memcpy(faceIndex, &buffer.data[0] + bufferView.byteOffset+ indexAccessor.byteOffset, faceCount * sizeof(unsigned short));
///
// get point and texture data
std::map<std::string, std::string>::const_iterator it(primitive.attributes.begin());
std::map<std::string, std::string>::const_iterator itEnd(primitive.attributes.end());
for (; it != itEnd; it++) {
assert(scene.accessors.find(it->second) != scene.accessors.end());
const tinygltf::Accessor &accessor = scene.accessors[it->second];
const tinygltf::BufferView &bufferView_pt = scene.bufferViews[accessor.bufferView];
const tinygltf::Buffer &buffer_pt = scene.buffers[bufferView_pt.buffer];
int count = 1;
if (accessor.type == TINYGLTF_TYPE_SCALAR) {
count = 1;
}
else if (accessor.type == TINYGLTF_TYPE_VEC2) {
count = 2;
}
else if (accessor.type == TINYGLTF_TYPE_VEC3) {
count = 3;
}
else if (accessor.type == TINYGLTF_TYPE_VEC4) {
count = 4;
}
else {
assert(0);
}
if (it->first.compare("POSITION") == 0) {
pointCount = accessor.count * count;
pointArr = new float[pointCount];
memcpy(pointArr, &buffer_pt.data[0]+ bufferView_pt.byteOffset + accessor.byteOffset, pointCount* sizeof(float));
}
else if (it->first.compare("NORMAL") == 0) {
normalCount = accessor.count * count;
normalArr = new float[normalCount];
memcpy(normalArr, &buffer_pt.data[0] + bufferView_pt.byteOffset + accessor.byteOffset, normalCount * sizeof(float));
}
else if (it->first.compare("TEXCOORD_0") == 0) {
texCount = accessor.count * count;
textureArr = new float[texCount];
memcpy(textureArr, &buffer_pt.data[0] + bufferView_pt.byteOffset + accessor.byteOffset, texCount * sizeof(float));
}
if ((it->first.compare("POSITION") == 0) ||
(it->first.compare("NORMAL") == 0) ||
(it->first.compare("TEXCOORD_0") == 0)) {
//#define GL_BYTE 0x1400 5120
//#define GL_UNSIGNED_BYTE 0x1401 5121
//#define GL_SHORT 0x1402 5122
//#define GL_UNSIGNED_SHORT 0x1403 5123
//#define GL_INT 0x1404 5124
//#define GL_UNSIGNED_INT 0x1405 5125
//#define GL_FLOAT 0x1406 5126
accessor.type;
accessor.componentType;
accessor.byteStride;
accessor.byteOffset;
accessor.count;
const tinygltf::BufferView &bufferView = scene.bufferViews[accessor.bufferView];
const tinygltf::Buffer &buffer = scene.buffers[bufferView.buffer];
printf("\n");
}
}
}
}
for (size_t i = 0; i < node.children.size(); i++) {
std::map<std::string, tinygltf::Node>::const_iterator it =
scene.nodes.find(node.children[i]);
if (it != scene.nodes.end()) {
//DrawNode(scene, it->second);
}
}
}
static void Dump(const tinygltf::Scene &scene) {
std::cout << "=== Dump glTF ===" << std::endl;
std::cout << "asset.generator : " << scene.asset.generator
<< std::endl;
std::cout << "asset.premultipliedAlpha : " << scene.asset.premultipliedAlpha
<< std::endl;
std::cout << "asset.version : " << scene.asset.version
<< std::endl;
std::cout << "asset.profile.api : " << scene.asset.profile_api
<< std::endl;
std::cout << "asset.profile.version : " << scene.asset.profile_version
<< std::endl;
std::cout << std::endl;
std::cout << "=== Dump scene ===" << std::endl;
std::cout << "defaultScene: " << scene.defaultScene << std::endl;
{
std::map<std::string, tinygltf::Node>::const_iterator it(
scene.nodes.begin());
std::map<std::string, tinygltf::Node>::const_iterator itEnd(
scene.nodes.end());
std::cout << "nodes(items=" << scene.nodes.size() << ")" << std::endl;
for (; it != itEnd; it++) {
DumpNode(it->second, (tinygltf::Scene &)scene);
}
}
}
int main(int argc, char **argv) {
/*if (argc < 2) {
printf("Needs input.gltf\n");
exit(1);
}*/
tinygltf::Scene scene;
tinygltf::TinyGLTFLoader loader;
std::string err;
std::string input_filename("c:\\Users\\tomcat\\Desktop\\BlockB.b3dm");
std::string ext = GetFilePathExtension(input_filename);
bool ret = false;
if (ext.compare("glb") == 0) {
// assume binary glTF.
ret = loader.LoadBinaryFromFile(&scene, &err, input_filename.c_str());
}
else if (ext.compare("gltf") == 0) {
// assume ascii glTF.
ret = loader.LoadASCIIFromFile(&scene, &err, input_filename.c_str());
}
else if (ext.compare("b3dm") == 0) {
ret = loader.LoadB3dmFromFile(&scene, &err, input_filename.c_str());
}
else {
return false;
}
if (!err.empty()) {
printf("Err: %s\n", err.c_str());
}
if (!ret) {
printf("Failed to parse glTF\n");
return -1;
}
Dump(scene);
return 0;
}
4.5 自己测试代码2
在头文件tiny_gltf_loader.h中,增加读取b3dm文件格式(3d地图瓦片)的接口。
//***********************************************************************
// Purpose: tiny_gltf_loader增加读取b3dm文件格式的接口
// Author: 爱看书的小沐
// Date: 2022-4-19
// Languages: C++
// Platform: Visual Studio 2017
// OS: Win10 win64
// ***********************************************************************
// 读取b3dm文件的文件头,返回值为头部的长度
int ReadB3dmHeader(std::ifstream &f, bool &rtcCenterEnable, float *rtcCenterPos)
{
rtcCenterEnable = false;
if (rtcCenterPos) {
rtcCenterPos[0] = 0;
rtcCenterPos[1] = 0;
rtcCenterPos[2] = 0;
}
int header[7];
int len_header = 7 * sizeof(int);
f.seekg(0, f.beg);
std::vector<char> buf(len_header);
f.read(&buf.at(0), static_cast<std::streamsize>(len_header));
::memcpy(header, &buf.at(0), len_header);
int len_featureTable = header[3];
if (len_featureTable > 20 && rtcCenterPos != nullptr) {
char *json = new char[len_featureTable + 1];
f.read(json, len_featureTable);
json[len_featureTable] = '\0';
picojson::value v;
std::string err;
const char* json_end = picojson::parse(v, json, json + strlen(json), &err);
if (!err.empty()) {
std::cerr << err << std::endl;
}
// obtain a const reference to the map, and print the contents
const picojson::value::object& obj = v.get<picojson::object>();
for (picojson::value::object::const_iterator i = obj.begin(); i != obj.end() ; ++i) {
std::cout << i->first << ': ' << i->second.to_str() << std::endl;
if (i->first.compare("RTC_CENTER") == 0) {
const picojson::value::array& center = i->second.get<picojson::array>();
rtcCenterPos[0] = (float)center[0].get<double>();
rtcCenterPos[1] = (float)center[1].get<double>();
rtcCenterPos[2] = (float)center[2].get<double>();
rtcCenterEnable = true;
}
}
delete[] json;
}
return len_header + header[3] + header[4] + header[5] + header[6];
}
// 读取gltf文件的文件头,返回值为gltf的版本号
int ReadGltfHeader(std::ifstream &f, int offset)
{
std::vector<char> buf(16);
f.seekg(offset, f.beg);
f.read(&buf.at(0), static_cast<std::streamsize>(buf.size()));
//std::string strBuf;
//strBuf.clear();
//strBuf.assign(buf.begin(), buf.end());
return buf[4];
}
// 读取b3dm文件的b3dm头部和gltf头部
int TinyGLTFLoader::ReadB3dmVersion(const std::string &filename, bool &rtcCenterEnable, float *rtcCenterPos) {
std::stringstream ss;
std::ifstream f(filename.c_str(), std::ios::binary);
if (!f) {
return 0;
}
int len_b3dm = ReadB3dmHeader(f, rtcCenterEnable, rtcCenterPos);
int ver = ReadGltfHeader(f, len_b3dm);
f.close();
return ver;
}
// 读取b3dm文件的所有内容
bool TinyGLTFLoader::LoadB3dmFromFile(Scene *scene, std::string *err,
const std::string &filename,
unsigned int check_sections) {
std::stringstream ss;
std::ifstream f(filename.c_str(), std::ios::binary);
if (!f) {
ss << "Failed to open file: " << filename << std::endl;
if (err) {
(*err) = ss.str();
}
return false;
}
bool rtcCenterEnable = false;
float rtcCenterPos[3] = {0};
int len_b3dm = ReadB3dmHeader(f, rtcCenterEnable, rtcCenterPos);
int ver = ReadGltfHeader(f, len_b3dm);
if (ver != 1) return false;
f.seekg(0, f.end);
size_t sz = static_cast<size_t>(f.tellg());
std::vector<char> buf(sz - len_b3dm);
f.seekg(len_b3dm, f.beg);
f.read(&buf.at(0), static_cast<std::streamsize>(sz - len_b3dm));
f.close();
std::string basedir = GetBaseDir(filename);
bool ret = LoadBinaryFromMemory(
scene, err, reinterpret_cast<unsigned char *>(&buf.at(0)),
static_cast<unsigned int>(buf.size()), basedir, check_sections);
return ret;
}
5、libgltf (v2.0, C++)
https://github.com/code4game/libgltf
libgltf:glTF 2.0 parser/loader for C++11, supports many extensions
likesKHR_draco_mesh_compression
,KHR_lights_punctual
,KHR_materials_clearcoat
, and more.
注意:目前该库仅支持glTF 2.0格式。
它的编译依赖库不不不需要额外下载。
5.1 下载和编译
cd C:\Users\tomcat\Desktop\test
git clone https://github.com/code4game/libgltf.git
cd libgltf
git submodule update --init
mkdir bin
cd bin
cmake ..
## or
cmake -G "Visual Studio 15 2017" .. -A x64
-
从github上下载libgltf的源代码,如下图所示:
-
下载libgltf的源代码的文件夹,如下所示:
-
通过cmake生成vs2017的工程文件。
-
vs2017打开上面生成的工程文件,编译生成libgltf的库文件,如下图所示:
5.2 nlohmann/json库
https://github.com/nlohmann/json
JSON for Modern C++
代码示例如下:
// write a JSON file
// create an empty structure (null)
json j;
// add a number that is stored as double (note the implicit conversion of j to an object)
j["pi"] = 3.141;
// add a Boolean that is stored as bool
j["happy"] = true;
// add a string that is stored as std::string
j["name"] = "Niels";
// add another null object by passing nullptr
j["nothing"] = nullptr;
// add an object inside the object
j["answer"]["everything"] = 42;
// add an array that is stored as std::vector (using an initializer list)
j["list"] = { 1, 0, 2 };
// add another object (using an initializer list of pairs)
j["object"] = { {"currency", "USD"}, {"value", 42.99} };
// instead, you could also write (which looks very similar to the JSON above)
json j2 = {
{"pi", 3.141},
{"happy", true},
{"name", "Niels"},
{"nothing", nullptr},
{"answer", {
{"everything", 42}
}},
{"list", {1, 0, 2}},
{"object", {
{"currency", "USD"},
{"value", 42.99}
}}
};
// read a JSON file
std::ifstream i("file.json");
json j;
i >> j;
// write prettified JSON to another file
std::ofstream o("pretty.json");
o << std::setw(4) << j << std::endl;
5.3 官网代码示例1
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(/*your gltf file*/);
std::shared_ptr<libgltf::SGlTF> loaded_gltf = gltf_loader->glTF().lock();
if (!loaded_gltf)
{
printf("failed to load your gltf file");
}
5.4 官网代码示例2
#include "runtest.h"
#include <libgltf/libgltf_ext.h>
#include <string>
#include <sstream>
#include <fstream>
#if defined(LIBGLTF_PLATFORM_WINDOWS)
#include <tchar.h>
#include <crtdbg.h>
#endif
#if defined(LIBGLTF_CHARACTOR_ENCODING_IS_UNICODE) && defined(LIBGLTF_PLATFORM_WINDOWS)
int _tmain(int _iArgc, wchar_t* _pcArgv[])
#else
int main(int _iArgc, char* _pcArgv[])
#endif
{
#if defined(LIBGLTF_PLATFORM_WINDOWS) && defined(_DEBUG)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
#if defined(LIBGLTF_BUILD_COVERAGE)
int error_code = 0;
#else
int error_code = 1;
#endif
#if defined(LIBGLTF_CHARACTOR_ENCODING_IS_UNICODE) && defined(LIBGLTF_PLATFORM_WINDOWS)
std::wstring input_file_path;
#else
std::string input_file_path;
#endif
{
#if defined(LIBGLTF_CHARACTOR_ENCODING_IS_UNICODE) && defined(LIBGLTF_PLATFORM_WINDOWS)
std::wstringstream argument;
#else
std::stringstream argument;
#endif
argument << _pcArgv[1];
input_file_path = argument.str();
}
if (input_file_path.length() == 0)
{
printf("Command line format: runtest input_file_path\n");
return error_code;
}
#if defined(LIBGLTF_CHARACTOR_ENCODING_IS_UTF16)
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(libgltf::UTF8ToUTF16(input_file_path));
#elif defined(LIBGLTF_CHARACTOR_ENCODING_IS_UTF32)
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(libgltf::UTF8ToUTF32(input_file_path));
#elif defined(LIBGLTF_CHARACTOR_ENCODING_IS_UNICODE)
#if defined(LIBGLTF_PLATFORM_WINDOWS)
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(input_file_path);
#else
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(libgltf::UTF8ToUNICODE(input_file_path));
#endif
#else
std::shared_ptr<libgltf::IglTFLoader> gltf_loader = libgltf::IglTFLoader::Create(input_file_path);
#endif
std::shared_ptr<libgltf::SGlTF> loaded_gltf = gltf_loader->glTF().lock();
if (loaded_gltf)
{
printf("operator << Success\n");
}
else
{
printf("operator << Failed\n");
return error_code;
}
int num_node = loaded_gltf->nodes.size();
int num_mesh = loaded_gltf->meshes.size();
const std::shared_ptr<libgltf::SMesh>& mesh = loaded_gltf->meshes[0];
int num_pri = mesh->primitives.size();
libgltf::TDimensionVector<1, size_t> triangle_data;
std::shared_ptr<libgltf::TAccessorStream<libgltf::TDimensionVector<1, size_t> > > triangle_stream = std::make_shared<libgltf::TAccessorStream<libgltf::TDimensionVector<1, size_t> > >(triangle_data);
gltf_loader->GetOrLoadMeshPrimitiveIndicesData(0, 0, triangle_stream);
libgltf::TDimensionVector<3, float> position_data;
std::shared_ptr<libgltf::TAccessorStream<libgltf::TDimensionVector<3, float> > > position_stream = std::make_shared<libgltf::TAccessorStream<libgltf::TDimensionVector<3, float> > >(position_data);
gltf_loader->GetOrLoadMeshPrimitiveAttributeData(0, 0, GLTFTEXT("position"), position_stream);
libgltf::TDimensionVector<3, float> normal_data;
std::shared_ptr<libgltf::TAccessorStream<libgltf::TDimensionVector<3, float> > > normal_stream = std::make_shared<libgltf::TAccessorStream<libgltf::TDimensionVector<3, float> > >(normal_data);
gltf_loader->GetOrLoadMeshPrimitiveAttributeData(0, 0, GLTFTEXT("normal"), normal_stream);
libgltf::TDimensionVector<2, float> texcoord_0_data;
std::shared_ptr<libgltf::TAccessorStream<libgltf::TDimensionVector<2, float> > > texcoord_0_stream = std::make_shared<libgltf::TAccessorStream<libgltf::TDimensionVector<2, float> > >(texcoord_0_data);
gltf_loader->GetOrLoadMeshPrimitiveAttributeData(0, 0, GLTFTEXT("texcoord_0"), texcoord_0_stream);
std::vector<uint8_t> image0_data;
libgltf::string_t image0_data_type;
gltf_loader->GetOrLoadImageData(0, image0_data, image0_data_type);
//TODO: just convert to json, save the mesh or image data to file in future
libgltf::string_t output_content;
if (loaded_gltf >> output_content)
{
printf("nodes: %d\n", num_node);
printf("meshes: %d\n", num_mesh);
printf("meshes[0]'s primitives: %d\n", num_pri);
printf("triangle_data: %d\n", triangle_data.size());
printf("position_data: %d\n", position_data.size());
printf("normal_data: %d\n", normal_data.size());
printf("texcoord_0_data: %d\n", texcoord_0_data.size());
printf("image0_data: %d\n", image0_data.size());
printf("operator >> Success\n");
}
else
{
printf("operator >> Failed\n");
return error_code;
}
return 0;
}
加载三维模型文件:C:\Users\tomcat\Desktop\dtiles_3\BlockBAB\BlockBAB.glb
运行结果如下:
5.5 自己测试代码
//***********************************************************************
// Purpose: 在libgltf代码中增加读取b3dm文件格式的接口
// Author: 爱看书的小沐
// Date: 2022-4-19
// Languages: C++
// Platform: Visual Studio 2017
// OS: Win10 win64
// ***********************************************************************
int CFileLoader::ReadB3dmHeader(const string_t& _sFilePath) const
{
float RTC_CENTER[3] = { 0,0,0 };
bool RTC_CENTER_enable = false;
const std::vector<uint8_t>& file_data = (*this)[_sFilePath];
if (file_data.empty()) return 0;
int header[7];
::memcpy(header, file_data.data(), 7*sizeof(int));
int len_featureTable = header[3];
if (len_featureTable > 20) {
char *buffer = new char[len_featureTable + 1];
::memcpy(buffer, file_data.data() + 7 * sizeof(int), len_featureTable * sizeof(char));
buffer[len_featureTable] = '\0';
auto j = json::parse(buffer);
bool ret = j.contains(json::json_pointer("/RTC_CENTER"));
if (ret) {
auto center = j["RTC_CENTER"];
RTC_CENTER[0] = center[0];
RTC_CENTER[1] = center[1];
RTC_CENTER[2] = center[2];
RTC_CENTER_enable = true;
}
else {
RTC_CENTER[0] = 0;
RTC_CENTER[1] = 0;
RTC_CENTER[2] = 0;
RTC_CENTER_enable = false;
}
delete[] buffer;
}
return 7*sizeof(int)+ header[3] + header[4] + header[5] + header[6];
}
6、assimp (v1.0, v2.0, C++)
https://github.com/assimp/assimp
https://assimp-docs.readthedocs.io/en/v5.1.0/
The official Open-Asset-Importer-Library Repository. Loads 40+ 3D-file-formats into one unified and clean data structure.
Asset-Importer-Lib(简称 assimp)是一个库,用于加载和处理来自各种 3D 数据格式的几何场景。通过支持节点层次结构、静态或蒙皮网格、材质、骨骼动画和潜在纹理数据,它主要针对典型的游戏场景进行定制。但也支持一些 3D 打印和 CAD 格式。
- 目前assimp库支持如下模型格式的导入:
3D Manufacturing Format (.3mf)
Collada (.dae, .xml)
Blender (.blend)
Biovision BVH (.bvh)
3D Studio Max 3DS (.3ds)
3D Studio Max ASE (.ase)
glTF (.glTF)
glTF2.0 (.glTF)
FBX-Format, as ASCII and binary (.fbx)
Stanford Polygon Library (.ply)
AutoCAD DXF (.dxf)
IFC-STEP (.ifc)
Neutral File Format (.nff)
Sense8 WorldToolkit (.nff)
Valve Model (.smd, .vta)
Quake I (.mdl)
Quake II (.md2)
Quake III (.md3)
Quake 3 BSP (.pk3)
RtCW (.mdc)
Doom 3 (.md5mesh, .md5anim, .md5camera)
DirectX X (.x)
Quick3D (.q3o, .q3s)
Raw Triangles (.raw)
AC3D (.ac, .ac3d)
Stereolithography (.stl)
Autodesk DXF (.dxf)
Irrlicht Mesh (.irrmesh, .xml)
Irrlicht Scene (.irr, .xml)
Object File Format ( .off )
Wavefront Object (.obj)
Terragen Terrain ( .ter )
3D GameStudio Model ( .mdl )
3D GameStudio Terrain ( .hmp )
Ogre ( .mesh.xml, .skeleton.xml, .material )
OpenGEX-Fomat (.ogex)
Milkshape 3D ( .ms3d )
LightWave Model ( .lwo )
LightWave Scene ( .lws )
Modo Model ( .lxo )
CharacterStudio Motion ( .csm )
Stanford Ply ( .ply )
TrueSpace (.cob, .scn)
XGL-3D-Format (.xgl)
6.1 下载和编译
从它的GitHub官网上下载代码,用cmake默认直接编译即可。
6.2 官网代码示例
- 代码示例:这是一段加载gltf模型文件的代码。
#include <stdlib.h>
#include <stdio.h>
/* assimp include files. These three are usually needed. */
#include <assimp/cimport.h>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#pragma comment(lib, "..\\..\\lib\\Debug\\assimp-vc141-mtd.lib")
#pragma comment(lib, "..\\..\\contrib\\zlib\\Debug\\zlibstaticd.lib")
/* ---------------------------------------------------------------------------- */
inline static void print_error(const char* msg) {
printf("ERROR: %s\n", msg);
}
#define NEW_LINE "\n"
#define DOUBLE_NEW_LINE NEW_LINE NEW_LINE
/* the global Assimp scene object */
const C_STRUCT aiScene* scene = NULL;
C_STRUCT aiVector3D scene_min, scene_max, scene_center;
/* current rotation angle */
static float angle = 0.f;
#define aisgl_min(x,y) (x<y?x:y)
#define aisgl_max(x,y) (y>x?y:x)
/* ---------------------------------------------------------------------------- */
void get_bounding_box_for_node (const C_STRUCT aiNode* nd,
C_STRUCT aiVector3D* min,
C_STRUCT aiVector3D* max,
C_STRUCT aiMatrix4x4* trafo
){
C_STRUCT aiMatrix4x4 prev;
unsigned int n = 0, t;
prev = *trafo;
aiMultiplyMatrix4(trafo,&nd->mTransformation);
for (; n < nd->mNumMeshes; ++n) {
const C_STRUCT aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
for (t = 0; t < mesh->mNumVertices; ++t) {
C_STRUCT aiVector3D tmp = mesh->mVertices[t];
aiTransformVecByMatrix4(&tmp,trafo);
min->x = aisgl_min(min->x,tmp.x);
min->y = aisgl_min(min->y,tmp.y);
min->z = aisgl_min(min->z,tmp.z);
max->x = aisgl_max(max->x,tmp.x);
max->y = aisgl_max(max->y,tmp.y);
max->z = aisgl_max(max->z,tmp.z);
}
}
for (n = 0; n < nd->mNumChildren; ++n) {
get_bounding_box_for_node(nd->mChildren[n],min,max,trafo);
}
*trafo = prev;
}
/* ---------------------------------------------------------------------------- */
void get_bounding_box(C_STRUCT aiVector3D* min, C_STRUCT aiVector3D* max)
{
C_STRUCT aiMatrix4x4 trafo;
aiIdentityMatrix4(&trafo);
min->x = min->y = min->z = 1e10f;
max->x = max->y = max->z = -1e10f;
get_bounding_box_for_node(scene->mRootNode,min,max,&trafo);
}
/* ---------------------------------------------------------------------------- */
void color4_to_float4(const C_STRUCT aiColor4D *c, float f[4])
{
f[0] = c->r;f[1] = c->g;f[2] = c->b;f[3] = c->a;
}
/* ---------------------------------------------------------------------------- */
void set_float4(float f[4], float a, float b, float c, float d)
{
f[0] = a;f[1] = b;f[2] = c;f[3] = d;
}
/* ---------------------------------------------------------------------------- */
void apply_material(const C_STRUCT aiMaterial *mtl)
{
float c[4];
int fill_mode;
int ret1, ret2;
C_STRUCT aiColor4D diffuse;
C_STRUCT aiColor4D specular;
C_STRUCT aiColor4D ambient;
C_STRUCT aiColor4D emission;
ai_real shininess, strength;
int two_sided;
int wireframe;
unsigned int max;
set_float4(c, 0.8f, 0.8f, 0.8f, 1.0f);
if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_DIFFUSE, &diffuse))
color4_to_float4(&diffuse, c);
printf(" GL_DIFFUSE: %.3f, %.3f, %.3f, %.3f\n", c[0], c[1], c[2], c[3]);
set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_SPECULAR, &specular))
color4_to_float4(&specular, c);
printf(" GL_SPECULAR: %.3f, %.3f, %.3f, %.3f\n", c[0], c[1], c[2], c[3]);
set_float4(c, 0.2f, 0.2f, 0.2f, 1.0f);
if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_AMBIENT, &ambient))
color4_to_float4(&ambient, c);
printf(" GL_AMBIENT: %.3f, %.3f, %.3f, %.3f\n", c[0], c[1], c[2], c[3]);
set_float4(c, 0.0f, 0.0f, 0.0f, 1.0f);
if (AI_SUCCESS == aiGetMaterialColor(mtl, AI_MATKEY_COLOR_EMISSIVE, &emission))
color4_to_float4(&emission, c);
printf(" GL_EMISSION:%.3f, %.3f, %.3f, %.3f\n", c[0], c[1], c[2], c[3]);
max = 1;
ret1 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS, &shininess, &max);
if (ret1 == AI_SUCCESS) {
max = 1;
ret2 = aiGetMaterialFloatArray(mtl, AI_MATKEY_SHININESS_STRENGTH, &strength, &max);
if (ret2 == AI_SUCCESS)
printf(" GL_SHININESS: %.3f\n", shininess * strength);
else
printf(" GL_SHININESS: %.3f\n", shininess);
}
max = 1;
if (AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_ENABLE_WIREFRAME, &wireframe, &max))
printf(" fill_mode: %s\n", wireframe ? "GL_LINE" : "GL_FILL");
max = 1;
if ((AI_SUCCESS == aiGetMaterialIntegerArray(mtl, AI_MATKEY_TWOSIDED, &two_sided, &max)) && two_sided)
printf(" two_sided: true\n");
}
/* ---------------------------------------------------------------------------- */
void recursive_render (const C_STRUCT aiScene *sc, const C_STRUCT aiNode* nd)
{
unsigned int i;
unsigned int n = 0, t;
C_STRUCT aiMatrix4x4 m = nd->mTransformation;
/* update transform */
aiTransposeMatrix4(&m);
/* draw all meshes assigned to this node */
printf("Node(name: %s, mNumMeshes: %d)\n", nd->mName.data, nd->mNumMeshes);
for (; n < nd->mNumMeshes; ++n) {
const C_STRUCT aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]];
apply_material(sc->mMaterials[mesh->mMaterialIndex]);
printf(" mNumFaces(%d): %d\n", n, mesh->mNumFaces);
for (t = 0; t < mesh->mNumFaces; ++t) {
const C_STRUCT aiFace* face = &mesh->mFaces[t];
//1:GL_POINTS, 2:GL_LINES, 3:GL_TRIANGLES, 0:GL_POLYGON
int face_mode = face->mNumIndices;
for(i = 0; i < face->mNumIndices; i++) {
int index = face->mIndices[i];
//if(mesh->mColors[0] != NULL)
// glColor4fv((GLfloat*)&mesh->mColors[0][index]);
//if(mesh->mNormals != NULL)
// glNormal3fv(&mesh->mNormals[index].x);
//glVertex3fv(&mesh->mVertices[index].x);
}
}
}
/* draw all children */
for (n = 0; n < nd->mNumChildren; ++n) {
recursive_render(sc, nd->mChildren[n]);
}
}
/* ---------------------------------------------------------------------------- */
int loadasset (const char* path)
{
/* we are taking one of the postprocessing presets to avoid
spelling out 20+ single postprocessing flags here. */
scene = aiImportFile(path,aiProcessPreset_TargetRealtime_MaxQuality);
if (scene) {
get_bounding_box(&scene_min,&scene_max);
scene_center.x = (scene_min.x + scene_max.x) / 2.0f;
scene_center.y = (scene_min.y + scene_max.y) / 2.0f;
scene_center.z = (scene_min.z + scene_max.z) / 2.0f;
printf("scene_center: (%.3f, %.3f, %.3f)\n"
, scene_center.x, scene_center.y, scene_center.z);
return 0;
}
return 1;
}
/* ---------------------------------------------------------------------------- */
int main(int argc, char **argv)
{
const char* model_file = NULL;
C_STRUCT aiLogStream stream;
// Check and validate the specified model file extension.
model_file = "D:\\test_3dxml\\Duck1.glb";
const char* extension = strrchr(model_file, '.');
if (!extension) {
print_error("Please provide a file with a valid extension.");
return EXIT_FAILURE;
}
if (AI_FALSE == aiIsExtensionSupported(extension)) {
print_error("The specified model file extension is currently "
"unsupported in Assimp " ASSIMP_VERSION ".");
return EXIT_FAILURE;
}
stream = aiGetPredefinedLogStream(aiDefaultLogStream_STDOUT,NULL);
aiAttachLogStream(&stream);
stream = aiGetPredefinedLogStream(aiDefaultLogStream_FILE,"assimp_log.txt");
aiAttachLogStream(&stream);
// Load the model file.
if(0 != loadasset(model_file)) {
print_error("Failed to load model. Please ensure that the specified file exists.");
aiDetachAllLogStreams();
return EXIT_FAILURE;
}
// Print the model data.
recursive_render(scene, scene->mRootNode);
// Relese
aiReleaseImport(scene);
aiDetachAllLogStreams();
return EXIT_SUCCESS;
}
- 运行结果如下:
(1)加载gltf1.0的模型文件:Duck1.glb
(2)加载gltf2.0的模型文件:Avocado2.glb
7、gltflib (v2.0, python)
https://pypi.org/project/gltflib/
Library for parsing, creating, and converting glTF 2.0 files in Python 3.6+.
This library is intended for working with glTF 2.0 at a fairly low level, meaning you are responsible for managing the actual geometry data yourself. This library facilitates saving this data into a properly formatted glTF/GLB file. It also helps with converting resources inside a glTF/GLB file between external files or web URLs, data URLs, and embedded GLB resources.
pip install gltflib
7.1 Parsing a glTF 2.0 Model
from gltflib import GLTF
gltf = GLTF.load('D:/glTF-Sample-Models/2.0/BoxTextured/gltf/BoxTextured.gltf')
# print(gltf.model)
print(gltf.model.buffers[0].uri)
print(gltf.resources)
resource = gltf.resources[0]
print(resource)
7.2 Exporting a glTF 2.0 Model
import struct
import operator
from gltflib import (
GLTF, GLTFModel, Asset, Scene, Node, Mesh, Primitive, Attributes, Buffer, BufferView, Accessor, AccessorType,
BufferTarget, ComponentType, GLBResource, FileResource)
vertices = [
(-4774424.719997984, 4163079.2597148907, 671001.6353722484),
(-4748098.650098154, 4163079.259714891, 837217.8990777463),
(-4689289.5292739635, 4246272.966707474, 742710.4976137652)
]
vertex_bytearray = bytearray()
for vertex in vertices:
for value in vertex:
vertex_bytearray.extend(struct.pack('f', value))
bytelen = len(vertex_bytearray)
mins = [min([operator.itemgetter(i)(vertex) for vertex in vertices]) for i in range(3)]
maxs = [max([operator.itemgetter(i)(vertex) for vertex in vertices]) for i in range(3)]
model = GLTFModel(
asset=Asset(version='2.0'),
scenes=[Scene(nodes=[0])],
nodes=[Node(mesh=0)],
meshes=[Mesh(primitives=[Primitive(attributes=Attributes(POSITION=0))])],
buffers=[Buffer(byteLength=bytelen, uri='vertices.bin')],
bufferViews=[BufferView(buffer=0, byteOffset=0, byteLength=bytelen, target=BufferTarget.ARRAY_BUFFER.value)],
accessors=[Accessor(bufferView=0, byteOffset=0, componentType=ComponentType.FLOAT.value, count=len(vertices),
type=AccessorType.VEC3.value, min=mins, max=maxs)]
)
resource = FileResource('vertices.bin', data=vertex_bytearray)
gltf = GLTF(model=model, resources=[resource])
gltf.export('triangle.gltf')
# gltf.export('triangle.glb')
7.3 Converting Between glTF and GLB
from gltflib import GLTF
gltf = GLTF.load('D:/glTF-Sample-Models/2.0/BoxTextured/gltf/BoxTextured.gltf')
gltf.export('D:/BoxTextured.glb')
from gltflib import GLTF
gltf = GLTF.load('D:/glTF-Sample-Models/2.0/BoxTextured/glTF-Binary/BoxTextured.glb')
glb_resource = gltf.get_glb_resource()
gltf.convert_to_file_resource(glb_resource, 'BoxTextured.bin')
gltf.export('D:/BoxTextured.gltf')
相关测试代码见网址链接:
https://download.csdn.net/download/hhy321/85182743
8、three.js(v2.0, javascript)
8.1 下载和编译
https://github.com/mrdoob/three.js
下载GitHub代码:
git clone --depth=1 https://github.com/mrdoob/three.js.git
使用npm编译代码:
npm install
npm start
or
npm run dev
8.2 官网代码示意
- 代码1:
import * as THREE from 'three';
// init
const camera = new THREE.PerspectiveCamera( 70, window.innerWidth / window.innerHeight, 0.01, 10 );
camera.position.z = 1;
const scene = new THREE.Scene();
const geometry = new THREE.BoxGeometry( 0.2, 0.2, 0.2 );
const material = new THREE.MeshNormalMaterial();
const mesh = new THREE.Mesh( geometry, material );
scene.add( mesh );
const renderer = new THREE.WebGLRenderer( { antialias: true } );
renderer.setSize( window.innerWidth, window.innerHeight );
renderer.setAnimationLoop( animation );
document.body.appendChild( renderer.domElement );
// animation
function animation( time ) {
mesh.rotation.x = time / 2000;
mesh.rotation.y = time / 1000;
renderer.render( scene, camera );
}
- 代码2:
<script type="module">
import * as THREE from 'three';
import Stats from './jsm/libs/stats.module.js';
import { GUI } from './jsm/libs/lil-gui.module.min.js';
import { GLTFLoader } from './jsm/loaders/GLTFLoader.js';
import { GPUComputationRenderer } from './jsm/misc/GPUComputationRenderer.js';
/* TEXTURE WIDTH FOR SIMULATION */
const WIDTH = 64;
const BIRDS = WIDTH * WIDTH;
/* BAKE ANIMATION INTO TEXTURE and CREATE GEOMETRY FROM BASE MODEL */
const BirdGeometry = new THREE.BufferGeometry();
let textureAnimation, durationAnimation, birdMesh, materialShader, indicesPerBird;
function nextPowerOf2( n ) {
return Math.pow( 2, Math.ceil( Math.log( n ) / Math.log( 2 ) ) );
}
Math.lerp = function ( value1, value2, amount ) {
amount = Math.max( Math.min( amount, 1 ), 0 );
return value1 + ( value2 - value1 ) * amount;
};
const gltfs = [ 'models/gltf/Parrot.glb', 'models/gltf/Flamingo.glb' ];
const colors = [ 0xccFFFF, 0xffdeff ];
const sizes = [ 0.2, 0.1 ];
const selectModel = Math.floor( Math.random() * gltfs.length );
new GLTFLoader().load( gltfs[ selectModel ], function ( gltf ) {
//.........
//.........
//.........
}
//.........
//.........
//.........
</script>
结语
如果您觉得该方法或代码有一点点用处,可以给作者点个赞,或打赏杯咖啡;
╮( ̄▽ ̄)╭如果您感觉方法或代码不咋地
//(ㄒoㄒ)//,就在评论处留言,作者继续改进;
o_O???如果您需要相关功能的代码定制化开发,可以留言私信作者;
(✿◡‿◡)感谢各位童鞋们的支持!
( ´ ▽´ )ノ ( ´ ▽´)っ!!!文章来源:https://www.toymoban.com/news/detail-400839.html
文章来源地址https://www.toymoban.com/news/detail-400839.html
到了这里,关于【CAD开发】glTF和b3dm文件格式读取(C++,Python)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!