cgltf

? CGLTF

Carregador e escritor GLTF de estilo único/Stb

Usado em: BGFX, Filamento, Gltfpack, Raylib, Unigine e muito mais!

Uso: Carregando

Carregando do arquivo:

 #define CGLTF_IMPLEMENTATION
#include "cgltf.h"

cgltf_options options = { 0 };
cgltf_data * data = NULL ;
cgltf_result result = cgltf_parse_file ( & options , "scene.gltf" , & data );
if ( result == cgltf_result_success )
{
	/* TODO make awesome stuff */
	cgltf_free ( data );
}

Carregando da memória:

 #define CGLTF_IMPLEMENTATION
#include "cgltf.h"

void * buf ; /* Pointer to glb or gltf file data */
size_t size ; /* Size of the file data */

cgltf_options options = { 0 };
cgltf_data * data = NULL ;
cgltf_result result = cgltf_parse ( & options , buf , size , & data );
if ( result == cgltf_result_success )
{
	/* TODO make awesome stuff */
	cgltf_free ( data );
}

Observe que o CGLTF não carrega o conteúdo de arquivos extras, como buffers ou imagens na memória por padrão. Você precisará ler esses arquivos usando URIs de data.buffers[] ou data.images[] respectivamente. Para dados do buffer, você pode ligar para cgltf_load_buffers , que usará FILE* APIs para abrir e ler arquivos buffer. Isso decodifica automaticamente URIs de dados BASE64 em buffers. Para URIs de dados nas imagens, você precisará usar cgltf_load_buffer_base64 .

Para uma documentação mais aprofundada e uma descrição da interface pública, consulte a parte superior do arquivo cgltf.h .

Uso: escrevendo

Ao escrever dados GLTF, você precisa de uma estrutura cgltf_data válida que represente um documento GLTF válido. Você pode construir essa estrutura ou carregá -la usando as funções do carregador descritas acima. As funções do escritor não negociam nenhuma memória. Portanto, você precisa fazê -lo manualmente ou ligar para cgltf_free() se você obteve os dados carregando -os de um documento GLTF.

Escrevendo para arquivar:

 #define CGLTF_IMPLEMENTATION
#define CGLTF_WRITE_IMPLEMENTATION
#include "cgltf_write.h"

cgltf_options options = { 0 };
cgltf_data * data = /* TODO must be valid data */ ;
cgltf_result result = cgltf_write_file ( & options , "out.gltf" , data );
if ( result != cgltf_result_success )
{
	/* TODO handle error */
}

Escrevendo para a memória:

 #define CGLTF_IMPLEMENTATION
#define CGLTF_WRITE_IMPLEMENTATION
#include "cgltf_write.h"
cgltf_options options = { 0 };
cgltf_data * data = /* TODO must be valid data */ ;

cgltf_size size = cgltf_write ( & options , NULL , 0 , data );

char * buf = malloc ( size );

cgltf_size written = cgltf_write ( & options , buf , size , data );
if ( written != size )
{
	/* TODO handle error */
}

Observe que o CGLTF não escreve o conteúdo de arquivos extras, como buffers ou imagens. Você precisará escrever esses dados.

Para uma documentação mais aprofundada e uma descrição da interface pública, consulte a parte superior do arquivo cgltf_write.h .

Características

CGLTF suporta o núcleo GLTF 2.0:

• GLB (arquivos binários) e GLTF (arquivos JSON)
• malhas (incluindo acessores, vistas de buffer, buffers)
• Materiais (incluindo texturas, amostradores, imagens)
• cenas e nós
• peles
• animações
• câmeras
• Morph alvos
• dados extras

O CGLTF também suporta algumas extensões GLTF:

• Ext_mesh_gpu_instancing
• Ext_Meshopt_Compression
• Ext_texture_webp
• KHR_DRACO_MESH_COMPRESSO (requer uma biblioteca como o Draco para a descompressão do Google)
• Khr_lights_punctual
• Khr_materials_anisotropy
• Khr_materials_clearcoat
• Khr_materials_dispersion
• Khr_materials_emissive_strength
• Khr_materials_ior
• Khr_materials_iridescence
• Khr_materials_pbrspecularGlossiness
• Khr_materials_sheen
• Khr_materials_specular
• Khr_materials_transmission
• Khr_materials_unlit
• Khr_materials_variants
• Khr_materials_volume
• KHR_TEXTURE_BASISU (requer uma biblioteca como o Bas Basé binomial para a transcodificação para a textura compactada nativa)
• Khr_texture_transform

O CGLTF ainda não suporta extensões não listadas. No entanto, extensões não listadas podem ser acessadas via membro "Extensões" em objetos.

Prédio

A abordagem mais fácil é integrar o arquivo de cabeçalho cgltf.h em seu projeto. Se você não está familiarizado com as bibliotecas de arquivo C único (também conhecidas como bibliotecas no estilo STB), é assim que se passa:

1. Inclua cgltf.h onde você precisa da funcionalidade.
2. Tenha exatamente um arquivo de origem que define CGLTF_IMPLEMENTATION Antes de incluir cgltf.h .
3. Use as funções CGLTF conforme descrito acima.

O suporte à escrita pode ser encontrado em um arquivo separado chamado cgltf_write.h (que inclui cgltf.h ). Construir funciona analogamente usando o CGLTF_WRITE_IMPLEMENTATION define.

Contribuindo

Todos podem contribuir para a biblioteca. Se você encontrar algum problema, poderá enviá -los usando o sistema de problemas do Github. Se você deseja contribuir com o código, bifurque o projeto e envie uma solicitação de tração.

Dependências

Nenhum.

C Cabeçalhos sendo usados ​​pela implementação:

 #include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>
#include <assert.h> // If asserts are enabled.

Observe que esta biblioteca possui uma cópia do analisador JSMN JSON incorporado em sua fonte.

Teste

Há um script python na pasta test/ que recupera os arquivos de amostra GLTF 2.0 do repositório GLTF-Sample-Models (https://github.com/khronosgroup/GLTF-Sample-Models/Tree/Master/2.0) e executa a biblioteca contra todos os arquivos GLTF e GLB.

Aqui está uma maneira de construir e executar o teste:

 cd test ; mkdir build ; cd build ; cmake .. -DCMAKE_BUILD_TYPE=Debug
make -j
cd ..
./test_all.py

Há também um teste LLVM-FUZZ no fuzz/ . Consulte http://llvm.org/docs/libfuzzer.html para obter mais informações.