29#include <system_threads.h>
33#include <libFreeWRL.h>
42#include "../vrml_parser/Structs.h"
44#include "../vrml_parser/CParseGeneral.h"
45#include "../scenegraph/Vector.h"
46#include "../vrml_parser/CFieldDecls.h"
47#include "../world_script/JScript.h"
48#include "../world_script/CScripts.h"
49#include "../vrml_parser/CParseParser.h"
50#include "../vrml_parser/CParseLexer.h"
51#include "../vrml_parser/CParse.h"
53#include "../scenegraph/Collision.h"
54#include "../scenegraph/Component_KeyDevice.h"
55#include "../opengl/Frustum.h"
56#include "../opengl/OpenGL_Utils.h"
58#if defined(INCLUDE_NON_WEB3D_FORMATS)
59#include "../non_web3d_formats/ColladaParser.h"
62#if defined (INCLUDE_STL_FILES)
63#include "../input/convertSTL.h"
66#include "../scenegraph/quaternion.h"
67#include "../scenegraph/Viewer.h"
68#include "../input/SensInterps.h"
69#include "../x3d_parser/Bindable.h"
70#include "../input/InputFunctions.h"
72#include "../plugin/pluginUtils.h"
73#include "../plugin/PluginSocket.h"
75#include "../ui/common.h"
76#include "../opengl/OpenGL_Utils.h"
77#include "../opengl/Textures.h"
78#include "../opengl/LoadTextures.h"
87void embedEXTERNPROTO(
struct VRMLLexer *me,
char *myName,
char *buffer,
char *pound);
90char *EAI_Flag =
"From the EAI bootcamp of life ";
91char* PluginPath =
"/private/tmp";
95int _fw_browser_plugin = 0;
97uintptr_t _fw_instance = 0;
118static bool parser_do_parse_string(
const char *input,
const int len,
struct X3D_Node *ectx,
struct X3D_Node *nRn);
123 struct Vector *viewpointNodes;
125 struct Vector *backgroundNodes;
126 struct Vector *navigationNodes;
130 s_list_t *resource_list_to_parse;
131 s_list_t *frontend_list_to_get;
132 int frontend_gets_files;
139 int inputThreadParsing;
140 int haveParsedCParsed;
141 int frontend_res_count;
142#if defined (INCLUDE_STL_FILES)
144 float lastSTLScaling;
148void *ProdCon_constructor(){
149 void *v = MALLOCV(
sizeof(
struct pProdCon));
150 memset(v,0,
sizeof(
struct pProdCon));
153void ProdCon_init(
struct tProdCon *t)
159 t->setViewpointBindInRender = NULL;
160 t->setFogBindInRender = NULL;
161 t->setBackgroundBindInRender = NULL;
162 t->setNavigationBindInRender = NULL;
164 t->savedParser = NULL;
167 t->prv = ProdCon_constructor();
169 ppProdCon p = (ppProdCon)t->prv;
171 p->viewpointNodes = newVector(
struct X3D_Node *,8);
172 t->viewpointNodes = p->viewpointNodes;
173 p->fogNodes = newVector(
struct X3D_Node *, 2);
174 p->backgroundNodes = newVector(
struct X3D_Node *, 2);
175 p->navigationNodes = newVector(
struct X3D_Node *, 2);
181 p->resource_list_to_parse = NULL;
182 p->frontend_list_to_get = NULL;
184 p->frontend_gets_files = 2;
186 p->frontend_gets_files = 0;
193 p->inputThreadParsing=FALSE;
194 p->haveParsedCParsed = FALSE;
196 p->frontend_res_count = 0;
197#if defined (INCLUDE_STL_FILES)
199 p->lastSTLScaling = 0.1;
204void ProdCon_clear(
struct tProdCon *t){
207 ppProdCon p = (ppProdCon)t->prv;
208 deleteVector(
struct X3D_Node *, p->viewpointNodes);
209 deleteVector(
struct X3D_Node *, p->fogNodes);
210 deleteVector(
struct X3D_Node *, p->backgroundNodes);
211 deleteVector(
struct X3D_Node *, p->navigationNodes);
232#if defined (INCLUDE_STL_FILES)
234float fwl_getLastSTLScaling() {
235 ppProdCon p = (ppProdCon)gglobal()->ProdCon.prv;
236 if (p!=NULL)
return p->lastSTLScaling;
244int fwl_isInputThreadInitialized() {
247 return gglobal()->threads.ResourceThreadRunning;
251int fwl_isinputThreadParsing() {
252 ppProdCon p = (ppProdCon)gglobal()->ProdCon.prv;
253 return(p->inputThreadParsing);
256void dump_scene2(FILE *fp,
int level,
struct X3D_Node* node,
int recurse, Stack *DEFedNodes) ;
258int indexChildrenName(
struct X3D_Node *node){
261 switch(node->_nodeType){
263 index = FIELDNAMES_children;
266 index = FIELDNAMES_children;
269 index = FIELDNAMES_children;
272 index = FIELDNAMES_children;
275 index = FIELDNAMES___children;
278 index = FIELDNAMES___children;
281 index = FIELDNAMES_rootNode;
291 switch(node->_nodeType){
293 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Group,children));
296 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Transform,children));
299 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Switch,children));
302 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Billboard,children));
305 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Proto,__children));
308 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_Inline,__children));
311 childs = offsetPointer_deref(
void*, node, offsetof(
struct X3D_GeoLOD,rootNode));
316int offsetofChildren(
struct X3D_Node *node){
319 switch(node->_nodeType){
321 offs = offsetof(
struct X3D_Group,children);
334 offs = offsetof(
struct X3D_Proto,__children);
337 offs = offsetof(
struct X3D_Inline,__children);
349static bool parser_do_parse_string(
const char *input,
const int len,
struct X3D_Node *ectx,
struct X3D_Node *nRn)
353 ppProdCon p = (ppProdCon)gglobal()->ProdCon.prv;
356#if defined (INCLUDE_STL_FILES)
358 p->lastSTLScaling = 0.1;
364 inputFileType = determineFileType(input,len);
365 DEBUG_MSG(
"PARSE STRING, ft %d, fv %d.%d.%d\n",
366 inputFileType, inputFileVersion[0], inputFileVersion[1], inputFileVersion[2]);
367 kids = offsetofChildren(nRn);
369 switch (inputFileType) {
370 case IS_TYPE_XML_X3D:
373 ret = X3DParse(ectx, X3D_NODE(nRn), (
const char*)input);
378 ret = cParse(ectx, nRn, kids, (
const char*)input);
379 p->haveParsedCParsed = TRUE;
382 case IS_TYPE_VRML1: {
383 char *newData = STRDUP(
"#VRML V2.0 utf8\n\
384 Shape {appearance Appearance {material Material {diffuseColor 0.0 1.0 1.0}}\
386 string [\"This build\" \"is not made with\" \"VRML1 support\"]\
387 fontStyle FontStyle{\
388 justify [\"MIDDLE\",\"MIDDLE\"]\
399#if defined (INCLUDE_NON_WEB3D_FORMATS)
400 case IS_TYPE_COLLADA:
401 ConsoleMessage (
"Collada not supported yet");
402 ret = ColladaParse (nRn, (
const char*)input);
404 case IS_TYPE_SKETCHUP:
405 ConsoleMessage (
"Google Sketchup format not supported yet");
408 ConsoleMessage (
"KML-KMZ format not supported yet");
412#if defined (INCLUDE_STL_FILES)
413 case IS_TYPE_ASCII_STL: {
414 char *newData = convertAsciiSTL(input);
415 p->lastSTLScaling = getLastSTLScale();
419 ret = cParse (ectx,nRn,(
int) offsetof (
struct X3D_Group, children), newData);
423 case IS_TYPE_BINARY_STL: {
424 char *newData = convertBinarySTL((
const unsigned char *)input);
425 p->lastSTLScaling = getLastSTLScale();
427 ret = cParse (ectx,nRn,(
int) offsetof (
struct X3D_Group, children), newData);
434 if (gglobal()->internalc.global_strictParsing) {
435 ConsoleMessage(
"unknown text as input");
437 inputFileType = IS_TYPE_VRML;
438 inputFileVersion[0] = 2;
439 cParse (ectx,nRn,(
int) offsetof (
struct X3D_Proto, __children), (
const char*)input);
440 p->haveParsedCParsed = TRUE; }
446 ConsoleMessage (
"Parser Unsuccessful");
453void EAI_killBindables (
void) {
455 ttglobal tg = gglobal();
456 ppProdCon p = (ppProdCon)tg->ProdCon.prv;
459 p->psp.comp = &complete;
460 p->psp.type = ZEROBINDABLES;
464 p->psp.zeroBind = FALSE;
467 p->psp.fieldname = NULL;
483 closeConsoleMessage();
495 killKeySensorNodeList();
503 setMenuStatusVP(NULL);
520 fwlio_RxTx_control(CHANNEL_EAI, RxTx_STOP) ;
536 setMenuStatusVP(
"NONE");
544 children = childrenField(rootNode());
545 for (i = 0; i < children->n; i++) {
546 markForDispose(children->p[i], TRUE);
552 rootNode()->_change++;
564void resitem_enqueue(s_list_t* item);
629void dump_resource_waiting(resource_item_t* res)
632 printf(
"%s\t%s\n",( res->complete ?
"<finished>" :
"<waiting>" ), res->URLrequest);
636void send_resource_to_parser_async(resource_item_t *res){
638 resitem_enqueue(ml_new(res));
642void dump_parser_wait_queue()
646 struct tProdCon *t = &gglobal()->ProdCon;
647 p = (ppProdCon)t->prv;
648 printf(
"Parser wait queue:\n");
649 ml_foreach(p->resource_list_to_parse, dump_resource_waiting((resource_item_t*)ml_elem(__l)));
654void post_parse_set_activeLayer();
660static pthread_mutex_t mutex_test = PTHREAD_MUTEX_INITIALIZER;
661void fwl_lockTestMutex()
663 pthread_mutex_lock(&mutex_test);
666void fwl_unlockTestMutex()
668 pthread_mutex_unlock(&mutex_test);
673bool parser_process_res_VRML_X3D(resource_item_t *res)
685 int parsedOk = FALSE;
686 bool fromEAI_SAI = FALSE;
689 struct X3D_Node *oldFogBindInRender, *oldBackgroundBindInRender, *oldNavigationBindInRender, *oldViewpointBindInRender;
693 ttglobal tg = gglobal();
695 p = (ppProdCon)t->prv;
709 oldFogBindInRender = oldBackgroundBindInRender = oldNavigationBindInRender = oldViewpointBindInRender = NULL;
710 if(vectorSize(p->fogNodes))
711 oldFogBindInRender = vector_get(
struct X3D_Node*, p->fogNodes,0);
712 if (vectorSize(p->backgroundNodes))
713 oldBackgroundBindInRender = vector_get(
struct X3D_Node*, p->backgroundNodes,0);
714 if (vectorSize(p->navigationNodes))
715 oldNavigationBindInRender = vector_get(
struct X3D_Node*, p->navigationNodes,0);
716 if (vectorSize(t->viewpointNodes) )
718 oldViewpointBindInRender = vector_get(
struct X3D_Node*, t->viewpointNodes,0);
723 if (res->parsed_request != NULL)
724 if (strncmp(res->parsed_request,EAI_Flag,strlen(EAI_Flag)) == 0) {
730 pushInputResource(res);
736 if (res->parsed_request != NULL && strcmp(res->parsed_request, EAI_Flag) == 0) {
741 nRn = (
struct X3D_Node *) createNewX3DNode0(NODE_Group);
743 insert_node = X3D_NODE(res->whereToPlaceData);
744 offsetInNode = res->offsetFromWhereToPlaceData;
745 if(res->media_type == resm_gltf || res->media_type == resm_glb)
746 parsedOk = parser_do_parse_gltf((
const char *)res->URLrequest,(
const int)strlen(res->URLrequest), ectx, nRn);
748 parsedOk = parser_do_parse_string((
const char *)res->URLrequest,(
const int)strlen(res->URLrequest), ectx, nRn);
759 of = res->openned_files;
779 if (res->treat_as_root || res == (resource_item_t*) gglobal()->resources.root_res) {
785 if (!((resource_item_t*)tg->resources.root_res)->complete) {
788 t->savedParser = (
void *)tg->CParse.globalParser;
789 tg->CParse.globalParser = NULL;
794 if(res->whereToPlaceData){
795 nRn = X3D_NODE(res->whereToPlaceData);
796 if(nRn->_nodeType == NODE_Inline){
814 X3D_INLINE(nRn)->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
822 sceneProto = (
struct X3D_Proto *) createNewX3DNode(NODE_Proto);
823 sceneProto->__protoFlags = ciflag_set(sceneProto->__protoFlags,1,0);
824 sceneProto->__protoFlags = ciflag_set(sceneProto->__protoFlags,2,2);
826 nRn = X3D_NODE(sceneProto);
827 sceneProto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
830 setRootNode(X3D_NODE(sceneProto));
833 deleteVector(
sizeof(
void*),rn->_parentVector);
834 freeMallocedNodeFields(rn);
835 unRegisterX3DNode(rn);
841 if(res->media_type == resm_gltf || res->media_type == resm_glb)
842 parsedOk = parser_do_parse_gltf(of->fileData, of->fileDataSize, ectx, nRn);
844 parsedOk = parser_do_parse_string(of->fileData, of->fileDataSize, ectx, nRn);
846 if ((res != (resource_item_t*)tg->resources.root_res) && ((!tg->resources.root_res) ||(!((resource_item_t*)tg->resources.root_res)->complete))) {
847 tg->CParse.globalParser = t->savedParser;
874 if(vectorSize(p->fogNodes)){
875 stacktop = vector_get(
struct X3D_Node*, p->fogNodes,0);
876 if(stacktop != oldFogBindInRender)
877 t->setFogBindInRender = stacktop;
879 if (vectorSize(p->backgroundNodes)){
880 stacktop = vector_get(
struct X3D_Node*, p->backgroundNodes,0);
881 if(stacktop != oldBackgroundBindInRender)
882 t->setBackgroundBindInRender = stacktop;
884 if (vectorSize(p->navigationNodes)){
885 stacktop = vector_get(
struct X3D_Node*, p->navigationNodes,0);
886 if(stacktop != oldNavigationBindInRender)
887 t->setNavigationBindInRender = stacktop;
889 if (vectorSize(t->viewpointNodes) ){
891 stacktop = vector_get(
struct X3D_Node*, t->viewpointNodes,0);
892 if(stacktop != oldViewpointBindInRender){
893 t->setViewpointBindInRender = stacktop;
894 if (res->afterPoundCharacters)
895 fwl_gotoViewpoint(res->afterPoundCharacters);
904 if (res->whereToPlaceData == NULL) {
908 insert_node = X3D_NODE(res->whereToPlaceData);
909 offsetInNode = res->offsetFromWhereToPlaceData;
920 if(X3D_NODE(nRn)->_nodeType == NODE_Group){
922 AddRemoveChildren(X3D_NODE(insert_node),
923 offsetPointer_deref(
void*, insert_node, offsetInNode),
924 (
struct X3D_Node * *)nRng->children.p,
925 nRng->children.n, 1, __FILE__,__LINE__);
928 AddRemoveChildren(X3D_NODE(nRng),
930 (
struct X3D_Node* *)nRng->children.p,nRng->children.n,2,__FILE__,__LINE__);
933 res->complete = TRUE;
936 deleteVector(
sizeof(
void*),nRnfree->_parentVector);
937 freeMallocedNodeFields(nRnfree);
953int EAI_CreateVrml(
const char *tp,
const char *inputstring,
955 resource_item_t *res;
961 if (strncmp(tp,
"URL", 3) == 0) {
963 res = resource_create_single(inputstring);
965 res->whereToPlaceData = where;
966 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
973 if (strncmp(inputstring,
"#VRML V2.0", 6) == 0) {
974 sendIn = inputstring;
976 newString = MALLOC (
char *, strlen(inputstring) + strlen (
"#VRML V2.0 utf8\n") + 3);
977 strcpy (newString,
"#VRML V2.0 utf8\n");
978 strcat (newString,inputstring);
983 res = resource_create_from_string(sendIn);
984 res->media_type=resm_vrml;
985 res->parsed_request = EAI_Flag;
987 res->whereToPlaceData = where;
988 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
990 retval = parser_process_res_VRML_X3D(res);
991 FREE_IF_NZ(newString);
1000int EAI_CreateX3d(
const char *tp,
const char *inputstring,
struct X3D_Node *ectx,
struct X3D_Group *where)
1003 resource_item_t *res;
1008 if (strncmp(tp,
"URL", 3) == 0) {
1010 res = resource_create_single(inputstring);
1012 res->whereToPlaceData = where;
1013 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
1023 newString = MALLOC (
char *, strlen(inputstring) + strlen (
"<X3D>\n\n</X3D>\n") + 3);
1024 strcpy(newString,
"<X3D>\n");
1025 strcat(newString,inputstring);
1026 strcat(newString,
"\n</X3D>\n");
1029 res = resource_create_from_string(sendIn);
1030 res->media_type=resm_x3d;
1031 res->parsed_request = EAI_Flag;
1033 res->whereToPlaceData = where;
1034 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
1036 return parser_process_res_VRML_X3D(res);
1048static bool parser_process_res_SCRIPT(resource_item_t *res)
1057 switch (res->type) {
1063 buffer = res->URLrequest;
1075 of = res->openned_files;
1081 buffer = (
const char*)of->fileData;
1087 return script_initCode(ss, buffer);
1091#if !defined(HAVE_PTHREAD_CANCEL)
1092void Parser_thread_exit_handler(
int sig) {
1093 ConsoleMessage(
"Parser_thread_exit_handler: parserThread exiting");
1116void *getProdConQueueContentStatus() {
1120 ttglobal tg = gglobal();
1121 p = (ppProdCon) tg->ProdCon.prv;
1123 return (p->resource_list_to_parse);
1127void threadsafe_enqueue_item_signal(s_list_t *item, s_list_t** queue, pthread_mutex_t* queue_lock, pthread_cond_t *queue_nonzero)
1129 pthread_mutex_lock(queue_lock);
1131 pthread_cond_signal(queue_nonzero);
1132 ml_enqueue(queue,item);
1133 pthread_mutex_unlock(queue_lock);
1136s_list_t* threadsafe_dequeue_item_wait(s_list_t** queue, pthread_mutex_t *queue_lock, pthread_cond_t *queue_nonzero, BOOL *waiting )
1138 s_list_t *item = NULL;
1139 pthread_mutex_lock(queue_lock);
1140 while (*queue == NULL){
1142 pthread_cond_wait(queue_nonzero, queue_lock);
1145 item = ml_dequeue(queue);
1146 pthread_mutex_unlock(queue_lock);
1149void resitem_enqueue(s_list_t *item){
1151 ttglobal tg = gglobal();
1152 p = (ppProdCon)tg->ProdCon.prv;
1154 threadsafe_enqueue_item_signal(item,&p->resource_list_to_parse, &tg->threads.mutex_resource_list, &tg->threads.resource_list_condition );
1156void resitem_enqueue_tg(s_list_t *item,
void* tg){
1157 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1158 resitem_enqueue(item);
1159 fwl_clearCurrentHandle();
1161s_list_t *resitem_dequeue(){
1163 ttglobal tg = gglobal();
1164 p = (ppProdCon)tg->ProdCon.prv;
1166 return threadsafe_dequeue_item_wait(&p->resource_list_to_parse, &tg->threads.mutex_resource_list, &tg->threads.resource_list_condition, &tg->threads.ResourceThreadWaiting );
1171void threadsafe_enqueue_item(s_list_t *item, s_list_t** queue, pthread_mutex_t* queue_lock)
1173 pthread_mutex_lock(queue_lock);
1174 ml_enqueue(queue,item);
1175 pthread_mutex_unlock(queue_lock);
1178s_list_t* threadsafe_dequeue_item(s_list_t** queue, pthread_mutex_t *queue_lock )
1180 s_list_t *item = NULL;
1181 pthread_mutex_lock(queue_lock);
1182 item = ml_dequeue(queue);
1183 pthread_mutex_unlock(queue_lock);
1187void frontenditem_enqueue(s_list_t *item){
1189 ttglobal tg = gglobal();
1190 p = (ppProdCon)tg->ProdCon.prv;
1191 threadsafe_enqueue_item(item,&p->frontend_list_to_get, &tg->threads.mutex_frontend_list );
1193void frontenditem_enqueue_tg(s_list_t *item,
void *tg){
1194 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1195 frontenditem_enqueue(item);
1196 fwl_clearCurrentHandle();
1198s_list_t *frontenditem_dequeue(){
1200 ttglobal tg = gglobal();
1201 p = (ppProdCon)tg->ProdCon.prv;
1203 return threadsafe_dequeue_item(&p->frontend_list_to_get, &tg->threads.mutex_frontend_list );
1205s_list_t *frontenditem_dequeue_tg(
void *tg){
1207 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1208 item = frontenditem_dequeue();
1209 fwl_clearCurrentHandle();
1212void *fwl_frontenditem_dequeue(){
1214 s_list_t *item = frontenditem_dequeue();
1221void fwl_resitem_enqueue(
void *res){
1222 resitem_enqueue(ml_new(res));
1225int frontendGetsFiles(){
1226 return ((ppProdCon)(gglobal()->ProdCon.prv))->frontend_gets_files;
1229void process_res_texitem(resource_item_t *res);
1230bool parser_process_res_SHADER(resource_item_t *res);
1231bool process_res_audio(resource_item_t *res);
1232bool process_res_movie(resource_item_t *res);
1233int parser_process_res_gltf(resource_item_t *res);
1239static bool parser_process_res(s_list_t *item)
1242 bool remove_it = FALSE;
1245 resource_item_t *res;
1250 if (!item || !item->elem)
1253 res = ml_elem(item);
1256 switch (res->status) {
1261 if(!res->actions || (res->actions & resa_identify)){
1262 resource_identify(res->parent, res);
1263 if (res->type == rest_invalid) {
1265 res->complete = TRUE;
1270 case ress_starts_good:
1271 if(!res->actions || (res->actions & resa_download)){
1274 frontenditem_enqueue(ml_new(res));
1280 if(p->frontend_gets_files){
1281 frontenditem_enqueue(ml_new(res));
1284 resource_fetch(res);
1290 case ress_downloaded:
1291 if(!res->actions || (res->actions & resa_load))
1295 if(!res->_loadFunc(res)){
1296 ERROR_MSG(
"failure when trying to load resource: %s\n", res->URLrequest);
1298 res->complete = TRUE;
1305 more_multi = (res->status == ress_failed) && (res->m_request != NULL);
1308 res->status = ress_invalid;
1309 res->type = rest_multi;
1312 resource_identify(res->parent, res);
1313 frontenditem_enqueue(ml_new(res));
1315 ConsoleMessage(
"url not found: %s\n",res->parsed_request);
1317 res->complete = TRUE;
1325 if(!res->actions || (res->actions & resa_process))
1326 switch (res->media_type) {
1328 ConsoleMessage (
"deciphering file: 404 file not found or unknown file type encountered.");
1331 res->status = ress_not_loaded;
1335 if (parser_process_res_VRML_X3D(res)) {
1336 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1337 res->status = ress_parsed;
1340 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1345 if (parser_process_res_SCRIPT(res)) {
1346 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1347 res->status = ress_parsed;
1350 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1355 if (parser_process_res_SHADER(res)) {
1356 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1357 res->status = ress_parsed;
1360 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1366 res->complete = TRUE;
1367 process_res_texitem(res);
1370 res->complete = TRUE;
1371 if(process_res_movie(res)){
1372 res->status = ress_parsed;
1375 res->status = ress_failed;
1379 res->complete = TRUE;
1380 if(process_res_audio(res)){
1381 res->status = ress_parsed;
1384 res->status = ress_failed;
1389 printf(
"processed x3z\n");
1404 if (parser_process_res_gltf(res)) {
1405 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1406 res->status = ress_parsed;
1409 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1416 printf (
"dont know anything about resm_external at this point\n");
1420 res->complete = TRUE;
1424 case ress_not_loaded:
1426 res->complete = TRUE;
1431 res->complete = TRUE;
1435 case ress_not_parsed:
1436 res->complete = TRUE;
1444 if(res->status == ress_parsed){
1446 if(res->openned_files){
1447 openned_file_t *of = res->openned_files;
1449 FREE_IF_NZ(of->fileData);
1455 resitem_enqueue(item);
1457 dump_parser_wait_queue();
1464static const int res_command_exit;
1466void resitem_queue_exit(){
1467 resitem_enqueue(ml_new(&res_command_exit));
1469void _inputParseThread(
void *globalcontext)
1471 ttglobal tg = (ttglobal)globalcontext;
1473 #if !defined (HAVE_PTHREAD_CANCEL)
1474 struct sigaction actions;
1476 memset(&actions, 0,
sizeof(actions));
1477 sigemptyset(&actions.sa_mask);
1478 actions.sa_flags = 0;
1479 actions.sa_handler = Parser_thread_exit_handler;
1480 rc = sigaction(SIGUSR2,&actions,NULL);
1485 ppProdCon p = (ppProdCon)tg->ProdCon.prv;
1486 tg->threads.PCthread = pthread_self();
1488 fwl_setCurrentHandle(tg,__FILE__,__LINE__);
1491 tg->threads.ResourceThreadRunning = TRUE;
1492 ENTER_THREAD(
"input parser");
1501 s_list_t* item = resitem_dequeue();
1502 elem = ml_elem(item);
1503 if (elem == &res_command_exit){
1509 if (tg->threads.flushing){
1513 p->inputThreadParsing = TRUE;
1515 parser_process_res(item);
1516 p->inputThreadParsing = FALSE;
1519 tg->threads.ResourceThreadRunning = FALSE;
1527void kill_bindables (
void) {
1531 ttglobal tg = gglobal();
1533 struct tProdCon *t = &gglobal()->ProdCon;
1534 p = (ppProdCon)t->prv;
1542 for(i=0;i<vectorSize(tg->Bindable.bstacks);i++){
1544 if (vectorSize(bstack->navigation) > 0) {
1545 for (i=0; i < vectorSize(bstack->navigation);i++){
1546 tmp = vector_get(
struct X3D_Node*,bstack->navigation,i);
1547 send_bind_to(tmp, ib);
1550 if (vectorSize(bstack->background) > 0) {
1551 for (i=0; i < vectorSize(bstack->background);i++){
1552 tmp = vector_get(
struct X3D_Node*,bstack->background,i);
1553 send_bind_to(tmp, ib);
1556 if (vectorSize(bstack->viewpoint) > 0) {
1557 for (i=0; i < vectorSize(bstack->viewpoint);i++){
1558 tmp = vector_get(
struct X3D_Node*,bstack->viewpoint,i);
1559 send_bind_to(tmp, ib);
1562 if (vectorSize(bstack->fog) > 0) {
1563 for (i=0; i < vectorSize(bstack->fog);i++){
1564 tmp = vector_get(
struct X3D_Node*,bstack->fog,i);
1565 send_bind_to(tmp, ib);
1568 ((
struct Vector *)bstack->navigation)->n=0;
1569 ((
struct Vector *)bstack->background)->n=0;
1570 ((
struct Vector *)bstack->viewpoint)->n=0;
1571 ((
struct Vector *)bstack->fog)->n=0;
1574 ((
struct Vector *)t->viewpointNodes)->n=0;
1575 p->backgroundNodes->n=0;
1576 p->navigationNodes->n=0;
1614void registerBindable (
struct X3D_Node *node) {
1621 p = (ppProdCon)t->prv;
1623 layerId = tg->Bindable.activeLayer;
1625 switch (node->_nodeType) {
1626 case NODE_Viewpoint:
1627 X3D_VIEWPOINT(node)->set_bind = 100;
1628 X3D_VIEWPOINT(node)->isBound = 0;
1629 X3D_VIEWPOINT(node)->_layerId = layerId;
1630 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1632 case NODE_OrthoViewpoint:
1633 X3D_ORTHOVIEWPOINT(node)->set_bind = 100;
1634 X3D_ORTHOVIEWPOINT(node)->isBound = 0;
1635 X3D_ORTHOVIEWPOINT(node)->_layerId = layerId;
1636 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1638 case NODE_GeoViewpoint:
1639 X3D_GEOVIEWPOINT(node)->set_bind = 100;
1640 X3D_GEOVIEWPOINT(node)->isBound = 0;
1641 X3D_GEOVIEWPOINT(node)->_layerId = layerId;
1642 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1644 case NODE_Background:
1645 X3D_BACKGROUND(node)->set_bind = 100;
1646 X3D_BACKGROUND(node)->isBound = 0;
1647 X3D_BACKGROUND(node)->_layerId = layerId;
1648 vector_pushBack (
struct X3D_Node*,p->backgroundNodes, node);
1650 case NODE_TextureBackground:
1651 X3D_TEXTUREBACKGROUND(node)->set_bind = 100;
1652 X3D_TEXTUREBACKGROUND(node)->isBound = 0;
1653 X3D_TEXTUREBACKGROUND(node)->_layerId = layerId;
1654 vector_pushBack (
struct X3D_Node*,p->backgroundNodes, node);
1656 case NODE_NavigationInfo:
1657 X3D_NAVIGATIONINFO(node)->set_bind = 100;
1658 X3D_NAVIGATIONINFO(node)->isBound = 0;
1659 X3D_NAVIGATIONINFO(node)->_layerId = layerId;
1660 vector_pushBack (
struct X3D_Node*,p->navigationNodes, node);
1663 X3D_FOG(node)->set_bind = 100;
1664 X3D_FOG(node)->isBound = 0;
1665 X3D_FOG(node)->_layerId = layerId;
1666 vector_pushBack (
struct X3D_Node*,p->fogNodes, node);
1678int removeNodeFromVector(
int iaction,
struct Vector *v,
struct X3D_Node *node){
1681 int noisy, iret = FALSE;
1690 tn = vector_get(
struct X3D_Node*,v,ii);
1694 vector_set(
struct X3D_Node*,v,ii,NULL);
1695 if(noisy) printf(
"NULLing %d %p\n",ii,node);
1696 }
else if(iaction == 0){
1697 if(noisy) printf(
"REMOVing %d %p\n",ii,node);
1698 vector_remove_elem(
struct X3D_Node*,v,ii);
1705 printf(
"not found in stack node=%p stack.n=%d:\n",node,vectorSize(v));
1706 for(i=0;i<vectorSize(v);i++){
1707 printf(
" %p",vector_get(
struct X3D_Node*,v,i));
1713void unRegisterBindable (
struct X3D_Node *node) {
1715 struct tProdCon *t = &gglobal()->ProdCon;
1716 p = (ppProdCon)t->prv;
1719 switch (node->_nodeType) {
1720 case NODE_Viewpoint:
1721 X3D_VIEWPOINT(node)->set_bind = 100;
1722 X3D_VIEWPOINT(node)->isBound = 0;
1724 send_bind_to(node,0);
1725 removeNodeFromVector(0, t->viewpointNodes, node);
1727 case NODE_OrthoViewpoint:
1728 X3D_ORTHOVIEWPOINT(node)->set_bind = 100;
1729 X3D_ORTHOVIEWPOINT(node)->isBound = 0;
1730 send_bind_to(node,0);
1731 removeNodeFromVector(0, t->viewpointNodes, node);
1733 case NODE_GeoViewpoint:
1734 X3D_GEOVIEWPOINT(node)->set_bind = 100;
1735 X3D_GEOVIEWPOINT(node)->isBound = 0;
1736 send_bind_to(node,0);
1737 removeNodeFromVector(0, t->viewpointNodes, node);
1739 case NODE_Background:
1740 X3D_BACKGROUND(node)->set_bind = 100;
1741 X3D_BACKGROUND(node)->isBound = 0;
1742 send_bind_to(node,0);
1743 removeNodeFromVector(0, p->backgroundNodes, node);
1745 case NODE_TextureBackground:
1746 X3D_TEXTUREBACKGROUND(node)->set_bind = 100;
1747 X3D_TEXTUREBACKGROUND(node)->isBound = 0;
1748 removeNodeFromVector(0, p->backgroundNodes, node);
1750 case NODE_NavigationInfo:
1751 X3D_NAVIGATIONINFO(node)->set_bind = 100;
1752 X3D_NAVIGATIONINFO(node)->isBound = 0;
1753 send_bind_to(node,0);
1754 removeNodeFromVector(0, p->navigationNodes, node);
1757 X3D_FOG(node)->set_bind = 100;
1758 X3D_FOG(node)->isBound = 0;
1759 send_bind_to(node,0);
1760 removeNodeFromVector(0, p->fogNodes, node);