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;
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();
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){
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() {
236 if (p!=NULL)
return p->lastSTLScaling;
244int fwl_isInputThreadInitialized() {
247 return gglobal()->threads.ResourceThreadRunning;
251int fwl_isinputThreadParsing() {
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)
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) {
459 p->psp.comp = &complete;
460 p->psp.type = ZEROBINDABLES;
464 p->psp.zeroBind = FALSE;
467 p->psp.fieldname = NULL;
483 closeConsoleMessage();
495 killKeySensorNodeList();
520 fwlio_RxTx_control(CHANNEL_EAI, RxTx_STOP) ;
536 setMenuStatus(
"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);
632 printf(
"%s\t%s\n",( res->complete ?
"<finished>" :
"<waiting>" ), res->URLrequest);
638 resitem_enqueue(ml_new(res));
642void dump_parser_wait_queue()
646 struct tProdCon *t = &gglobal()->ProdCon;
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);
685 int parsedOk = FALSE;
686 bool fromEAI_SAI = FALSE;
689 struct X3D_Node *oldFogBindInRender, *oldBackgroundBindInRender, *oldNavigationBindInRender, *oldViewpointBindInRender;
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;
746 parsedOk = parser_do_parse_string((
const char *)res->URLrequest,(
const int)strlen(res->URLrequest), ectx, nRn);
757 of = res->openned_files;
777 if (res->treat_as_root || res == (
resource_item_t*) gglobal()->resources.root_res) {
786 t->savedParser = (
void *)tg->CParse.globalParser;
787 tg->CParse.globalParser = NULL;
792 if(res->whereToPlaceData){
793 nRn = X3D_NODE(res->whereToPlaceData);
794 if(nRn->_nodeType == NODE_Inline){
812 X3D_INLINE(nRn)->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
820 sceneProto = (
struct X3D_Proto *) createNewX3DNode(NODE_Proto);
821 sceneProto->__protoFlags = ciflag_set(sceneProto->__protoFlags,1,0);
822 sceneProto->__protoFlags = ciflag_set(sceneProto->__protoFlags,2,2);
824 nRn = X3D_NODE(sceneProto);
825 sceneProto->__specversion = inputFileVersion[0]*100 + inputFileVersion[1]*10 + inputFileVersion[2];
828 setRootNode(X3D_NODE(sceneProto));
831 deleteVector(
sizeof(
void*),rn->_parentVector);
832 freeMallocedNodeFields(rn);
833 unRegisterX3DNode(rn);
839 parsedOk = parser_do_parse_string(of->fileData, of->fileDataSize, ectx, nRn);
842 tg->CParse.globalParser = t->savedParser;
869 if(vectorSize(p->fogNodes)){
870 stacktop = vector_get(
struct X3D_Node*, p->fogNodes,0);
871 if(stacktop != oldFogBindInRender)
872 t->setFogBindInRender = stacktop;
874 if (vectorSize(p->backgroundNodes)){
875 stacktop = vector_get(
struct X3D_Node*, p->backgroundNodes,0);
876 if(stacktop != oldBackgroundBindInRender)
877 t->setBackgroundBindInRender = stacktop;
879 if (vectorSize(p->navigationNodes)){
880 stacktop = vector_get(
struct X3D_Node*, p->navigationNodes,0);
881 if(stacktop != oldNavigationBindInRender)
882 t->setNavigationBindInRender = stacktop;
884 if (vectorSize(t->viewpointNodes) ){
886 stacktop = vector_get(
struct X3D_Node*, t->viewpointNodes,0);
887 if(stacktop != oldViewpointBindInRender){
888 t->setViewpointBindInRender = stacktop;
889 if (res->afterPoundCharacters)
890 fwl_gotoViewpoint(res->afterPoundCharacters);
899 if (res->whereToPlaceData == NULL) {
903 insert_node = X3D_NODE(res->whereToPlaceData);
904 offsetInNode = res->offsetFromWhereToPlaceData;
915 if(X3D_NODE(nRn)->_nodeType == NODE_Group){
917 AddRemoveChildren(X3D_NODE(insert_node),
918 offsetPointer_deref(
void*, insert_node, offsetInNode),
919 (
struct X3D_Node * *)nRng->children.p,
920 nRng->children.n, 1, __FILE__,__LINE__);
923 AddRemoveChildren(X3D_NODE(nRng),
925 (
struct X3D_Node* *)nRng->children.p,nRng->children.n,2,__FILE__,__LINE__);
928 res->complete = TRUE;
931 deleteVector(
sizeof(
void*),nRnfree->_parentVector);
932 freeMallocedNodeFields(nRnfree);
948int EAI_CreateVrml(
const char *tp,
const char *inputstring,
956 if (strncmp(tp,
"URL", 3) == 0) {
958 res = resource_create_single(inputstring);
960 res->whereToPlaceData = where;
961 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
968 if (strncmp(inputstring,
"#VRML V2.0", 6) == 0) {
969 sendIn = inputstring;
971 newString = MALLOC (
char *, strlen(inputstring) + strlen (
"#VRML V2.0 utf8\n") + 3);
972 strcpy (newString,
"#VRML V2.0 utf8\n");
973 strcat (newString,inputstring);
978 res = resource_create_from_string(sendIn);
979 res->media_type=resm_vrml;
980 res->parsed_request = EAI_Flag;
982 res->whereToPlaceData = where;
983 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
985 retval = parser_process_res_VRML_X3D(res);
986 FREE_IF_NZ(newString);
995int EAI_CreateX3d(
const char *tp,
const char *inputstring,
struct X3D_Node *ectx,
struct X3D_Group *where)
1003 if (strncmp(tp,
"URL", 3) == 0) {
1005 res = resource_create_single(inputstring);
1007 res->whereToPlaceData = where;
1008 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
1018 newString = MALLOC (
char *, strlen(inputstring) + strlen (
"<X3D>\n\n</X3D>\n") + 3);
1019 strcpy(newString,
"<X3D>\n");
1020 strcat(newString,inputstring);
1021 strcat(newString,
"\n</X3D>\n");
1024 res = resource_create_from_string(sendIn);
1025 res->media_type=resm_x3d;
1026 res->parsed_request = EAI_Flag;
1028 res->whereToPlaceData = where;
1029 res->offsetFromWhereToPlaceData = (int) offsetof (
struct X3D_Group, children);
1031 return parser_process_res_VRML_X3D(res);
1052 switch (res->type) {
1058 buffer = res->URLrequest;
1070 of = res->openned_files;
1076 buffer = (
const char*)of->fileData;
1082 return script_initCode(ss, buffer);
1086#if !defined(HAVE_PTHREAD_CANCEL)
1087void Parser_thread_exit_handler(
int sig) {
1088 ConsoleMessage(
"Parser_thread_exit_handler: parserThread exiting");
1111void *getProdConQueueContentStatus() {
1118 return (p->resource_list_to_parse);
1122void threadsafe_enqueue_item_signal(
s_list_t *item,
s_list_t** queue, pthread_mutex_t* queue_lock, pthread_cond_t *queue_nonzero)
1124 pthread_mutex_lock(queue_lock);
1126 pthread_cond_signal(queue_nonzero);
1127 ml_enqueue(queue,item);
1128 pthread_mutex_unlock(queue_lock);
1131s_list_t* threadsafe_dequeue_item_wait(
s_list_t** queue, pthread_mutex_t *queue_lock, pthread_cond_t *queue_nonzero, BOOL *waiting )
1134 pthread_mutex_lock(queue_lock);
1135 while (*queue == NULL){
1137 pthread_cond_wait(queue_nonzero, queue_lock);
1140 item = ml_dequeue(queue);
1141 pthread_mutex_unlock(queue_lock);
1144void resitem_enqueue(
s_list_t *item){
1149 threadsafe_enqueue_item_signal(item,&p->resource_list_to_parse, &tg->threads.mutex_resource_list, &tg->threads.resource_list_condition );
1151void resitem_enqueue_tg(
s_list_t *item,
void* tg){
1152 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1153 resitem_enqueue(item);
1154 fwl_clearCurrentHandle();
1161 return threadsafe_dequeue_item_wait(&p->resource_list_to_parse, &tg->threads.mutex_resource_list, &tg->threads.resource_list_condition, &tg->threads.ResourceThreadWaiting );
1166void threadsafe_enqueue_item(
s_list_t *item,
s_list_t** queue, pthread_mutex_t* queue_lock)
1168 pthread_mutex_lock(queue_lock);
1169 ml_enqueue(queue,item);
1170 pthread_mutex_unlock(queue_lock);
1173s_list_t* threadsafe_dequeue_item(
s_list_t** queue, pthread_mutex_t *queue_lock )
1176 pthread_mutex_lock(queue_lock);
1177 item = ml_dequeue(queue);
1178 pthread_mutex_unlock(queue_lock);
1182void frontenditem_enqueue(
s_list_t *item){
1186 threadsafe_enqueue_item(item,&p->frontend_list_to_get, &tg->threads.mutex_frontend_list );
1188void frontenditem_enqueue_tg(
s_list_t *item,
void *tg){
1189 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1190 frontenditem_enqueue(item);
1191 fwl_clearCurrentHandle();
1198 return threadsafe_dequeue_item(&p->frontend_list_to_get, &tg->threads.mutex_frontend_list );
1200s_list_t *frontenditem_dequeue_tg(
void *tg){
1202 fwl_setCurrentHandle(tg, __FILE__, __LINE__);
1203 item = frontenditem_dequeue();
1204 fwl_clearCurrentHandle();
1207void *fwl_frontenditem_dequeue(){
1209 s_list_t *item = frontenditem_dequeue();
1216void fwl_resitem_enqueue(
void *res){
1217 resitem_enqueue(ml_new(res));
1220int frontendGetsFiles(){
1221 return ((
ppProdCon)(gglobal()->ProdCon.prv))->frontend_gets_files;
1233static bool parser_process_res(
s_list_t *item)
1236 bool remove_it = FALSE;
1244 if (!item || !item->elem)
1247 res = ml_elem(item);
1250 switch (res->status) {
1255 if(!res->actions || (res->actions & resa_identify)){
1256 resource_identify(res->parent, res);
1257 if (res->type == rest_invalid) {
1259 res->complete = TRUE;
1264 case ress_starts_good:
1265 if(!res->actions || (res->actions & resa_download)){
1268 frontenditem_enqueue(ml_new(res));
1274 if(p->frontend_gets_files){
1275 frontenditem_enqueue(ml_new(res));
1278 resource_fetch(res);
1284 case ress_downloaded:
1285 if(!res->actions || (res->actions & resa_load))
1289 if(!res->_loadFunc(res)){
1290 ERROR_MSG(
"failure when trying to load resource: %s\n", res->URLrequest);
1292 res->complete = TRUE;
1299 more_multi = (res->status == ress_failed) && (res->m_request != NULL);
1302 res->status = ress_invalid;
1303 res->type = rest_multi;
1306 resource_identify(res->parent, res);
1307 frontenditem_enqueue(ml_new(res));
1309 ConsoleMessage(
"url not found: %s\n",res->parsed_request);
1311 res->complete = TRUE;
1319 if(!res->actions || (res->actions & resa_process))
1320 switch (res->media_type) {
1322 ConsoleMessage (
"deciphering file: 404 file not found or unknown file type encountered.");
1325 res->status = ress_not_loaded;
1329 if (parser_process_res_VRML_X3D(res)) {
1330 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1331 res->status = ress_parsed;
1334 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1339 if (parser_process_res_SCRIPT(res)) {
1340 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1341 res->status = ress_parsed;
1344 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1349 if (parser_process_res_SHADER(res)) {
1350 DEBUG_MSG(
"parser successfull: %s\n", res->URLrequest);
1351 res->status = ress_parsed;
1354 ERROR_MSG(
"parser failed for resource: %s\n", res->URLrequest);
1360 res->complete = TRUE;
1361 process_res_texitem(res);
1364 res->complete = TRUE;
1365 if(process_res_movie(res)){
1366 res->status = ress_parsed;
1369 res->status = ress_failed;
1373 res->complete = TRUE;
1374 if(process_res_audio(res)){
1375 res->status = ress_parsed;
1378 res->status = ress_failed;
1383 printf(
"processed x3z\n");
1388 printf (
"dont know anything about resm_external at this point\n");
1392 res->complete = TRUE;
1396 case ress_not_loaded:
1398 res->complete = TRUE;
1403 res->complete = TRUE;
1407 case ress_not_parsed:
1408 res->complete = TRUE;
1416 if(res->status == ress_parsed){
1418 if(res->openned_files){
1421 FREE_IF_NZ(of->fileData);
1427 resitem_enqueue(item);
1429 dump_parser_wait_queue();
1436static const int res_command_exit;
1438void resitem_queue_exit(){
1439 resitem_enqueue(ml_new(&res_command_exit));
1441void _inputParseThread(
void *globalcontext)
1445 #if !defined (HAVE_PTHREAD_CANCEL)
1446 struct sigaction actions;
1448 memset(&actions, 0,
sizeof(actions));
1449 sigemptyset(&actions.sa_mask);
1450 actions.sa_flags = 0;
1451 actions.sa_handler = Parser_thread_exit_handler;
1452 rc = sigaction(SIGUSR2,&actions,NULL);
1458 tg->threads.PCthread = pthread_self();
1460 fwl_setCurrentHandle(tg,__FILE__,__LINE__);
1463 tg->threads.ResourceThreadRunning = TRUE;
1464 ENTER_THREAD(
"input parser");
1473 s_list_t* item = resitem_dequeue();
1474 elem = ml_elem(item);
1475 if (elem == &res_command_exit){
1481 if (tg->threads.flushing){
1485 p->inputThreadParsing = TRUE;
1487 parser_process_res(item);
1488 p->inputThreadParsing = FALSE;
1491 tg->threads.ResourceThreadRunning = FALSE;
1499void kill_bindables (
void) {
1505 struct tProdCon *t = &gglobal()->ProdCon;
1514 for(i=0;i<vectorSize(tg->Bindable.bstacks);i++){
1516 if (vectorSize(bstack->navigation) > 0) {
1517 for (i=0; i < vectorSize(bstack->navigation);i++){
1518 tmp = vector_get(
struct X3D_Node*,bstack->navigation,i);
1519 send_bind_to(tmp, ib);
1522 if (vectorSize(bstack->background) > 0) {
1523 for (i=0; i < vectorSize(bstack->background);i++){
1524 tmp = vector_get(
struct X3D_Node*,bstack->background,i);
1525 send_bind_to(tmp, ib);
1528 if (vectorSize(bstack->viewpoint) > 0) {
1529 for (i=0; i < vectorSize(bstack->viewpoint);i++){
1530 tmp = vector_get(
struct X3D_Node*,bstack->viewpoint,i);
1531 send_bind_to(tmp, ib);
1534 if (vectorSize(bstack->fog) > 0) {
1535 for (i=0; i < vectorSize(bstack->fog);i++){
1536 tmp = vector_get(
struct X3D_Node*,bstack->fog,i);
1537 send_bind_to(tmp, ib);
1540 ((
struct Vector *)bstack->navigation)->n=0;
1541 ((
struct Vector *)bstack->background)->n=0;
1542 ((
struct Vector *)bstack->viewpoint)->n=0;
1543 ((
struct Vector *)bstack->fog)->n=0;
1546 ((
struct Vector *)t->viewpointNodes)->n=0;
1547 p->backgroundNodes->n=0;
1548 p->navigationNodes->n=0;
1586void registerBindable (
struct X3D_Node *node) {
1595 layerId = tg->Bindable.activeLayer;
1597 switch (node->_nodeType) {
1598 case NODE_Viewpoint:
1599 X3D_VIEWPOINT(node)->set_bind = 100;
1600 X3D_VIEWPOINT(node)->isBound = 0;
1601 X3D_VIEWPOINT(node)->_layerId = layerId;
1602 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1604 case NODE_OrthoViewpoint:
1605 X3D_ORTHOVIEWPOINT(node)->set_bind = 100;
1606 X3D_ORTHOVIEWPOINT(node)->isBound = 0;
1607 X3D_ORTHOVIEWPOINT(node)->_layerId = layerId;
1608 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1610 case NODE_GeoViewpoint:
1611 X3D_GEOVIEWPOINT(node)->set_bind = 100;
1612 X3D_GEOVIEWPOINT(node)->isBound = 0;
1613 X3D_GEOVIEWPOINT(node)->_layerId = layerId;
1614 vector_pushBack (
struct X3D_Node*,t->viewpointNodes, node);
1616 case NODE_Background:
1617 X3D_BACKGROUND(node)->set_bind = 100;
1618 X3D_BACKGROUND(node)->isBound = 0;
1619 X3D_BACKGROUND(node)->_layerId = layerId;
1620 vector_pushBack (
struct X3D_Node*,p->backgroundNodes, node);
1622 case NODE_TextureBackground:
1623 X3D_TEXTUREBACKGROUND(node)->set_bind = 100;
1624 X3D_TEXTUREBACKGROUND(node)->isBound = 0;
1625 X3D_TEXTUREBACKGROUND(node)->_layerId = layerId;
1626 vector_pushBack (
struct X3D_Node*,p->backgroundNodes, node);
1628 case NODE_NavigationInfo:
1629 X3D_NAVIGATIONINFO(node)->set_bind = 100;
1630 X3D_NAVIGATIONINFO(node)->isBound = 0;
1631 X3D_NAVIGATIONINFO(node)->_layerId = layerId;
1632 vector_pushBack (
struct X3D_Node*,p->navigationNodes, node);
1635 X3D_FOG(node)->set_bind = 100;
1636 X3D_FOG(node)->isBound = 0;
1637 X3D_FOG(node)->_layerId = layerId;
1638 vector_pushBack (
struct X3D_Node*,p->fogNodes, node);
1650int removeNodeFromVector(
int iaction,
struct Vector *v,
struct X3D_Node *node){
1653 int noisy, iret = FALSE;
1662 tn = vector_get(
struct X3D_Node*,v,ii);
1666 vector_set(
struct X3D_Node*,v,ii,NULL);
1667 if(noisy) printf(
"NULLing %d %p\n",ii,node);
1668 }
else if(iaction == 0){
1669 if(noisy) printf(
"REMOVing %d %p\n",ii,node);
1670 vector_remove_elem(
struct X3D_Node*,v,ii);
1677 printf(
"not found in stack node=%p stack.n=%d:\n",node,vectorSize(v));
1678 for(i=0;i<vectorSize(v);i++){
1679 printf(
" %p",vector_get(
struct X3D_Node*,v,i));
1685void unRegisterBindable (
struct X3D_Node *node) {
1687 struct tProdCon *t = &gglobal()->ProdCon;
1691 switch (node->_nodeType) {
1692 case NODE_Viewpoint:
1693 X3D_VIEWPOINT(node)->set_bind = 100;
1694 X3D_VIEWPOINT(node)->isBound = 0;
1696 send_bind_to(node,0);
1697 removeNodeFromVector(0, t->viewpointNodes, node);
1699 case NODE_OrthoViewpoint:
1700 X3D_ORTHOVIEWPOINT(node)->set_bind = 100;
1701 X3D_ORTHOVIEWPOINT(node)->isBound = 0;
1702 send_bind_to(node,0);
1703 removeNodeFromVector(0, t->viewpointNodes, node);
1705 case NODE_GeoViewpoint:
1706 X3D_GEOVIEWPOINT(node)->set_bind = 100;
1707 X3D_GEOVIEWPOINT(node)->isBound = 0;
1708 send_bind_to(node,0);
1709 removeNodeFromVector(0, t->viewpointNodes, node);
1711 case NODE_Background:
1712 X3D_BACKGROUND(node)->set_bind = 100;
1713 X3D_BACKGROUND(node)->isBound = 0;
1714 send_bind_to(node,0);
1715 removeNodeFromVector(0, p->backgroundNodes, node);
1717 case NODE_TextureBackground:
1718 X3D_TEXTUREBACKGROUND(node)->set_bind = 100;
1719 X3D_TEXTUREBACKGROUND(node)->isBound = 0;
1720 removeNodeFromVector(0, p->backgroundNodes, node);
1722 case NODE_NavigationInfo:
1723 X3D_NAVIGATIONINFO(node)->set_bind = 100;
1724 X3D_NAVIGATIONINFO(node)->isBound = 0;
1725 send_bind_to(node,0);
1726 removeNodeFromVector(0, p->navigationNodes, node);
1729 X3D_FOG(node)->set_bind = 100;
1730 X3D_FOG(node)->isBound = 0;
1731 send_bind_to(node,0);
1732 removeNodeFromVector(0, p->fogNodes, node);