30#include <system_threads.h>
34#include <libFreeWRL.h>
37#include "../vrml_parser/Structs.h"
38#include "../main/headers.h"
39#include "CParseGeneral.h"
40#include "../scenegraph/Vector.h"
41#include "../vrml_parser/CFieldDecls.h"
42#include "../world_script/JScript.h"
43#include "../world_script/CScripts.h"
44#include "../world_script/fieldGet.h"
45#include "../world_script/fieldSet.h"
46#include "CParseParser.h"
47#include "CParseLexer.h"
48#include "../input/SensInterps.h"
49#include "../scenegraph/Component_ProgrammableShaders.h"
50#include "../input/EAIHeaders.h"
51#include "../input/EAIHelpers.h"
53#include "../opencl/OpenCL_Utils.h"
64static bool canRouteOnGPUTo(
struct X3D_Node *me);
168 void (*interpptr)(
void *);
188 cl_kernel CL_Interpolator;
198#define POSSIBLEINITIALROUTES 1000
207#define LOCK_PREROUTETABLE pthread_mutex_lock(&p->preRouteLock);
208#define UNLOCK_PREROUTETABLE pthread_mutex_unlock(&p->preRouteLock);
211#define MUTEX_LOCK_ROUTING_UPDATES pthread_mutex_lock(&p->insertRouteLock);
212#define MUTEX_FREE_LOCK_ROUTING_UPDATES pthread_mutex_unlock(&p->insertRouteLock);
221 int size_ClockEvents;
222 int CRoutes_Initiated;
225 int initialEventBeforeRoutesCount;
226 int preRouteTableSize;
228 pthread_mutex_t preRouteLock;
229 struct Vector* routesToRegister;
230 pthread_mutex_t insertRouteLock;
232 int thisIntTimeStamp;
237 struct Vector* ScriptControl;
246void *CRoutes_constructor(){
247 void *v = MALLOCV(
sizeof(
struct pCRoutes));
248 memset(v,0,
sizeof(
struct pCRoutes));
251void CRoutes_init(
struct tCRoutes *t){
254 t->CRoutesExtra = NULL;
256 t->max_script_found = -1;
257 t->max_script_found_and_initialized = -1;
259 t->MAXJSparamNames = 0;
262 t->prv = CRoutes_constructor();
266 p->size_ClockEvents = 1;
268 p->num_ClockEvents = 0;
269 p->CRoutes_Initiated = FALSE;
272 p->initialEventBeforeRoutesCount = 0;
273 p->preRouteTableSize = 0;
276 pthread_mutex_init(&(p->preRouteLock), NULL);
277 p->routesToRegister = NULL;
279 pthread_mutex_init(&(p->insertRouteLock), NULL);
281 p->thisIntTimeStamp = 1;
286 p->ScriptControl = newVector(
struct CRscriptControl*,0);
290 p->JSparamnames = NULL;
295void lock_and_do_routes_register();
300 lock_and_do_routes_register();
302 p->CRoutes_Count = 0;
304 FREE_IF_NZ(p->CRoutes);
308void CRoutes_clear(
struct tCRoutes *t){
312 FREE_IF_NZ(p->ClockEvents);
313 FREE_IF_NZ(p->preEvents);
325 return p->CRoutes_Count;
327int *getCRouteCounter(){
329 return &p->CRoutes_Count;
342void markScriptResults(
struct X3D_Node * tn,
int tptr,
int route,
void * tonode) {
349 printf (
"markScriptResults: can update this node %p %d\n",tn,tptr);
354 printf (
"markScriptResults: skipping this node %p %d flag %d\n",tn,tptr,p->CRoutes[route].direction_flag);
358 MARK_EVENT (p->CRoutes[route].routeFromNode,p->CRoutes[route].fnptr);
361 if (p->CRoutes[route].interpptr != 0) {
363 tg->CRoutes.CRoutesExtra = p->CRoutes[route].extra;
365 printf (
"script propagate_events. index %d is an interpolator\n",route);
367 p->CRoutes[route].interpptr(tonode);
372void AddRemoveSFNodeFieldChild(
387 if ((parent==NULL) || (child == NULL)) {
400 if ((ar == 0) || (ar == 1)) {
402 printf (
"we have to perform a \"set_child\" on this field\n");
406 if (*tn != NULL) remove_parent(*tn,parent);
410 ADD_PARENT(child,parent);
417 remove_parent(*tn,parent);
420 if ((*tn != NULL) && (child->referenceCount > 0)) {
421 ConsoleMessage (
".... ARSF, requested child to remove is %p %s ref %d as a child",child,stringNodeType(child->_nodeType),
422 child->referenceCount);
441unsigned long upper_power_of_two(
unsigned long v)
453unsigned long lower_power_of_two(
unsigned long v)
455 return upper_power_of_two(v - 1) / 2L;
458void AddRemoveChildren (
467 void *newmal, *oldmal;
477 printf (
"\n start of AddRemoveChildren; parent is a %s at %p\n",stringNodeType(parent->_nodeType),parent);
478 printf (
"AddRemove Children parent %p tn %p, len %d ar %d\n",parent,tn,len,ar);
479 printf (
"called at %s:%d\n",file,line);
486 if ((parent==0) || (tn == 0)) {
497 printf (
"AddRemoveChildren, len %d, oldlen %d ar %d\n",len, oldlen, ar);
503 printf (
"we have to perform a \"set_children\" on this field\n");
510 for (counter=0; counter < oldlen; counter ++) remove_parent(tn->p[counter],parent);
513 if (oldlen > 0) {FREE_IF_NZ(tn->p);}
524 unsigned long p2new, p2old;
525 unsigned long old_len = (unsigned)(oldlen);
526 unsigned long new_len = (unsigned)(oldlen+len);
527 p2new = upper_power_of_two(new_len);
528 p2old = upper_power_of_two(old_len);
543 unsigned long po2 = upper_power_of_two(new_len);
547 printf(
"[%d]{%u}",oldlen,upper_power_of_two(old_len));
550#if defined(DEBUG_MALLOC) && defined(DEBUG_MALLOC_LIST)
551 newmal = (
void*)freewrlMalloc(line, file, (po2)*
sizeof(
struct X3D_Node *), FALSE);
553 newmal = MALLOC (
void *, (po2)*
sizeof(
struct X3D_Node *));
557 if (newmal != NULL && oldlen > 0) memcpy (newmal,tn->p,oldlen*
sizeof(
void *));
574 tmpptr = offsetPointer_deref(
struct X3D_Node * *,newmal,
sizeof(
struct X3D_Node *) * oldlen);
577 for (counter = 0; counter < len; counter++) {
579 printf (
"AddRemove, count %d of %d, node %p parent %p\n",counter, len,nodelist[counter],parent);
581 if (tmpptr != NULL && nodelist[counter] != NULL) {
583 *tmpptr = nodelist[counter];
587 ADD_PARENT((
void *)nodelist[counter],(
void *)parent);
590 printf (
"AddRemoveChildren, Add, but new node is null; ignoring...\n");
610 for (c2 = 0; c2 < len; c2++) {
611 remptr = (
struct X3D_Node * *) tn->p;
614 for (counter = 0; counter < tn->n; counter ++) {
616 printf (
"remove, comparing %p with %p\n",*remptr, *remchild);
618 if ((*remptr == *remchild) && (!done)) {
620 printf (
"Found it! removing this child from this parent\n");
623 remove_parent(X3D_NODE(*remchild),parent);
635 finalLength = oldlen - num_removed;
637 printf (
"final length is %d, we have %d in original array\n", finalLength, tn->n);
638 remptr = (
struct X3D_Node * *) tn->p;
639 printf (
"so, the original array, with zeroed elements is: \n");
640 for (counter = 0; counter < tn->n; counter ++) {
641 printf (
"count %d of %d is %p\n",counter,tn->n, *remptr);
647 if (num_removed > 0) {
648 if (finalLength > 0) {
649 newmal = MALLOC (
void *, finalLength*
sizeof(
struct X3D_Node * *));
650 bzero (newmal, (
size_t)(finalLength*
sizeof(
struct X3D_Node * *)));
651 tmpptr = (
struct X3D_Node * *) newmal;
652 remptr = (
struct X3D_Node * *) tn->p;
655 for (counter = 0; counter < tn->n; counter ++) {
657 if (*remptr != NULL) {
677 printf (
"so, we have a final array length of %d\n",tn->n);
678 for (counter =0; counter <tn->n; counter ++) {
679 printf (
" element %d is %p\n",counter,tn->p[counter]);
696void kill_clockEvents() {
700 p->num_ClockEvents = 0;
702void do_ColorChaserTick(
void * ptr);
703void do_ColorDamperTick(
void * ptr);
704void do_CoordinateChaserTick(
void * ptr);
705void do_CoordinateDamperTick(
void * ptr);
706void do_OrientationChaserTick(
void * ptr);
707void do_OrientationDamperTick(
void * ptr);
708void do_PositionChaserTick(
void * ptr);
709void do_ColorDamperTick(
void * ptr);
710void do_PositionChaserTick(
void * ptr);
711void do_PositionDamperTick(
void * ptr);
712void do_PositionChaser2DTick(
void * ptr);
713void do_PositionDamper2DTick(
void * ptr);
714void do_ScalarChaserTick(
void * ptr);
715void do_ScalarDamperTick(
void * ptr);
716void do_TexCoordChaser2DTick(
void * ptr);
717void do_TexCoordDamper2DTick(
void * ptr);
718void do_CollisionSensorTick(
void * ptr);
720void add_first(
struct X3D_Node * node) {
727 printf (
"error in add_first; somehow the node datastructure is zero \n");
731 clocktype = node->_nodeType;
749 case NODE_TimeSensor: myp = do_TimeSensorTick;
break;
750 case NODE_ProximitySensor: myp = do_ProximitySensorTick;
break;
751 case NODE_Collision: myp = do_CollisionTick;
break;
752 case NODE_MovieTexture: myp = do_MovieTextureTick;
break;
753 case NODE_AudioClip: myp = do_AudioTick;
break;
754 case NODE_VisibilitySensor: myp = do_VisibilitySensorTick;
break;
755 case NODE_TransformSensor: myp = do_TransformSensorTick;
break;
756 case NODE_GeoProximitySensor: myp = do_GeoProximitySensorTick;
break;
757 case NODE_ColorChaser: myp = do_ColorChaserTick;
break;
758 case NODE_ColorDamper: myp = do_ColorDamperTick;
break;
759 case NODE_CoordinateChaser: myp = do_CoordinateChaserTick;
break;
760 case NODE_CoordinateDamper: myp = do_CoordinateDamperTick;
break;
761 case NODE_OrientationChaser: myp = do_OrientationChaserTick;
break;
762 case NODE_OrientationDamper: myp = do_OrientationDamperTick;
break;
763 case NODE_PositionChaser: myp = do_PositionChaserTick;
break;
764 case NODE_PositionDamper: myp = do_PositionDamperTick;
break;
765 case NODE_PositionChaser2D: myp = do_PositionChaser2DTick;
break;
766 case NODE_PositionDamper2D: myp = do_PositionDamper2DTick;
break;
767 case NODE_ScalarChaser: myp = do_ScalarChaserTick;
break;
768 case NODE_ScalarDamper: myp = do_ScalarDamperTick;
break;
769 case NODE_TexCoordChaser2D: myp = do_TexCoordChaser2DTick;
break;
770 case NODE_TexCoordDamper2D: myp = do_TexCoordDamper2DTick;
break;
771 case NODE_LinePickSensor: myp = do_PickSensorTick;
break;
772 case NODE_PointPickSensor: myp = do_PickSensorTick;
break;
773 case NODE_PrimitivePickSensor: myp = do_PickSensorTick;
break;
774 case NODE_VolumePickSensor: myp = do_PickSensorTick;
break;
775 case NODE_CollisionSensor: myp = do_CollisionSensorTick;
break;
781 if (p->num_ClockEvents + 1 > p->size_ClockEvents){
790 memcpy(ce, p->ClockEvents, sizeof (
struct FirstStruct) * p->num_ClockEvents);
792 p->size_ClockEvents *= 2;
793 old_ce = p->ClockEvents;
799 if (p->ClockEvents == 0) {
800 printf (
"can not allocate memory for add_first call\n");
801 p->num_ClockEvents = 0;
805 for (count=0; count < p->num_ClockEvents; count ++) {
806 if (p->ClockEvents[count].tonode == node) {
813 for (count=0; count < p->num_ClockEvents; count ++) {
814 if (p->ClockEvents[count].tonode == NULL) {
816 p->ClockEvents[count].interpptr = myp;
817 p->ClockEvents[count].tonode = node;
824 p->ClockEvents[p->num_ClockEvents].interpptr = myp;
825 p->ClockEvents[p->num_ClockEvents].tonode = node;
827 p->num_ClockEvents++;
831void delete_first(
struct X3D_Node *node) {
835 if (p->ClockEvents) {
836 for (count=0; count < p->num_ClockEvents; count ++) {
837 if (p->ClockEvents[count].tonode == node) {
838 p->ClockEvents[count].tonode = NULL;
857void CRoutes_RegisterSimple(
864 void* interpolatorPointer;
869 switch (from->_nodeType) {
871 case NODE_ComposedShader:
873 case NODE_PackagedShader:
875 case NODE_ProgramShader:
876 dir = dir | FROM_SCRIPT;
break;
879 switch (to->_nodeType) {
881 case NODE_ComposedShader:
883 case NODE_PackagedShader:
885 case NODE_ProgramShader:
886 dir = dir | TO_SCRIPT;
break;
891 if (dir!=SCRIPT_TO_SCRIPT && dir!=TO_SCRIPT) {
893 if (to->_nodeType == NODE_StaticGroup) {
894 ConsoleMessage (
"ROUTE to a StaticGroup not allowed");
899 if (dir!=SCRIPT_TO_SCRIPT && dir!=FROM_SCRIPT) {
901 if (from->_nodeType == NODE_StaticGroup) {
902 ConsoleMessage (
"ROUTE from a StaticGroup not allowed");
908 if(dir!=SCRIPT_TO_SCRIPT && dir!=TO_SCRIPT)
909 interpolatorPointer=returnInterpolatorPointer(to->_nodeType);
911 interpolatorPointer=NULL;
912 CRoutes_Register(1, from, fromOfs, to,toOfs, type, interpolatorPointer, dir, NULL);
914int usesBuiltin(
struct X3D_Node* node){
918 switch(node->_nodeType){
920 case NODE_ComposedShader:
922 case NODE_ShaderProgram :
923 case NODE_PackagedShader:
932void CRoutes_RegisterSimpleB(
933 struct X3D_Node* from,
int fromIndex,
int fromBuiltIn,
934 struct X3D_Node* to,
int toIndex,
int toBuiltIn,
941 if(usesBuiltin(from) != fromBuiltIn)
942 printf(
"error usesBuiltin(from) != fromBuiltin\n");
943 if(usesBuiltin(to) != toBuiltIn)
944 printf(
"error usesBuiltin(to) != toBuiltin\n");
947 fromOfs = NODE_OFFSETS[(from)->_nodeType][fromIndex*FIELDOFFSET_LENGTH + 1];
951 toOfs = NODE_OFFSETS[(to)->_nodeType][toIndex*FIELDOFFSET_LENGTH + 1];
952 CRoutes_RegisterSimple(from,fromOfs,to,toOfs,type);
963void CRoutes_RemoveSimple(
969 void* interpolatorPointer;
971 interpolatorPointer=returnInterpolatorPointer(to->_nodeType);
973 CRoutes_Register(0, from, fromOfs, to, toOfs, type,
974 interpolatorPointer, 0, NULL);
977void CRoutes_RemoveSimpleB(
struct X3D_Node* from,
int fromIndex,
int fromBuiltIn,
978 struct X3D_Node* to,
int toIndex,
int toBuiltIn,
int len){
985 fromOfs = NODE_OFFSETS[(from)->_nodeType][fromIndex*FIELDOFFSET_LENGTH + 1];
989 toOfs = NODE_OFFSETS[(to)->_nodeType][toIndex*FIELDOFFSET_LENGTH + 1];
991 CRoutes_RemoveSimple(from,fromOfs,to,toOfs,len);
1003void CRoutes_Register(
1018 cl_kernel CL_Interpolator = NULL;
1019 ConsoleMessage (
"CRoutes_Register, being run on :%s:\n",__DATE__);
1045 if (from->_nodeType == NODE_CoordinateInterpolator) {
1049 if (incr == 0) incr = -1;
1052 if (to->_nodeType == NODE_Coordinate) {
1054 if (canRouteOnGPUTo(to) ) {
1057 p = (ppOpenCL_Utils)tg->OpenCL_Utils.prv;
1059 px ->_GPU_Routes_out += incr;
1061 if (tg->OpenCL_Utils.OpenCL_Initialized) {
1062 printf (
"OpenCL initialized in routes\n");
1064 printf(
"OPENCL NOT INITIALIZED YET\n");
1067 while (!tg->OpenCL_Utils.OpenCL_Initialized) {
1069 printf (
"sleeping, waiting for CL to be initialized\n");
1074 CL_Interpolator = p->coordinateInterpolatorKernel;
1076 printf (
"CRoutes Register, have a CoordinateInterpolator to Coordinate, but dest node type not supported yet\n");
1077 px->_CPU_Routes_out+= incr;
1081 px->_CPU_Routes_out += incr;
1084 px->_CPU_Routes_out += incr;
1088 MUTEX_LOCK_ROUTING_UPDATES
1090 if (p->routesToRegister == NULL) {
1091 p->routesToRegister = newVector(
struct CR_RegStruct *, 16);
1096 newEntry->adrem = adrem;
1097 newEntry->from = from;
1098 newEntry->fromoffset = fromoffset;
1100 newEntry->toOfs = toOfs;
1101 newEntry->fieldType = type;
1102 newEntry->intptr = intptr;
1103 newEntry->scrdir = scrdir;
1104 newEntry->extra = extra;
1106 newEntry->CL_Interpolator = CL_Interpolator;
1109 vector_pushBack(
struct CR_RegStruct *, p->routesToRegister, newEntry);
1111 MUTEX_FREE_LOCK_ROUTING_UPDATES
1114void free_routes_to_register(
struct Vector * routesToRegister){
1116 if(routesToRegister){
1119 for(i=0;i<vectorSize(routesToRegister);i++){
1120 r = vector_get(
struct CR_RegStruct*,routesToRegister,i);
1124 FREE_IF_NZ(routesToRegister);
1128void print_routes_ready_to_register(FILE* fp)
1141 if(p->routesToRegister == NULL)
return;
1142 numRoutes = vectorSize(p->routesToRegister);
1143 fprintf(fp,
"Number of Routes Ready to Register %d\n",numRoutes);
1144 if (numRoutes < 1) {
1148 for (count = 0; count < (numRoutes); count++) {
1149 entry = vector_get(
struct CR_RegStruct *, p->routesToRegister, count);
1150 fromNode = entry->from;
1151 fromOffset = entry->fromoffset;
1153 toOffset = entry->toOfs;
1154 fromName = parser_getNameFromNode(fromNode);
1155 toName = parser_getNameFromNode(toNode);
1156 fprintf (fp,
" %p %s.%s TO %p %s.%s \n",fromNode,fromName,
1157 findFIELDNAMESfromNodeOffset0(fromNode,fromOffset),
1159 findFIELDNAMESfromNodeOffset0(toNode,toOffset)
1165static void actually_do_CRoutes_Register() {
1166 int insert_here, check_here, shifter, isDuplicate;
1173 if (p->routesToRegister == NULL)
return;
1176 printf (
"actually_do_CRoutes_Register, vector size %d\n",vectorSize(p->routesToRegister));
1179 for (ind=0; ind<vectorSize(p->routesToRegister); ind++ ) {
1182 newEntry = vector_get(
struct CR_RegStruct *, p->routesToRegister, ind);
1185 printf (
"CRoutes_Register adrem %d from %u ",newEntry->adrem, newEntry->from);
1188 printf (
"off %u to %u intptr %p\n",
1189 newEntry->fromoffset, newEntry->to, newEntry->intptr);
1190 printf (
"CRoutes_Register, CRoutes_Count is %d\n",p->CRoutes_Count);
1194 if (!p->CRoutes_Initiated) {
1196 p->CRoutes_MAX = 25;
1197 p->CRoutes = MALLOC (
struct CRStruct *,
sizeof (*p->CRoutes) * p->CRoutes_MAX);
1199 p->CRoutes[0].routeFromNode = X3D_NODE(0);
1200 p->CRoutes[0].fnptr = 0;
1201 p->CRoutes[0].tonode_count = 0;
1202 p->CRoutes[0].tonodes = NULL;
1203 p->CRoutes[0].isActive = FALSE;
1204 p->CRoutes[0].interpptr = 0;
1205 p->CRoutes[0].intTimeStamp = 0;
1206 p->CRoutes[1].routeFromNode = X3D_NODE(-1);
1207 p->CRoutes[1].fnptr = 0x8FFFFFFF;
1208 p->CRoutes[1].tonode_count = 0;
1209 p->CRoutes[1].tonodes = NULL;
1210 p->CRoutes[1].isActive = FALSE;
1211 p->CRoutes[1].interpptr = 0;
1212 p->CRoutes[1].intTimeStamp = 0;
1213 p->CRoutes_Count = 2;
1214 p->CRoutes_Initiated = TRUE;
1217 p->CRoutes[0].CL_Interpolator = NULL;
1218 p->CRoutes[1].CL_Interpolator = NULL;
1225 while (newEntry->from > p->CRoutes[insert_here].routeFromNode) {
1227 printf (
"comparing %u to %u\n",newEntry->from, p->CRoutes[insert_here].routeFromNode);
1234 while ((newEntry->from == p->CRoutes[insert_here].routeFromNode) &&
1235 (newEntry->fromoffset > p->CRoutes[insert_here].fnptr)) {
1237 printf (
"same routeFromNode, different offset\n");
1247 printf (
"ok, CRoutes_Register - is this a duplicate? comparing from (%d %d), fnptr (%d %d) intptr (%d %d) and tonodes %d\n",
1248 p->CRoutes[insert_here].routeFromNode, newEntry->from,
1249 p->CRoutes[insert_here].fnptr, newEntry->fromoffset,
1250 p->CRoutes[insert_here].interpptr, newEntry->intptr,
1251 p->CRoutes[insert_here].tonodes);
1254 check_here = insert_here;
1256 while ((p->CRoutes[check_here].routeFromNode==newEntry->from) &&
1257 (p->CRoutes[check_here].fnptr==newEntry->fromoffset) &&
1258 (newEntry->adrem == 0 || p->CRoutes[check_here].interpptr==newEntry->intptr) &&
1259 (p->CRoutes[check_here].tonodes!=0)) {
1262 toof = newEntry->toOfs;
1264 if ((toN == (p->CRoutes[check_here].tonodes)->routeToNode) &&
1265 (toof == (p->CRoutes[check_here].tonodes)->foffset)) {
1269 printf (
"duplicate route; maybe this is a remove? \n");
1273 if (newEntry->adrem == 1) {
1275 printf (
"definite duplicate, returning\n");
1282 FREE_IF_NZ(p->CRoutes[check_here].tonodes);
1283 for (shifter = check_here; shifter < p->CRoutes_Count; shifter++) {
1285 printf (
"copying from %d to %d\n",shifter, shifter-1);
1287 memcpy ((
void *)&p->CRoutes[shifter],
1288 (
void *)&p->CRoutes[shifter+1],
1291 p->CRoutes_Count --;
1293 printf (
"routing table now %d\n",p->CRoutes_Count);
1294 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1295 printf (
"%d: %u %u %u\n",shifter, p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1296 p->CRoutes[shifter].interpptr);
1307 if (newEntry->adrem == 1 && !isDuplicate) {
1309 printf (
"CRoutes, inserting at %d\n",insert_here);
1313 for (shifter = p->CRoutes_Count; shifter > insert_here; shifter--) {
1314 memcpy ((
void *)&p->CRoutes[shifter], (
void *)&p->CRoutes[shifter-1],
sizeof(
struct CRStruct));
1316 printf (
"Copying from index %d to index %d\n",shifter, shifter-1);
1322 p->CRoutes[insert_here].routeFromNode = newEntry->from;
1323 p->CRoutes[insert_here].fnptr = newEntry->fromoffset;
1324 p->CRoutes[insert_here].isActive = FALSE;
1325 p->CRoutes[insert_here].tonode_count = 0;
1326 p->CRoutes[insert_here].tonodes = NULL;
1327 p->CRoutes[insert_here].len = returnRoutingElementLength(newEntry->fieldType);
1328 p->CRoutes[insert_here].interpptr = (void (*)(
void*))newEntry->intptr;
1329 p->CRoutes[insert_here].direction_flag = newEntry->scrdir;
1330 p->CRoutes[insert_here].extra = newEntry->extra;
1331 p->CRoutes[insert_here].intTimeStamp = 0;
1333 p->CRoutes[insert_here].CL_Interpolator = newEntry->CL_Interpolator;
1337 if ((p->CRoutes[insert_here].tonodes =
1339 fprintf(stderr,
"CRoutes_Register: calloc failed to allocate memory.\n");
1341 p->CRoutes[insert_here].tonode_count = 1;
1344 to_ptr = &(p->CRoutes[insert_here].tonodes[0]);
1345 to_ptr->routeToNode = newEntry->to;
1346 to_ptr->foffset = newEntry->toOfs;
1350 if (p->CRoutes_Count >= (p->CRoutes_MAX-2)) {
1352 p->CRoutes_MAX += 50;
1353 p->CRoutes =(
struct CRStruct *) REALLOC (p->CRoutes, sizeof (*p->CRoutes) * p->CRoutes_MAX);
1356 p->CRoutes_Count ++;
1359 printf (
"routing table now %d\n",p->CRoutes_Count);
1360 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1361 printf (
"%d: from: %p offset: %u Interpolator %p direction %d, len %d extra %p : ",shifter,
1362 p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1363 p->CRoutes[shifter].interpptr, p->CRoutes[shifter].direction_flag, p->CRoutes[shifter].len, p->CRoutes[shifter].extra);
1364 for (insert_here = 0; insert_here < p->CRoutes[shifter].tonode_count; insert_here++) {
1365 printf (
" to: %p %u",p->CRoutes[shifter].tonodes[insert_here].routeToNode,
1366 p->CRoutes[shifter].tonodes[insert_here].foffset);
1374 free_routes_to_register(p->routesToRegister);
1375 p->routesToRegister = NULL;
1377 printf (
"routing table now %d\n",p->CRoutes_Count);
1378 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1379 printf (
"%3d from: %p offset: %u Interp %p dir %d, len %d extra %p :\n",shifter,
1380 p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1381 p->CRoutes[shifter].interpptr, p->CRoutes[shifter].direction_flag, p->CRoutes[shifter].len, p->CRoutes[shifter].extra);
1382 for (insert_here = 0; insert_here < p->CRoutes[shifter].tonode_count; insert_here++) {
1383 printf (
" to: %p %u\n",p->CRoutes[shifter].tonodes[insert_here].routeToNode,
1384 p->CRoutes[shifter].tonodes[insert_here].foffset);
1390void lock_and_do_routes_register()
1393 MUTEX_LOCK_ROUTING_UPDATES
1394 actually_do_CRoutes_Register();
1395 MUTEX_FREE_LOCK_ROUTING_UPDATES
1399#ifdef DEBUG_VALIDNODE
1401void mark_event_check (
struct X3D_Node *from,
int totalptr,
char *fn,
int line) {
1402 printf (
"mark_event_check: at %s:%d\n",fn,line);
1403 if (X3D_NODE_CHECK(from)) {
1405 printf (
"mark_event_check, routing from a %s\n",stringNodeType(from->_nodeType));
1408 printf (
"mark_event_check, not a real node %d\n",from);
1410 mark_event(from,totalptr);
1411 printf (
"mark_event_check: finished at %s:%d\n",fn,line);
1423void mark_event (
struct X3D_Node *from,
int totalptr) {
1427 if(from == 0)
return;
1430 X3D_NODE_CHECK(from);
1433 if (!p->CRoutes_Initiated) {
1436 if (p->initialEventBeforeRoutesCount >= p->preRouteTableSize) {
1437 p->preRouteTableSize += POSSIBLEINITIALROUTES;
1438 p->preEvents=REALLOC (p->preEvents,
1441 p->preEvents[p->initialEventBeforeRoutesCount].from = from;
1442 p->preEvents[p->initialEventBeforeRoutesCount].totalptr = totalptr;
1443 p->initialEventBeforeRoutesCount++;
1444 UNLOCK_PREROUTETABLE
1452 printf (
"\nmark_event, from %s (%u) fromoffset %u\n", stringNodeType(from->_nodeType),from, totalptr);
1457 while (from > p->CRoutes[findit].routeFromNode) {
1459 printf (
"mark_event, skipping past %x %x, index %d\n",from, p->CRoutes[findit].routeFromNode, findit);
1466 while ((from == p->CRoutes[findit].routeFromNode) &&
1467 (totalptr != p->CRoutes[findit].fnptr)) findit ++;
1471 printf (
"ep, (%#x %#x) (%#x %#x) at %d \n",
1472 from,p->CRoutes[findit].routeFromNode, totalptr,
1473 p->CRoutes[findit].fnptr,findit);
1478 while ((from == p->CRoutes[findit].routeFromNode) &&
1479 (totalptr == p->CRoutes[findit].fnptr)) {
1481 printf (
"found event at %d\n",findit);
1483 if (p->CRoutes[findit].intTimeStamp!=p->thisIntTimeStamp) {
1484 p->CRoutes[findit].isActive=TRUE;
1485 p->CRoutes[findit].intTimeStamp=p->thisIntTimeStamp;
1489 else printf (
"routing loop broken, findit %d\n",findit);
1495 printf (
"done mark_event\n");
1500void mark_event_B (
struct X3D_Node *lastFrom,
int lastptr,
struct X3D_Node *from,
int totalptr) {
1504 if(from == 0)
return;
1507 X3D_NODE_CHECK(from);
1510 if (!p->CRoutes_Initiated) {
1513 if (p->initialEventBeforeRoutesCount >= p->preRouteTableSize) {
1514 p->preRouteTableSize += POSSIBLEINITIALROUTES;
1515 p->preEvents=REALLOC (p->preEvents,
1518 p->preEvents[p->initialEventBeforeRoutesCount].from = from;
1519 p->preEvents[p->initialEventBeforeRoutesCount].totalptr = totalptr;
1520 p->initialEventBeforeRoutesCount++;
1521 UNLOCK_PREROUTETABLE
1529 printf (
"\nmark_event, from %s (%u) fromoffset %u\n", stringNodeType(from->_nodeType),from, totalptr);
1534 while (from > p->CRoutes[findit].routeFromNode) {
1536 printf (
"mark_event, skipping past %x %x, index %d\n",from, p->CRoutes[findit].routeFromNode, findit);
1543 while ((from == p->CRoutes[findit].routeFromNode) &&
1544 (totalptr != p->CRoutes[findit].fnptr)) findit ++;
1548 printf (
"ep, (%#x %#x) (%#x %#x) at %d \n",
1549 from,p->CRoutes[findit].routeFromNode, totalptr,
1550 p->CRoutes[findit].fnptr,findit);
1555 while ((from == p->CRoutes[findit].routeFromNode) &&
1556 (totalptr == p->CRoutes[findit].fnptr)) {
1559 printf (
"found event at %d\n",findit);
1561 isCycle = (p->CRoutes[findit].tonodes[0].routeToNode == lastFrom &&
1562 p->CRoutes[findit].tonodes[0].foffset == lastptr);
1564 if (p->CRoutes[findit].intTimeStamp!=p->thisIntTimeStamp) {
1565 p->CRoutes[findit].isActive=TRUE;
1566 p->CRoutes[findit].intTimeStamp=p->thisIntTimeStamp;
1570 else printf (
"routing loop broken, findit %d\n",findit);
1576 printf (
"done mark_event\n");
1593 return vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1596void setScriptControlIndex(
int actualscript,
struct CRscriptStruct *sc){
1598 vector_set(
struct CRscriptStruct*,p->ScriptControl,actualscript,sc);
1600int isScriptControlOK(
int actualscript)
1604 cs = vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1606 return cs->scriptOK;
1608int isScriptControlInitialized(
int actualscript)
1614 if(actualscript < p->JSMaxScript){
1615 cs = vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1617 if(cs->_initialized) ret = TRUE;
1622int loadstatus_Script(
struct X3D_Script *script){
1625 if(script->__scriptObj){
1626 struct Shader_Script * shader=X3D_SCRIPT(script)->__scriptObj;
1627 istate = isScriptControlInitialized(shader->num);
1632void initializeAnyScripts()
1650 if( tg->CRoutes.max_script_found != tg->CRoutes.max_script_found_and_initialized)
1654 for (i=tg->CRoutes.max_script_found_and_initialized+1; i <= tg->CRoutes.max_script_found; i++)
1657 JSCreateScriptContext(i);
1658 JSInitializeScriptAndFields(i);
1659 ScriptControl = getScriptControlIndex(i);
1660 if (ScriptControl->scriptOK)
1661 jsActualrunScript(i,
"initialize()");
1665 tg->CRoutes.max_script_found_and_initialized = tg->CRoutes.max_script_found;
1678void CRoutes_js_new (
int num,
int scriptType) {
1686 cs->thisScriptType = scriptType;
1689 if (num > tg->CRoutes.max_script_found) tg->CRoutes.max_script_found = num;
1701void mark_script (
int num) {
1710 getScriptControlIndex(num)->scr_act = TRUE;
1725 int JSparamNameIndex,
int type,
int extra,
int len) {
1737 int touched_flag=FALSE;
1768 if(shader->num > -1 && shader->loaded){
1769 actualscript = shader->num;
1776 if(!isScriptControlInitialized(actualscript)){
1781 if (actualscript > tg->CRoutes.max_script_found_and_initialized) {
1787 if(!isScriptControlOK(actualscript)){
1816 touched_flag = get_valueChanged_flag((
int)JSparamNameIndex,actualscript);
1819 if (touched_flag!= 0) {
1832 js_setField_javascriptEventOut_B(any,type, len, extra,
1848 resetScriptTouchedFlag ((
int) actualscript, (
int) JSparamNameIndex);
1870 printf (
"%f finished gatherScriptEventOuts loop\n",TickTime());
1875void JSparamnamesShutdown(){
1879 FREE_IF_NZ(p->JSparamnames);
1880 tg->CRoutes.jsnameindex = -1;
1881 tg->CRoutes.MAXJSparamNames = 0;
1884void kill_javascript(
void) {
1890 printf (
"calling kill_javascript()\n");
1891 zeroScriptHandles();
1892 if (jsIsRunning() != 0) {
1893 for (i=0; i<=tg->CRoutes.max_script_found_and_initialized; i++) {
1895 ScriptControl = getScriptControlIndex(i);
1897 if (ScriptControl->cx != 0) {
1898 JSDeleteScriptContext(i);
1900 setScriptControlIndex(i,NULL);
1905 tg->CRoutes.max_script_found = -1;
1906 tg->CRoutes.max_script_found_and_initialized = -1;
1908 JSparamnamesShutdown();
1914 printf (
"done kill_javascript\n");
1918void cleanupDie(
int num,
const char *msg) {
1926 sc->thisScriptType = NOSCRIPT;
1927 sc->eventsProcessed = NULL;
1930 sc->_initialized = FALSE;
1931 sc->scriptOK = FALSE;
1932 sc->scriptText = NULL;
1933 sc->paramList = NULL;
1980void JSMaxAlloc2(
int num){
1983 if(!p->ScriptControl)
1986 if(p->ScriptControl->allocn <= num){
1989 istart = p->ScriptControl->allocn;
1990 iend = upper_power_of_two(num+1);
1991 p->ScriptControl->data = REALLOC(p->ScriptControl->data,iend*
sizeof(
struct CRscriptStruct *));
1992 p->ScriptControl->allocn = iend;
1993 p->JSMaxScript = p->ScriptControl->allocn;
1997 for(i=istart;i<iend;i++)
2001int unInitializeScript(
struct X3D_Node *node){
2003 if(node && node->_nodeType == NODE_Script){
2011 count = sscript->num;
2012 ScriptControl = getScriptControlIndex(count);
2013 if (ScriptControl->cx != 0)
2014 JSDeleteScriptContext(count);
2015 setScriptControlIndex(count,NULL);
2016 FREE_IF_NZ(ScriptControl);
2027 #ifdef JAVASCRIPTVERBOSE
2028 printf(
"JSinit: script %d\n",num);
2032 if (script->num >= p->JSMaxScript) {
2033 JSMaxAlloc2(script->num);
2035 cs = newScriptControl();
2036 setScriptControlIndex(script->num,cs);
2038 cs->script = script;
2043void SaveScriptText(
int num,
const char *text) {
2049 if (num >= p->JSMaxScript) {
2050 ConsoleMessage (
"SaveScriptText: warning, script %d initialization out of order",num);
2053 ScriptControl = getScriptControlIndex(num);
2054 FREE_IF_NZ(ScriptControl->scriptText);
2055 ScriptControl->scriptText = STRDUP(text);
2058 jsClearScriptControlEntries(num);
2060 if (((
int)num) > tg->CRoutes.max_script_found) tg->CRoutes.max_script_found = num;
2069 return p->JSparamnames;
2074 p->JSparamnames = JSparamnames;
2085int JSparamIndex (
const char *name,
const char *type,
int mod) {
2093 printf (
"start of JSparamIndex, name %s, type %s\n",name,type);
2094 printf (
"start of JSparamIndex, lengths name %d, type %d\n",
2095 strlen(name),strlen(type));
2098 ty = findFieldInFIELDTYPES(type);
2101 printf (
"JSparamIndex, type %d, %s\n",ty,type);
2108 for (ctr=0; ctr<=tg->CRoutes.jsnameindex; ctr++) {
2109 if (ty==JSparamnames[ctr].type) {
2110 if ((strlen(JSparamnames[ctr].name) == len) &&
2111 (strncmp(name,JSparamnames[ctr].name,len)==0)) {
2113 printf (
"JSparamIndex, duplicate, returning %d\n",ctr);
2123 tg->CRoutes.jsnameindex ++;
2126 if (tg->CRoutes.jsnameindex >= tg->CRoutes.MAXJSparamNames) {
2128 tg->CRoutes.MAXJSparamNames += 100;
2129 setJSparamnames( (
struct CRjsnameStruct*)REALLOC (JSparamnames,
sizeof(*JSparamnames) * tg->CRoutes.MAXJSparamNames));
2130 JSparamnames = getJSparamnames();
2133 if (len > MAXJSVARIABLELENGTH-2) len = MAXJSVARIABLELENGTH-2;
2134 strncpy (JSparamnames[tg->CRoutes.jsnameindex].name,name,len);
2135 JSparamnames[tg->CRoutes.jsnameindex].name[len] = 0;
2136 JSparamnames[tg->CRoutes.jsnameindex].type = ty;
2137 JSparamnames[tg->CRoutes.jsnameindex].kind = mod;
2138 JSparamnames[tg->CRoutes.jsnameindex].eventInFunction = NULL;
2140 printf (
"JSparamIndex, returning %d\n",tg->JScript.jsnameindex);
2143 return tg->CRoutes.jsnameindex;
2159char * BOOL_STRING(
int inp) {
if (inp)
return "true ";
else return "false ";}
2173union anyVrml* get_anyVrml(
struct X3D_Node* node,
int offset,
int *type,
int *mode)
2177 int fromMode, fromType, fromOffset;
2179 fromType = INT_ID_UNDEFINED;
2180 fromMode = INT_ID_UNDEFINED;
2181 fromOffset = offset;
2184 switch(node->_nodeType)
2186 case NODE_ShaderProgram:
2187 case NODE_ComposedShader:
2188 case NODE_PackagedShader:
2194 switch(fromNode->_nodeType)
2196 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(fromNode)->__scriptObj);
break;
2197 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2198 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(fromNode)->_shaderUserDefinedFields);
break;
2199 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(fromNode)->_shaderUserDefinedFields);
break;
2200 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2202 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, fromOffset);
2203 fromAny = &sfield->value;
2204 fromType = sfield->fieldDecl->fieldType;
2205 fromMode = sfield->fieldDecl->PKWmode;
2214 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, fromOffset);
2215 fromAny = &pfield->defaultVal;
2216 fromType = pfield->type;
2217 fromMode = pfield->mode;
2222 const int * offsets;
2224 fromAny = (
union anyVrml*)offsetPointer_deref(
void *,fromNode , fromOffset);
2226 offsets = NODE_OFFSETS[fromNode->_nodeType];
2227 while(*offsets > -1)
2230 if(offsets[1]==fromOffset)
2232 fromType = offsets[2];
2233 fromMode = PKW_from_KW(offsets[3]);
2236 offsets += FIELDOFFSET_LENGTH;
2246void cleanFieldIfManaged(
int type,
int mode,BOOL isPublic,
struct X3D_Node* parent,
int offset)
2260 if(isManagedField(mode,type,isPublic))
2262 int n,k,haveSomething,fromType,fromMode;
2265 any = get_anyVrml(parent,offset,&fromType,&fromMode);
2266 haveSomething = (type==FIELDTYPE_SFNode && any->sfnode) || (type==FIELDTYPE_MFNode && any->mfnode.n);
2267 haveSomething = haveSomething && parent;
2269 if(type==FIELDTYPE_SFNode){
2270 plist = &any->sfnode;
2273 plist = any->mfnode.p;
2279 remove_parent(sfn,parent);
2281 sfn->referenceCount--;
2283 if(type==FIELDTYPE_MFNode) {
2291void add_mfparents(
struct X3D_Node* newParent,
union anyVrml* mfnode,
int mftype)
2294 if(mftype != FIELDTYPE_MFNode)
return;
2295 for(i=0;i<mfnode->mfnode.n;i++)
2297 add_parent(mfnode->mfnode.p[i],newParent,__FILE__,__LINE__);
2312char *findFIELDNAMES0(
struct X3D_Node *node,
int offset);
2315const char *stringMode(
int pkwmode,
int cute){
2316 const char **strmode;
2317 const char *cutemode[] = {
"init",
"in",
"out",
"inOut" };
2318 const char *fullmode[] = {
"initializeOnly",
"inputOnly",
"outputOnly",
"inputOutput"};
2320 if(cute) strmode = cutemode;
2324 case PKW_initializeOnly:
2326 case PKW_inputOutput:
2330 case PKW_outputOnly:
2337void print_field_value(FILE *fp,
int typeIndex,
union anyVrml* value);
2339void propagate_events_B() {
2344 union anyVrml *fromAny, *toAny;
2345 struct X3D_Node *fromNode, *toNode, *lastFromNode;
2346 int fromOffset, toOffset, lastFromOffset, last_markme;
2351 int len, isize, type, sftype, isMF, itime, nRoutesDone, modeFrom, modeTo, debugRoutes;
2359 printf (
"\npropagate_events start\n");
2362 type = INT_ID_UNDEFINED;
2365 p->thisIntTimeStamp ++;
2366 lastFromOffset = -1;
2367 lastFromNode = NULL;
2368 last_markme = FALSE;
2372 printf(
"current time=%d routecount=%d\n",p->thisIntTimeStamp,p->CRoutes_Count);
2377 for (counter = 1; counter < p->CRoutes_Count-1; counter++) {
2380 fromNode = p->CRoutes[counter].routeFromNode;
2381 fromOffset = p->CRoutes[counter].fnptr;
2382 itime = p->CRoutes[counter].intTimeStamp;
2383 switch(fromNode->_nodeType)
2385 case NODE_ShaderProgram:
2386 case NODE_ComposedShader:
2388 case NODE_PackagedShader:
2394 switch(fromNode->_nodeType)
2396 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(fromNode)->__scriptObj);
break;
2397 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2398 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(fromNode)->_shaderUserDefinedFields);
break;
2399 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(fromNode)->_shaderUserDefinedFields);
break;
2400 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2402 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, fromOffset);
2403 fromAny = &sfield->value;
2405 type = sfield->fieldDecl->fieldType;
2407 sftype = type - isMF;
2410 isize = sizeofSForMF(sftype);
2411 if(isMF) len =
sizeof(int) +
sizeof(
void*);
2413 modeFrom = sfield->fieldDecl->PKWmode;
2416 if(fromNode->_nodeType == NODE_Script){
2420 markme = last_markme;
2421 if(!(fromNode==lastFromNode && fromOffset==lastFromOffset)){
2423 if(SM_method() == 0){
2425 int JSparamNameIndex = sfield->fieldDecl->JSparamNameIndex;
2426 markme = gatherScriptEventOut_B(fromAny,shader,JSparamNameIndex,type,0,len);
2431 markme = sfield->valueChanged;
2433 sfield->valueChanged = 0;
2438 if (p->CRoutes[counter].intTimeStamp!=p->thisIntTimeStamp) {
2439 p->CRoutes[counter].isActive=TRUE;
2440 p->CRoutes[counter].intTimeStamp=p->thisIntTimeStamp;
2443 last_markme = markme;
2455 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, fromOffset);
2456 fromAny = &pfield->defaultVal;
2457 type = pfield->type;
2458 modeFrom = pfield->mode;
2463 const int * offsets;
2465 fromAny = (
union anyVrml*)offsetPointer_deref(
void *,fromNode , fromOffset);
2467 offsets = NODE_OFFSETS[fromNode->_nodeType];
2468 while(*offsets > -1)
2471 if(offsets[1]==fromOffset)
2474 modeFrom = PKW_from_KW(offsets[3]);
2477 offsets += FIELDOFFSET_LENGTH;
2485 sftype = type - isMF;
2488 isize = sizeofSForMF(sftype);
2489 if(isMF) len =
sizeof(int) +
sizeof(
void*);
2494 for (to_counter = 0; to_counter < p->CRoutes[counter].tonode_count; to_counter++) {
2495 modeTo = PKW_inputOnly;
2496 to_ptr = &(p->CRoutes[counter].tonodes[to_counter]);
2497 if (to_ptr == NULL) {
2498 printf(
"WARNING: tonode at %u is NULL in propagate_events.\n",
2504 printf(
"propagate_events: counter %d to_counter %u act %s from %u off %u to %u off %u oint %u dir %d\n",
2505 counter, to_counter, BOOL_STRING(p->CRoutes[counter].isActive),
2506 p->CRoutes[counter].routeFromNode, p->CRoutes[counter].fnptr,
2507 to_ptr->routeToNode, to_ptr->foffset, p->CRoutes[counter].interpptr,
2508 p->CRoutes[counter].direction_flag);
2511 if (p->CRoutes[counter].isActive == TRUE) {
2513 p->CRoutes[counter].isActive = FALSE;
2521 toNode = to_ptr->routeToNode;
2522 toOffset = to_ptr->foffset;
2526 if (toNode != NULL) {
2527 switch(toNode->_nodeType)
2529 case NODE_ShaderProgram:
2530 case NODE_ComposedShader:
2531 case NODE_PackagedShader:
2537 switch(toNode->_nodeType)
2539 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(toNode)->__scriptObj);
break;
2540 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(toNode)->_shaderUserDefinedFields);
break;
2541 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(toNode)->_shaderUserDefinedFields);
break;
2542 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(toNode)->_shaderUserDefinedFields);
break;
2543 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(toNode)->_shaderUserDefinedFields);
break;
2545 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, toOffset);
2546 toAny = &sfield->value;
2547 modeTo = sfield->fieldDecl->PKWmode;
2555 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, toOffset);
2556 toAny = &pfield->defaultVal;
2557 modeTo = pfield->mode;
2561 toAny = (
union anyVrml*)offsetPointer_deref(
void *,toNode , toOffset);
2564 const int *offsets = NODE_OFFSETS[toNode->_nodeType];
2565 while(*offsets > -1)
2568 if(offsets[1]==fromOffset)
2570 modeTo = PKW_from_KW(offsets[3]);
2573 offsets += FIELDOFFSET_LENGTH;
2591 if (toNode != NULL) {
2592 cleanFieldIfManaged(type,modeTo,1,toNode,toOffset);
2594 shallow_copy_field(type,fromAny,toAny);
2597 registerParentIfManagedField(type,modeTo,1, toAny, toNode);
2604 mark_event_B(fromNode,fromOffset, toNode, toOffset);
2609 char *fromName, *toName, *fromFieldName, *toFieldName, *fromModeName, *toModeName, *fromNodeType, *toNodeType;
2610 char fromNameP[100], toNameP[100];
2611 sprintf(fromNameP,
"%p",fromNode);
2612 sprintf(toNameP,
"%p",toNode);
2613 fromName = parser_getNameFromNode(fromNode);
2614 if(!fromName) fromName = &fromNameP[0];
2615 toName = parser_getNameFromNode(toNode);
2616 if(!toName) toName = &toNameP[0];
2617 fromFieldName = findFIELDNAMES0(fromNode,fromOffset);
2618 toFieldName = findFIELDNAMES0(toNode,toOffset);
2619 if(!toName) toName = &toNameP[0];
2620 fromNodeType = (
char *)stringNodeType(fromNode->_nodeType);
2621 if(fromNode->_nodeType == NODE_Proto)
2622 fromNodeType = ((
struct ProtoDefinition*)(X3D_PROTO(fromNode)->__protoDef))->protoName;
2623 toNodeType = (
char *)stringNodeType(toNode->_nodeType);
2624 if(toNode->_nodeType == NODE_Proto)
2625 toNodeType = ((
struct ProtoDefinition*)(X3D_PROTO(toNode)->__protoDef))->protoName;
2626 fromModeName = (
char *)stringMode(modeFrom,1);
2627 toModeName = (
char *)stringMode(modeTo, 1);
2628 printf(
" %s %s.%s %s TO %s %s.%s %s %d ",fromNodeType,fromName,fromFieldName,fromModeName,
2629 toNodeType,toName,toFieldName,toModeName,itime);
2630 print_field_value(stdout,type,toAny);
2638 if (toNode != NULL) {
2639 switch(toNode->_nodeType)
2646 shader =(
struct Shader_Script *)(X3D_SCRIPT(toNode)->__scriptObj);
2662 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, toOffset);
2665 if(isScriptControlInitialized(shader->num) && isScriptControlOK(shader->num))
2667 int JSparamNameIndex = sfield->fieldDecl->JSparamNameIndex;
2669 mark_script(shader->num);
2672 getField_ToJavascript_B(shader->num, JSparamNameIndex, type, (
union anyVrml* ) toAny->mfnode.p, toAny->mfnode.n);
2674 getField_ToJavascript_B(shader->num, JSparamNameIndex, type, toAny, len);
2682 case NODE_ShaderProgram:
2683 case NODE_ComposedShader:
2685 case NODE_PackagedShader:
2689 getField_ToShader(toNode, toOffset, toAny, type);
2699 if (p->CRoutes[counter].interpptr != 0)
2704 printf(
"propagate_events: index %d is an interpolator\n",counter);
2708 tg->CRoutes.CRoutesExtra = p->CRoutes[counter].extra;
2710 p->CRoutes[counter].interpptr((
void *)(toNode));
2724 update_node(toNode);
2728 lastFromNode = fromNode;
2729 lastFromOffset = fromOffset;
2733 havinterp = havinterp || runQueuedDirectOutputs();
2736 }
while (havinterp==TRUE);
2739 for (counter =0; counter <= tg->CRoutes.max_script_found_and_initialized; counter++) {
2743 sc->scr_act = FALSE;
2744 js_cleanup_script_context(counter);
2755 printf (
"done propagate_events\n\n");
2758void propagate_events()
2760 propagate_events_B();
2773void printStatsEvents(){
2774 ConsoleMessage(
"%25s %d\n",
"ClockEvent count", ((
ppCRoutes)gglobal()->CRoutes.prv)->num_ClockEvents);
2785 ne = p->num_ClockEvents;
2786 for (counter =0; counter < ne; counter ++) {
2787 ce = p->ClockEvents[counter];
2789 ce.interpptr(ce.tonode);
2807 if (p->routesToRegister != NULL) {
2808 MUTEX_LOCK_ROUTING_UPDATES
2809 actually_do_CRoutes_Register();
2810 MUTEX_FREE_LOCK_ROUTING_UPDATES
2816 if (p->preEvents != NULL) {
2817 if (p->CRoutes_Initiated) {
2821 printf (
"doing preEvents, we have %d events \n",p->initialEventBeforeRoutesCount);
2824 for (counter = 0; counter < p->initialEventBeforeRoutesCount; counter ++) {
2825 MARK_EVENT(p->preEvents[counter].from, p->preEvents[counter].totalptr);
2827 p->initialEventBeforeRoutesCount = 0;
2828 p->preRouteTableSize = 0;
2829 FREE_IF_NZ(p->preEvents);
2830 UNLOCK_PREROUTETABLE
2842 ne = p->num_ClockEvents;
2843 for (counter =0; counter < ne; counter ++) {
2844 ce = p->ClockEvents[counter];
2846 ce.interpptr(ce.tonode);
2868int getRoutesCount(
void) {
2871 return p->CRoutes_Count;
2874void getSpecificRoute (
int routeNo,
struct X3D_Node **fromNode,
int *fromOffset,
2875 struct X3D_Node **toNode,
int *toOffset) {
2880 if ((routeNo <1) || (routeNo >= p->CRoutes_Count)) {
2881 *fromNode = NULL; *fromOffset = 0; *toNode = NULL; *toOffset = 0;
2887 *fromNode = p->CRoutes[routeNo].routeFromNode;
2888 *fromOffset = p->CRoutes[routeNo].fnptr;
2890 if (p->CRoutes[routeNo].tonode_count != 1) {
2891 printf (
"huh? tonode count %d\n",p->CRoutes[routeNo].tonode_count);
2892 *toNode = 0; *toOffset = 0;
2897 to_ptr = &(p->CRoutes[routeNo].tonodes[0]);
2898 *toNode = to_ptr->routeToNode;
2899 *toOffset = to_ptr->foffset;
2913void kill_routing (
void) {
2918 if (p->CRoutes_Initiated) {
2919 p->CRoutes_Initiated = FALSE;
2920 p->CRoutes_Count = 0;
2922 FREE_IF_NZ (p->CRoutes);
2924 printf (
"kill_routing done\n");
2929void Multimemcpy (
struct X3D_Node *toNode,
struct X3D_Node *fromNode,
void *tn,
void *fn,
size_t multitype) {
2937 void *fromptr, *toptr;
2942 printf (
"Multimemcpy, copying structures from %p (%s) to %p (%s) %p %p type %d\n",
2943 fromNode, stringNodeType(fromNode->_nodeType),
2944 toNode, stringNodeType(toNode->_nodeType),
2960 fromptr = (
void *)mv3ffn->p;
2963 fromcount = mv3ffn->n;
2967 tocount = mv3ftn->n;
2968 printf (
"Multimemcpy, fromcount %d\n",fromcount);
2972 switch (multitype) {
2973 case ROUTING_SFNODE: structlen =
sizeof (
void *);
break;
2974 case ROUTING_MFNODE: structlen =
sizeof (
void *);
break;
2975 case ROUTING_SFIMAGE: structlen =
sizeof (
void *);
break;
2976 case ROUTING_MFSTRING: structlen =
sizeof (
void *);
break;
2977 case ROUTING_MFFLOAT: structlen =
sizeof (float);
break;
2978 case ROUTING_MFROTATION: structlen =
sizeof (
struct SFRotation);
break;
2979 case ROUTING_MFINT32: structlen =
sizeof (int);
break;
2980 case ROUTING_MFCOLOR: structlen =
sizeof (
struct SFColor);
break;
2981 case ROUTING_MFVEC2F: structlen =
sizeof (
struct SFVec2f);
break;
2982 case ROUTING_MFVEC3F: structlen =
sizeof (
struct SFColor);
break;
2983 case ROUTING_MFVEC3D: structlen =
sizeof (
struct SFVec3d);
break;
2984 case ROUTING_MFDOUBLE: structlen =
sizeof (double);
break;
2985 case ROUTING_MFMATRIX4F: structlen =
sizeof (
struct SFMatrix4f);
break;
2986 case ROUTING_MFMATRIX4D: structlen =
sizeof (
struct SFMatrix4d);
break;
2987 case ROUTING_MFVEC2D: structlen =
sizeof (
struct SFVec2d);
break;
2988 case ROUTING_MFVEC4F: structlen =
sizeof (
struct SFVec4f);
break;
2989 case ROUTING_MFVEC4D: structlen =
sizeof (
struct SFVec4d);
break;
2990 case ROUTING_MFMATRIX3F: structlen =
sizeof (
struct SFMatrix3f);
break;
2991 case ROUTING_MFMATRIX3D: structlen =
sizeof (
struct SFMatrix3d);
break;
2993 case ROUTING_SFSTRING: {
3006 memcpy (&fStr,fn,
sizeof (
void *));
3007 memcpy (&tStr,tn,
sizeof (
void *));
3012 verify_Uni_String(tStr, fStr->strptr);
3026 if(multitype==ROUTING_SFNODE){
3028 memcpy (tn,fn,structlen);
3033 int nele = fromcount;
3034 FREE_IF_NZ (mv3ftn->p);
3036 if( multitype == ROUTING_MFNODE ) nele = (int) upper_power_of_two(nele);
3037 mv3ftn->p = MALLOC (
struct SFVec3f *, structlen*nele);
3038 toptr = (
void *)mv3ftn->p;
3041 mv3ftn->n = fromcount;
3044 printf (
"Multimemcpy, fromcount %d tocount %d fromptr %p toptr %p\n",fromcount,tocount,fromptr,toptr);
3048 memcpy (toptr,fromptr,structlen * fromcount);
3057 if (toNode != NULL) {
3058 if (multitype==ROUTING_SFNODE) {
3067 sfnodeptr = any->sfnode;
3069 printf (
"got a ROUTING_SFNODE, adding %u to %u\n",(
unsigned int) fn, (
unsigned int) toNode);
3071 ADD_PARENT(X3D_NODE(sfnodeptr),toNode);
3073 if (multitype==ROUTING_MFNODE) {
3078 printf (
"fromcount %d tocount %d\n",fromcount, tocount);
3079 printf (
"ROUTING - have to add parents... \n");
3082 for (count = 0; count < mv3ffn->n; count++) {
3084 printf (
"node in place %d is %u ",count,arrptr[count]);
3085 printf (
"%s ",stringNodeType(arrptr[count]->_nodeType));
3089 ADD_PARENT(arrptr[count],toNode);
3101static bool canRouteOnGPUTo(
struct X3D_Node *me) {
3104 if (me == NULL)
return FALSE;
3105 printf (
"canRouteOnGPUTo = %s\n",stringNodeType(me->_nodeType));
3106 for (i=0; i< vectorSize(me->_parentVector); i++) {
3108 printf (
"parent %d is a %s\n",i,stringNodeType(par->_nodeType));
3109 switch (par->_nodeType) {
3110 case NODE_TriangleSet :
3111 case NODE_IndexedTriangleSet:
3114 default:
return FALSE;