8#include "../vrml_parser/Structs.h"
9#include "../vrml_parser/CRoutes.h"
10#include "../main/headers.h"
12#include "../input/EAIHeaders.h"
13#include "../input/EAIHelpers.h"
14#include "../opengl/Frustum.h"
15#include "../opengl/OpenGL_Utils.h"
16#include "../opengl/Textures.h"
18#include "Component_Networking.h"
20#include "../scenegraph/RenderFuncs.h"
22#include <libFreeWRL.h>
25#include "quaternion.h"
45#define CGLTF_IMPLEMENTATION 1
65void *gltf_loader_constructor(){
70void gltf_loader_init(
struct tgltf_loader *t){
73 t->prv = gltf_loader_constructor();
75 ppgltf_loader p = (ppgltf_loader)t->prv;
76 p->gltf_units = newStack(
struct gltf_unit*);
79void gltf_loader_clear(
struct tgltf_loader *t){
83 ppgltf_loader p = (ppgltf_loader)t->prv;
86 deleteStack(
struct gltf_unit*,p->gltf_units);
97static Stack *defs = NULL;
98struct X3D_Node *USE_node(
char *name,
int nodeclass){
100 if(!defs) defs = newStack(
struct name_node);
102 for(
int i=0;i<defs->n;i++){
103 nn = vector_get(
struct name_node,defs,i);
104 if(!strcmp(name,nn.name) && nodeclass == nn.nodeclass){
112 if(!defs) defs = newStack(
struct name_node);
114 struct X3D_Node *node = createNewX3DNode(nodetype);
115 add_node_to_broto_context(X3D_PROTO(ectx),X3D_NODE(node));
118 nn.nodeclass = getSAI_X3DNodeType(nodetype);
127void* set_MeshRep(
void* _meshrep) {
144#include "Component_Shape.h"
145void saveArraysForGPU(
int mode,
int first,
int count);
146void reallyDrawOnce();
147void render_MeshRep(
void* _meshrep) {
149 s_shader_capabilities_t* me = NULL;
153 if (!gb || gb->VBO < 1)
return;
156 glBindBuffer(GL_ARRAY_BUFFER, gb->VBO);
157 struct bufAccess* ba = &meshrep->attrib[0];
158 FW_GL_VERTEX_POINTER(ba->dataSize, ba->dataType, ba->byteStride, (GLfloat*)BUFFER_OFFSET(ba->byteOffset));
162 ba = &meshrep->attrib[1];
164 FW_GL_COLOR_POINTER(ba->dataSize, ba->dataType, ba->byteStride, (GLfloat*)BUFFER_OFFSET(ba->byteOffset));
168 ba = &meshrep->attrib[2];
170 FW_GL_FOG_POINTER(ba->dataType, ba->byteStride, (GLfloat*)BUFFER_OFFSET(ba->byteOffset));
173 ba = &meshrep->attrib[3];
175 FW_GL_NORMAL_POINTER(ba->dataType, ba->byteStride, (GLfloat*)BUFFER_OFFSET(ba->byteOffset));
182 for (
int j = 0; j < 4; j++) {
183 ba = &meshrep->attrib[4 + j];
187 FW_GL_TEXCOORD_POINTER(ba->dataSize, ba->dataType, ba->byteStride, (GLfloat*)BUFFER_OFFSET(ba->byteOffset), j);
190 me = getAppearanceProperties()->currentShaderProperties;
191 glUniform1i(me->nTexCoordChannels, kuv);
192 glUniform1i(me->flipuv, meshrep->flipuv);
196 ba = &meshrep->index;
200 char* indices = meshrep->buffer->address + ba->byteOffset;
203 saveElementsForGPU0(GL_TRIANGLES, meshrep->nindex, ba->dataType, indices);
206 saveArraysForGPU(GL_TRIANGLES, 0, meshrep->ncoord);
215 for (
int i = 0; i < meshrep->ncoord; i++) {
217 for (
int k = 0; k < 8; k++) {
218 ba = &meshrep->attrib[k];
220 paddress = get_Attribi(ba, gb, i);;
221 float* ai = (
float*)paddress;
223 for (
int j = 0; j < ba->dataSize; j++)
224 printf(
"%f ", ai[j]);
233void rendray_MeshRep(
void* _meshrep) {
236 if (!mr->ncoord)
return;
239 if (!gb || gb->loaded < 2)
return;
251 float v1len, v2len, v3len;
257 get_current_ray(&t_r1, &t_r2);
261 int ntri = mr->ncoord / 3;
262 if (mr->index.in_use) {
264 ntri = mr->nindex / 3;
265 for (
int i = 0, j=0; i < ntri; i++) {
266 if (mr->index.in_use) {
267 for (
int k = 0; k < 3; k++) {
268 paddress = get_Attribi(bai, gb, i * 3 + k);
270 if (bai->dataType == GL_UNSIGNED_BYTE) {
271 unsigned char* ip = (
unsigned char*)paddress;
274 else if (bai->dataType == GL_UNSIGNED_SHORT) {
275 unsigned short* ip = (
unsigned short*)paddress;
278 }
else if (bai->dataType == GL_SHORT) {
279 short* ip = (
short*)paddress;
283 int* ip = (
int*)paddress;
290 for (
int k = 0; k < 3; k++)
291 cindex[k] = i * 3 + k;
294 for (
int k = 0; k < 3; k++) {
295 paddress = get_Attribi(ba, gb, cindex[k]);
296 veccopy3f(point[k], (
float*)paddress);
311 v1.x = point[1][0] - point[0][0];
312 v1.y = point[1][1] - point[0][1];
313 v1.z = point[1][2] - point[0][2];
314 v2.x = point[2][0] - point[0][0];
315 v2.y = point[2][1] - point[0][1];
316 v2.z = point[2][2] - point[0][2];
317 v1len = (float)sqrt(VECSQ(v1)); VECSCALE(v1, 1 / v1len);
318 v2len = (float)sqrt(VECSQ(v2)); VECSCALE(v2, 1 / v2len);
319 v12pt = (float)VECPT(v1, v2);
322 if (fabs(v12pt - 1.0) < 0.00001)
continue;
325 if ((fabs(v1len) > 0.00001) && (fabs(v2len) > 0.00001)) {
329 v3len = (float)sqrt(VECSQ(v3)); VECSCALE(v3, 1 / v3len);
330 pt1 = (float)VECPT(t_r1, v3);
331 pt2 = (float)VECPT(t_r2, v3);
332 pt3 = (float)(v3.x * point[0][0] + v3.y * point[0][1] + v3.z * point[0][2]);
337 if (!APPROX(tmp1, 0)) {
342 tmp2 = (float)((pt1 - pt3) / (pt1 - pt2));
343 hitpoint.x = MRATX(tmp2);
344 hitpoint.y = MRATY(tmp2);
345 hitpoint.z = MRATZ(tmp2);
348 p0h.x = hitpoint.x - point[0][0];
349 p0h.y = hitpoint.y - point[0][1];
350 p0h.z = hitpoint.z - point[0][2];
351 ra = (float)VECPT(v1, p0h);
352 if (ra < 0.0f) {
continue; }
353 rb = (float)VECPT(v2, p0h);
354 if (rb < 0.0f) {
continue; }
363 k = (ra - v12pt * rb) / (1 - v12pt * v12pt);
364 l = (rb - v12pt * ra) / (1 - v12pt * v12pt);
365 k /= v1len; l /= v2len;
366 if (k + l > 1 || k < 0 || l < 0) {
369 rayhit(((
float)(tmp2)),
370 ((
float)(hitpoint.x)),
371 ((
float)(hitpoint.y)),
372 ((
float)(hitpoint.z)),
376 ((
float)-1), ((
float)-1),
"polyrep");
386void delete_MeshRep(
void* meshrep) {
390 subtract_geomBufferUser(mr->buffer);
394 struct geomBuffer* buffer = find_buffer_in_broto_context_from_cgltf_buffer(ectx, bv->buffer);
397 buffer = add_geomBuffer0(ectx, bv->buffer->size, 1);
398 buffer->cgltf_buffer = (
char*)bv->buffer;
399 if (bv->buffer->data) {
400 memcpy(buffer->address, bv->buffer->data, bv->buffer->size);
402 buffer->cgltf_buffer = (
char*)bv->buffer;
406 add_geomBufferUser(buffer);
412 char* iname = texture->image->name;
413 struct X3D_Node* image = USE_node(iname, X3DTextureNode);
415 if (texture->image->buffer_view) {
416 image = DEF_node(ectx, iname, NODE_BufferTexture);
418 tr->buffer = find_or_create_buffer_add_user(ectx, texture->image->buffer_view);
419 tr->byteOffset = texture->image->buffer_view->offset;
420 tr->byteSize = texture->image->buffer_view->size;
421 image->_intern = (
void*)tr;
424 char* iuri = texture->image->uri;
425 image = DEF_node(ectx, iname, NODE_ImageTexture);
427 it->url.p = malloc(
sizeof(
void*));
428 it->url.p[0] = newASCIIString(iuri);
438 veccopy2f(ttrans->translation.c, ctexture.transform.offset);
439 ttrans->translation.c[1] = (1.0f - ttrans->translation.c[1])* ctexture.transform.scale[1];
440 ttrans->rotation = ctexture.transform.rotation;
441 veccopy2f(ttrans->scale.c, ctexture.transform.scale);
442 sprintf(scratch,
"%d", ntextrans);
443 ttrans->mapping = newASCIIString(scratch);
451 mtrans->textureTransform.n = ntextrans;
452 for (
int k = 0; k < ntextrans; k++)
453 mtrans->textureTransform.p[k] = X3D_NODE(textrans[k]);
454 appear->textureTransform = X3D_NODE(mtrans);
457 appear->textureTransform = X3D_NODE(textrans[0]);
461 char scratch[20], ctemp[10];
464 if (ctexture.texcoord > -1) {
465 sprintf(ctemp,
"C%1d", ctexture.texcoord);
466 strcat(scratch, ctemp);
468 if (ctexture.has_transform) {
469 sprintf(ctemp,
"T%1d", itextrans);
470 strcat(scratch, ctemp);
472 return newASCIIString(scratch);
482 struct Vector* pp = &vector;
483 memset(pp, 0,
sizeof(
struct Vector));
489 viewpoint = (
struct X3D_Node*)USE_node(camera->name, X3DBindableNode);
491 if (camera->type == cgltf_camera_type_perspective) {
494 vp->fieldOfView = perspective.yfov;
495 vp->aspectRatio = perspective.aspect_ratio > 0.0f ? perspective.aspect_ratio : .75;
496 vp->farClippingPlane = perspective.zfar;
497 vp->nearClippingPlane = perspective.znear;
498 vp->description = newASCIIString(camera->name);
499 vecset3f(vp->position.c, 0.0f, 0.0f, 0.0f);
501 viewpoint = X3D_NODE(vp);
504 else if (camera->type == cgltf_camera_type_orthographic) {
507 vp->fieldOfView.p[0] *= ortho.xmag;
508 vp->fieldOfView.p[1] *= ortho.ymag;
509 vp->fieldOfView.p[2] *= ortho.xmag;
510 vp->fieldOfView.p[3] *= ortho.ymag;
511 vp->farClippingPlane = ortho.zfar;
512 vp->nearClippingPlane = ortho.znear;
513 vp->description = newASCIIString(camera->name);
514 vecset3f(vp->position.c, 0.0f, 0.0f, 0.0f);
516 viewpoint = X3D_NODE(vp);
522 vector_pushBack(
struct X3D_Node*, pp, viewpoint);
539 light = (
struct X3D_Node*)USE_node(plight->name, X3DLightNode);
541 if (node->light->type > cgltf_light_type_invalid) {
551 switch (node->light->type) {
552 case cgltf_light_type_directional:
555 veccopy3f(dl->color.c, plight->color);
556 dl->intensity = plight->intensity;
557 light = X3D_NODE(dl);
560 case cgltf_light_type_point:
563 veccopy3f(pl->color.c, plight->color);
564 pl->intensity = plight->intensity;
565 pl->radius = plight->range;
566 light = X3D_NODE(pl);
569 case cgltf_light_type_spot:
572 veccopy3f(sl->color.c, plight->color);
573 sl->intensity = plight->intensity;
574 sl->radius = plight->range;
575 sl->beamWidth = plight->spot_inner_cone_angle;
576 sl->cutOffAngle = plight->spot_outer_cone_angle;
577 light = X3D_NODE(sl);
585 vector_pushBack(
struct X3D_Node*, pp, light);
594 struct X3D_Group* gr = (
struct X3D_Group*)USE_node(node->mesh->name, X3DGroupingNode);
596 gr = (
struct X3D_Group*) DEF_node(ectx,node->mesh->name,NODE_Group);
597 int do_mapping = FALSE;
599 for(
int j=0;j<node->mesh->primitives_count;j++){
629 if(prim->material->unlit){
630 int mtype = NODE_UnlitMaterial;
635 veccopy3f(mat->emissiveColor.c,prim->material->emissive_factor);
637 if (prim->material->emissive_texture.texture) {
638 if (prim->material->emissive_texture.texture) {
639 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->emissive_texture.texture);
660 mat->emissiveTexture = image;
661 mat->emissiveTextureMapping = set_mat_mapping(prim->material->emissive_texture, ntextrans);
662 if (prim->material->emissive_texture.has_transform) {
663 textrans[ntextrans++] = add_texture_transform(prim->material->emissive_texture, ntextrans);
668 sn->appearance = createNewX3DNode(NODE_Appearance);
670 save_texture_transforms(sn->appearance, ntextrans, textrans);
672 X3D_APPEARANCE(sn->appearance)->material = X3D_NODE(mat);
673 }
else if(prim->material->has_pbr_metallic_roughness){
674 int mtype = NODE_PhysicalMaterial;
693 veccopy3f(mat->emissiveColor.c,prim->material->emissive_factor);
694 veccopy3f(mat->baseColor.c,pbr->base_color_factor);
695 mat->transparency = 1.0f - pbr->base_color_factor[3];
696 mat->metallic = pbr->metallic_factor;
697 mat->roughness = pbr->roughness_factor;
698 if(pbr->base_color_texture.texture ){
699 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, pbr->base_color_texture.texture);
700 mat->baseTexture = image;
702 mat->baseTextureMapping = set_mat_mapping(pbr->base_color_texture, ntextrans);
703 if (pbr->base_color_texture.has_transform) {
704 textrans[ntextrans++] = add_texture_transform(pbr->base_color_texture, ntextrans);
707 if (pbr->metallic_roughness_texture.texture ) {
708 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, pbr->metallic_roughness_texture.texture);
709 mat->metallicRoughnessTexture = image;
711 mat->metallicRoughnessTextureMapping = set_mat_mapping(pbr->metallic_roughness_texture, ntextrans);
712 if (pbr->metallic_roughness_texture.has_transform) {
713 textrans[ntextrans++] = add_texture_transform(pbr->metallic_roughness_texture, ntextrans);
716 if (prim->material->emissive_texture.texture ) {
717 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->emissive_texture.texture);
718 mat->emissiveTexture = image;
720 mat->emissiveTextureMapping = set_mat_mapping(prim->material->emissive_texture, ntextrans);
721 if (prim->material->emissive_texture.has_transform) {
722 textrans[ntextrans++] = add_texture_transform(prim->material->emissive_texture, ntextrans);
725 if (prim->material->normal_texture.texture ) {
726 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->normal_texture.texture);
727 mat->normalTexture = image;
729 mat->normalTextureMapping = set_mat_mapping(prim->material->normal_texture, ntextrans);
730 if (prim->material->normal_texture.has_transform) {
731 textrans[ntextrans++] = add_texture_transform(prim->material->normal_texture, ntextrans);
734 if (prim->material->occlusion_texture.texture) {
735 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->occlusion_texture.texture);
736 mat->occlusionTexture = image;
738 mat->occlusionTextureMapping = set_mat_mapping(prim->material->occlusion_texture, ntextrans);
739 if (prim->material->occlusion_texture.has_transform) {
740 textrans[ntextrans++] = add_texture_transform(prim->material->occlusion_texture, ntextrans);
744 sn->appearance = createNewX3DNode(NODE_Appearance);
746 save_texture_transforms(sn->appearance, ntextrans, textrans);
748 X3D_APPEARANCE(sn->appearance)->material = X3D_NODE(mat);
749 }
else if(prim->material->has_pbr_specular_glossiness){
750 int mtype = NODE_Material;
765 mat = (
struct X3D_Material*) DEF_node(ectx,prim->material->name,mtype);
767 veccopy3f(mat->emissiveColor.c,prim->material->emissive_factor);
768 veccopy3f(mat->diffuseColor.c,pbr->diffuse_factor);
769 veccopy3f(mat->specularColor.c,pbr->specular_factor);
770 mat->shininess = pbr->glossiness_factor;
771 mat->transparency = 1.0f - pbr->diffuse_factor[3];
773 if (pbr->specular_glossiness_texture.texture) {
774 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, pbr->specular_glossiness_texture.texture);
775 mat->specularTexture = image;
776 mat->shininessTexture = image;
779 mat->specularTextureMapping = set_mat_mapping(pbr->specular_glossiness_texture, ntextrans);
780 mat->shininessTextureMapping = set_mat_mapping(pbr->specular_glossiness_texture, ntextrans);
781 if (pbr->specular_glossiness_texture.has_transform) {
782 textrans[ntextrans++] = add_texture_transform(pbr->specular_glossiness_texture, ntextrans);
787 if (pbr->diffuse_texture.texture) {
788 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, pbr->diffuse_texture.texture);
789 mat->diffuseTexture = image;
791 mat->diffuseTextureMapping = set_mat_mapping(pbr->diffuse_texture, ntextrans);
792 if (pbr->diffuse_texture.has_transform) {
793 textrans[ntextrans++] = add_texture_transform(pbr->diffuse_texture, ntextrans);
797 if (prim->material->emissive_texture.texture) {
798 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->emissive_texture.texture);
799 mat->emissiveTexture = image;
801 mat->emissiveTextureMapping = set_mat_mapping(prim->material->emissive_texture, ntextrans);
802 if (prim->material->emissive_texture.has_transform) {
803 textrans[ntextrans++] = add_texture_transform(prim->material->emissive_texture, ntextrans);
807 if (prim->material->normal_texture.texture) {
808 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->normal_texture.texture);
809 mat->normalTexture = image;
811 mat->normalTextureMapping = set_mat_mapping(prim->material->normal_texture, ntextrans);
812 if (prim->material->normal_texture.has_transform) {
813 textrans[ntextrans++] = add_texture_transform(prim->material->normal_texture, ntextrans);
817 if (prim->material->occlusion_texture.texture) {
818 struct X3D_Node* image = x3dtexture_from_cgltf_texture(ectx, prim->material->occlusion_texture.texture);
819 mat->occlusionTexture = image;
821 mat->occlusionTextureMapping = set_mat_mapping(prim->material->occlusion_texture, ntextrans);
822 if (prim->material->occlusion_texture.has_transform) {
823 textrans[ntextrans++] = add_texture_transform(prim->material->occlusion_texture, ntextrans);
827 sn->appearance = createNewX3DNode(NODE_Appearance);
829 save_texture_transforms(sn->appearance, ntextrans, textrans);
831 X3D_APPEARANCE(sn->appearance)->material = X3D_NODE(mat);
839 case cgltf_primitive_type_points:
840 case cgltf_primitive_type_lines:
841 case cgltf_primitive_type_line_loop:
842 case cgltf_primitive_type_line_strip:
844 case cgltf_primitive_type_triangles:
846 cgltf_float element_float[16];
847 int acount = prim->attributes_count;
850 printf(
"triangles\n");
851 for(
int ii=0;ii<acount;ii++){
852 printf(
"attr %s indx %d ",prim->attributes[ii].name,prim->attributes[ii].index);
853 switch(prim->attributes[ii].type){
854 case cgltf_attribute_type_invalid: printf(
"invalid");
break;
855 case cgltf_attribute_type_position: printf(
"position");
break;
856 case cgltf_attribute_type_normal: printf(
"normal");
break;
857 case cgltf_attribute_type_tangent: printf(
"tangent");
break;
858 case cgltf_attribute_type_texcoord: printf(
"texcoord");
break;
859 case cgltf_attribute_type_color: printf(
"color");
break;
860 case cgltf_attribute_type_joints: printf(
"joints");
break;
861 case cgltf_attribute_type_weights: printf(
"weights");
break;
866 cgltf_size nfloats = cgltf_num_components(blob->type) * blob->count;
867 printf(
" nfloats = %d accessor type %d count %d ",(
int)nfloats,blob->type, (
int)blob->count);
869 case cgltf_type_scalar: printf(
"SCALAR");
break;
870 case cgltf_type_vec2: printf(
"VEC2");
break;
871 case cgltf_type_vec3: printf(
"VEC3");
break;
875 cgltf_float element_float[16];
876 for (cgltf_size index = 0; index < blob->count; index++)
878 cgltf_accessor_read_float(blob, index, element_float, 16);
879 printf(
"%d %f %f %f\n",(
int)index,element_float[0],element_float[1],element_float[2]);
885 cgltf_uint element_int;
886 printf(
"triangle indices\n");
887 int ntri = blob->count / 3;
888 for (
int i = 0; i < ntri; i++)
891 for(
int j=0;j<3;j++){
893 cgltf_accessor_read_uint(blob, index, &element_int, 1);
894 printf(
"%d ",element_int);
900 gn = createNewX3DNode(NODE_BufferGeometry);
901 add_node_to_broto_context(X3D_PROTO(ectx),X3D_NODE(gn));
904 int lookup_attrib_index[] = {
917 int lookup_GL_type[] = {
928 mr = set_MeshRep(NULL);
932 acount = prim->attributes_count;
933 for (
int ii = 0; ii < acount; ii++) {
935 int iat = lookup_attrib_index[prim->attributes[ii].type];
936 if (iat < 0)
continue;
939 mr->ncoord = blob->count;
961 mr->buffer = find_or_create_buffer_add_user(ectx, blob->buffer_view);
963 ba->byteOffset = blob->buffer_view->offset;
964 ba->dataSize = cgltf_num_components(blob->type);
965 ba->dataType = lookup_GL_type[blob->component_type];
966 ba->byteStride = blob->stride;
967 ba->byteSize = ba->dataSize * lookup_dataType_size(ba->dataType);
974 ba->byteOffset = blob->buffer_view->offset;
975 ba->dataSize = cgltf_num_components(blob->type);
976 ba->dataType = lookup_GL_type[blob->component_type];
977 ba->byteStride = blob->stride;
978 ba->byteSize = ba->dataSize * lookup_dataType_size(ba->dataType);
980 mr->nindex = blob->count;
982 if (prim->attributes->data->has_max && prim->attributes->data->has_min) {
983 float *emin = prim->attributes->data->min;
984 float* emax = prim->attributes->data->max;
985 extent6f_constructor(ts->_extent, emin[0], emin[1], emin[2], emax[0], emax[1], emax[2]);
989 case cgltf_primitive_type_triangle_strip:
993 printf(
"triangle strip\n");
995 case cgltf_primitive_type_triangle_fan:
996 printf(
"triangle fan\n");
1001 AddRemoveChildren(X3D_NODE(gr), offsetPointer_deref(
void*, gr, offsetof(
struct X3D_Group, children)), (
struct X3D_Node * *)(X3D_NODE(sn)), 1, 1, __FILE__, __LINE__);
1005 vector_pushBack(
void *, pp, gr);
1010 if(node->weights_count){
1012 size_t estart = node->extras.start_offset;
1013 size_t eend = node->extras.end_offset;
1015 int mc = node->children_count;
1019 for(
int i=0;i<mc;i++){
1020 if (parse_gltf_node(ectx, &pn, data, node->children[i], unit)) {
1021 vector_pushBack(
struct X3D_Node*, pp, pn);
1026 int got_something = FALSE;
1030 if (node->has_matrix) {
1033 printf(
"gltf_loader not parsing matrix yet\n");
1036 vecset3f(t->translation.c, 0.0f, 0.0f, 0.0f);
1037 vecset3f(t->scale.c, 1.0f, 1.0f, 1.0f);
1038 vecset4f(t->rotation.c, 0.0f, 1.0f, 0.0f, 0.0f);
1039 if (node->has_rotation ) {
1040 float* r = t->rotation.c;
1043 q.x = node->rotation[0];
1044 q.y = node->rotation[1];
1045 q.z = node->rotation[2];
1046 q.w = node->rotation[3];
1047 quaternion_normalize(&q);
1048 quaternion_to_vrmlrot(&q, &rd[0], &rd[1], &rd[2], &rd[3]);
1049 double2float(r, rd, 4);
1052 if (node->has_scale ) {
1053 veccopy3f(t->scale.c, node->scale);
1056 if (node->has_translation ) {
1057 veccopy3f(t->translation.c, node->translation);
1060 t->children.n = pp->n;
1061 t->children.p = pp->data;
1063 printf(
"translation %f %f %f\n", t->translation.c[0], t->translation.c[1], t->translation.c[2]);
1064 printf(
"scale %f %f %f\n", t->scale.c[0], t->scale.c[1], t->scale.c[2]);
1065 printf(
"rotation %f %f %f %f\n", t->rotation.c[0], t->rotation.c[1], t->rotation.c[2], t->rotation.c[3]);
1066 printf(
"number of children %d\n", t->children.n);
1067 for (
int k = 0; k < t->children.n; k++)
1068 printf(
" %d %s\n", k, stringNodeType(t->children.p[k]->_nodeType));
1070 for (
int i = 0; i < t->children.n; ++i) {
1071 ADD_PARENT(t->children.p[i], X3D_NODE(t));
1073 add_node_to_broto_context(X3D_PROTO(ectx), X3D_NODE(t));
1075 *spot = X3D_NODE(t);
1076 got_something = TRUE;
1078 return got_something;
1082 int n = data->scene[0].nodes_count;
1083 spot->p = realloc(spot->p, n *
sizeof(
struct X3D_Node *));
1085 for(
int i=0;i<data->scene[0].nodes_count;i++){
1086 if( parse_gltf_node(ectx,&spot->p[n],data,data->scene[0].nodes[i], unit) ) n++;
1102 if (options == NULL)
1104 return cgltf_result_invalid_options;
1107 if (data->buffers_count && data->buffers[0].data == NULL && data->buffers[0].uri == NULL && data->bin)
1109 if (data->bin_size < data->buffers[0].size)
1111 return cgltf_result_data_too_short;
1114 data->buffers[0].data = (
void*)data->bin;
1117 for (cgltf_size i = 0; i < data->buffers_count; ++i)
1119 if (data->buffers[i].data)
1124 const char* uri = data->buffers[i].uri;
1131 if (strncmp(uri,
"data:", 5) == 0)
1133 const char* comma = strchr(uri,
',');
1135 if (comma && comma - uri >= 7 && strncmp(comma - 7,
";base64", 7) == 0)
1137 cgltf_result res = cgltf_load_buffer_base64(options, data->buffers[i].size, comma + 1, &data->buffers[i].data);
1139 if (res != cgltf_result_success)
1146 return cgltf_result_unknown_format;
1149 else if (strstr(uri,
"://") == NULL )
1153 ud.cdata = &data->buffers[i];
1154 ud.data_size = data->buffers[i].size;
1155 stack_push(
struct uri_data,file_list,ud);
1159 return cgltf_result_unknown_format;
1163 return cgltf_result_success;
1168int parser_do_parse_gltf(
const char *input,
const int len,
struct X3D_Node *ectx,
struct X3D_Node *myParent)
1177 ppgltf_loader p = (ppgltf_loader)gglobal()->gltf_loader.prv;
1180 stack_push(
gltf_unit*,p->gltf_units,unit);
1182 unit->blob = malloc(len);
1183 unit->blob_len = len;
1184 memcpy(unit->blob,input,len);
1185 cgltf_result result = cgltf_parse( &options, (
void*) unit->blob, unit->blob_len, &data);
1187 if (result == cgltf_result_success)
1189 printf(
"gltf parsed into cgltf scene struct\n");
1193 Stack *file_list = newStack(
struct uri_data);
1194 result = cgltf_load_buffers_except_files(&options, data,file_list);
1196 if(result == cgltf_result_success && file_list->n == 0){
1197 unit->bin_loaded = TRUE;
1198 }
else if(result == cgltf_result_file_not_found){
1199 printf(
"gltf .bin file not found ... yet\n");
1201 }
else if(file_list->n){
1202 resource_item_t *res;
1203 struct X3D_Proto *context = X3D_PROTO(ectx);
1207 unit->bin_file_list = file_list;
1210 for (
int k = 0; k < nn; k++) {
1212 char* uri = ud->uri;
1213 res = resource_create_single(uri);
1215 res->media_type = resm_unknown;
1216 res->resm_specific = ud->cdata;
1217 resource_identify(context->_parentResource, res);
1218 res->actions = resa_download | resa_load | resa_process;
1219 resitem_enqueue(ml_new(res));
1224 if(myParent->_nodeType == NODE_Proto || myParent->_nodeType == NODE_Inline )
1225 spot = &((
struct X3D_Proto*)(myParent))->__children;
1227 spot = &((
struct X3D_Group*)(myParent))->children;
1228 spot->p = NULL; spot->n = 0;
1229 parse_gltf(ectx,spot,data,unit);
1230 for(
int j=0;j<spot->n;j++)
1231 ADD_PARENT(X3D_NODE(spot->p[j]), X3D_NODE(ectx));
1250int gltf_load_bin(resource_item_t *res){
1254 struct geomBuffer *gb = find_buffer_in_broto_context_from_cgltf_buffer(res->ectx, buffer);
1256 openned_file_t* of = res->openned_files;
1257 int len = of->fileDataSize;
1258 char* input = of->fileData;
1259 memcpy(gb->address, input, len);
1267bool parser_process_res_VRML_X3D(resource_item_t *res);
1269int parser_process_res_gltf(resource_item_t *res){
1274 int parsedOk = FALSE;
1275 switch(res->media_type){
1281 parsedOk = parser_process_res_VRML_X3D(res);
1289 parsedOk = gltf_load_bin(res);
1306float* extent6f_fromBufferAccess(
float* e6,
struct geomBuffer* gb,
struct bufAccess* ba,
int ncoord) {
1312 memset(point, 0, 3 *
sizeof(
float));
1313 for (
int i = 0; i < ncoord; i++) {
1314 paddress = get_Attribi(ba, gb, i);
1315 if (ba->dataType == GL_FLOAT) {
1316 fp = (
float*)paddress;
1317 for (
int j = 0; j < ba->dataSize; j++) {
1321 else if (ba->dataType == GL_DOUBLE) {
1322 dp = (
double*)paddress;
1323 double2float(point, dp, ba->dataSize);
1325 extent6f_union_vec3f(e6, point);
1338 if (mr->buffer->loaded == 1)
1339 set_geomBuffer(mr->buffer);
1340 if (mr->buffer->loaded == 2) {
1345 if (mr->attrib[0].in_use) {
1347 if (!extent6f_isSet(node->_extent)) {
1348 extent6f_fromBufferAccess(e6, mr->buffer, &mr->attrib[0], mr->ncoord);
1352 for (
int j = 0; j < 4; j++)
1353 if (mr->attrib[4 + j].in_use) nuv++;
1356 extent6f_printf(node->_extent);
1357 printf(
"cgltf min,max\n");
1358 extent6f_printf(e6);
1359 printf(
"compile_BufferGeometry extent\n");
1361 if(extent6f_isSet(e6))
1362 extent6f_copy(node->_extent, e6);
1370 COMPILE_IF_REQUIRED;
1371 setExtent(node->EXTENT_MAX_X, node->EXTENT_MIN_X, node->EXTENT_MAX_Y,
1372 node->EXTENT_MIN_Y, node->EXTENT_MAX_Z, node->EXTENT_MIN_Z,
1374 render_MeshRep(node->_intern);
1380 if (!(node->_intern)) {
1383 if (node->_ichange == 0)
return;
1385 rendray_MeshRep(node->_intern);