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();
264 ppCRoutes p = (ppCRoutes)t->prv;
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();
297 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
300 lock_and_do_routes_register();
302 p->CRoutes_Count = 0;
304 FREE_IF_NZ(p->CRoutes);
308void CRoutes_clear(
struct tCRoutes *t){
310 ppCRoutes p = (ppCRoutes)t->prv;
312 FREE_IF_NZ(p->ClockEvents);
313 FREE_IF_NZ(p->preEvents);
320 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
324 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
325 return p->CRoutes_Count;
327int *getCRouteCounter(){
328 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
329 return &p->CRoutes_Count;
342void markScriptResults(
struct X3D_Node * tn,
int tptr,
int route,
void * tonode) {
344 ttglobal tg = gglobal();
345 p = (ppCRoutes)tg->CRoutes.prv;
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() {
697 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
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) {
724 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
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_BufferAudioSource: myp = do_BufferAudioSourceTick;
break;
755 case NODE_OscillatorSource: myp = do_OscillatorSourceTick;
break;
756 case NODE_VisibilitySensor: myp = do_VisibilitySensorTick;
break;
757 case NODE_TransformSensor: myp = do_TransformSensorTick;
break;
758 case NODE_GeoProximitySensor: myp = do_GeoProximitySensorTick;
break;
759 case NODE_ColorChaser: myp = do_ColorChaserTick;
break;
760 case NODE_ColorDamper: myp = do_ColorDamperTick;
break;
761 case NODE_CoordinateChaser: myp = do_CoordinateChaserTick;
break;
762 case NODE_CoordinateDamper: myp = do_CoordinateDamperTick;
break;
763 case NODE_OrientationChaser: myp = do_OrientationChaserTick;
break;
764 case NODE_OrientationDamper: myp = do_OrientationDamperTick;
break;
765 case NODE_PositionChaser: myp = do_PositionChaserTick;
break;
766 case NODE_PositionDamper: myp = do_PositionDamperTick;
break;
767 case NODE_PositionChaser2D: myp = do_PositionChaser2DTick;
break;
768 case NODE_PositionDamper2D: myp = do_PositionDamper2DTick;
break;
769 case NODE_ScalarChaser: myp = do_ScalarChaserTick;
break;
770 case NODE_ScalarDamper: myp = do_ScalarDamperTick;
break;
771 case NODE_TexCoordChaser2D: myp = do_TexCoordChaser2DTick;
break;
772 case NODE_TexCoordDamper2D: myp = do_TexCoordDamper2DTick;
break;
773 case NODE_LinePickSensor: myp = do_PickSensorTick;
break;
774 case NODE_PointPickSensor: myp = do_PickSensorTick;
break;
775 case NODE_PrimitivePickSensor: myp = do_PickSensorTick;
break;
776 case NODE_VolumePickSensor: myp = do_PickSensorTick;
break;
777 case NODE_CollisionSensor: myp = do_CollisionSensorTick;
break;
783 if (p->num_ClockEvents + 1 > p->size_ClockEvents){
792 memcpy(ce, p->ClockEvents, sizeof (
struct FirstStruct) * p->num_ClockEvents);
794 p->size_ClockEvents *= 2;
795 old_ce = p->ClockEvents;
801 if (p->ClockEvents == 0) {
802 printf (
"can not allocate memory for add_first call\n");
803 p->num_ClockEvents = 0;
807 for (count=0; count < p->num_ClockEvents; count ++) {
808 if (p->ClockEvents[count].tonode == node) {
815 for (count=0; count < p->num_ClockEvents; count ++) {
816 if (p->ClockEvents[count].tonode == NULL) {
818 p->ClockEvents[count].interpptr = myp;
819 p->ClockEvents[count].tonode = node;
826 p->ClockEvents[p->num_ClockEvents].interpptr = myp;
827 p->ClockEvents[p->num_ClockEvents].tonode = node;
829 p->num_ClockEvents++;
833void delete_first(
struct X3D_Node *node) {
835 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
837 if (p->ClockEvents) {
838 for (count=0; count < p->num_ClockEvents; count ++) {
839 if (p->ClockEvents[count].tonode == node) {
840 p->ClockEvents[count].tonode = NULL;
859void CRoutes_RegisterSimple(
866 void* interpolatorPointer;
871 switch (from->_nodeType) {
873 case NODE_ComposedShader:
875 case NODE_PackagedShader:
877 case NODE_ProgramShader:
878 dir = dir | FROM_SCRIPT;
break;
881 switch (to->_nodeType) {
883 case NODE_ComposedShader:
885 case NODE_PackagedShader:
887 case NODE_ProgramShader:
888 dir = dir | TO_SCRIPT;
break;
893 if (dir!=SCRIPT_TO_SCRIPT && dir!=TO_SCRIPT) {
895 if (to->_nodeType == NODE_StaticGroup) {
896 ConsoleMessage (
"ROUTE to a StaticGroup not allowed");
901 if (dir!=SCRIPT_TO_SCRIPT && dir!=FROM_SCRIPT) {
903 if (from->_nodeType == NODE_StaticGroup) {
904 ConsoleMessage (
"ROUTE from a StaticGroup not allowed");
910 if(dir!=SCRIPT_TO_SCRIPT && dir!=TO_SCRIPT)
911 interpolatorPointer=returnInterpolatorPointer(to->_nodeType);
913 interpolatorPointer=NULL;
914 CRoutes_Register(1, from, fromOfs, to,toOfs, type, interpolatorPointer, dir, NULL);
916int usesBuiltin(
struct X3D_Node* node){
920 switch(node->_nodeType){
922 case NODE_ComposedShader:
924 case NODE_ShaderProgram :
925 case NODE_PackagedShader:
934void CRoutes_RegisterSimpleB(
935 struct X3D_Node* from,
int fromIndex,
int fromBuiltIn,
936 struct X3D_Node* to,
int toIndex,
int toBuiltIn,
943 if(usesBuiltin(from) != fromBuiltIn)
944 printf(
"error usesBuiltin(from) != fromBuiltin\n");
945 if(usesBuiltin(to) != toBuiltIn)
946 printf(
"error usesBuiltin(to) != toBuiltin\n");
949 fromOfs = NODE_OFFSETS[(from)->_nodeType][fromIndex*FIELDOFFSET_LENGTH + 1];
953 toOfs = NODE_OFFSETS[(to)->_nodeType][toIndex*FIELDOFFSET_LENGTH + 1];
954 CRoutes_RegisterSimple(from,fromOfs,to,toOfs,type);
965void CRoutes_RemoveSimple(
971 void* interpolatorPointer;
973 interpolatorPointer=returnInterpolatorPointer(to->_nodeType);
975 CRoutes_Register(0, from, fromOfs, to, toOfs, type,
976 interpolatorPointer, 0, NULL);
979void CRoutes_RemoveSimpleB(
struct X3D_Node* from,
int fromIndex,
int fromBuiltIn,
980 struct X3D_Node* to,
int toIndex,
int toBuiltIn,
int len){
987 fromOfs = NODE_OFFSETS[(from)->_nodeType][fromIndex*FIELDOFFSET_LENGTH + 1];
991 toOfs = NODE_OFFSETS[(to)->_nodeType][toIndex*FIELDOFFSET_LENGTH + 1];
993 CRoutes_RemoveSimple(from,fromOfs,to,toOfs,len);
1005void CRoutes_Register(
1017 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1020 cl_kernel CL_Interpolator = NULL;
1021 ConsoleMessage (
"CRoutes_Register, being run on :%s:\n",__DATE__);
1047 if (from->_nodeType == NODE_CoordinateInterpolator) {
1051 if (incr == 0) incr = -1;
1054 if (to->_nodeType == NODE_Coordinate) {
1056 if (canRouteOnGPUTo(to) ) {
1058 ttglobal tg = gglobal();
1059 p = (ppOpenCL_Utils)tg->OpenCL_Utils.prv;
1061 px ->_GPU_Routes_out += incr;
1063 if (tg->OpenCL_Utils.OpenCL_Initialized) {
1064 printf (
"OpenCL initialized in routes\n");
1066 printf(
"OPENCL NOT INITIALIZED YET\n");
1069 while (!tg->OpenCL_Utils.OpenCL_Initialized) {
1071 printf (
"sleeping, waiting for CL to be initialized\n");
1076 CL_Interpolator = p->coordinateInterpolatorKernel;
1078 printf (
"CRoutes Register, have a CoordinateInterpolator to Coordinate, but dest node type not supported yet\n");
1079 px->_CPU_Routes_out+= incr;
1083 px->_CPU_Routes_out += incr;
1086 px->_CPU_Routes_out += incr;
1090 MUTEX_LOCK_ROUTING_UPDATES
1092 if (p->routesToRegister == NULL) {
1093 p->routesToRegister = newVector(
struct CR_RegStruct *, 16);
1098 newEntry->adrem = adrem;
1099 newEntry->from = from;
1100 newEntry->fromoffset = fromoffset;
1102 newEntry->toOfs = toOfs;
1103 newEntry->fieldType = type;
1104 newEntry->intptr = intptr;
1105 newEntry->scrdir = scrdir;
1106 newEntry->extra = extra;
1108 newEntry->CL_Interpolator = CL_Interpolator;
1111 vector_pushBack(
struct CR_RegStruct *, p->routesToRegister, newEntry);
1113 MUTEX_FREE_LOCK_ROUTING_UPDATES
1116void free_routes_to_register(
struct Vector * routesToRegister){
1118 if(routesToRegister){
1121 for(i=0;i<vectorSize(routesToRegister);i++){
1122 r = vector_get(
struct CR_RegStruct*,routesToRegister,i);
1126 FREE_IF_NZ(routesToRegister);
1130void print_routes_ready_to_register(FILE* fp)
1141 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1143 if(p->routesToRegister == NULL)
return;
1144 numRoutes = vectorSize(p->routesToRegister);
1145 fprintf(fp,
"Number of Routes Ready to Register %d\n",numRoutes);
1146 if (numRoutes < 1) {
1150 for (count = 0; count < (numRoutes); count++) {
1151 entry = vector_get(
struct CR_RegStruct *, p->routesToRegister, count);
1152 fromNode = entry->from;
1153 fromOffset = entry->fromoffset;
1155 toOffset = entry->toOfs;
1156 fromName = parser_getNameFromNode(fromNode);
1157 toName = parser_getNameFromNode(toNode);
1158 fprintf (fp,
" %p %s.%s TO %p %s.%s \n",fromNode,fromName,
1159 findFIELDNAMESfromNodeOffset0(fromNode,fromOffset),
1161 findFIELDNAMESfromNodeOffset0(toNode,toOffset)
1167static void actually_do_CRoutes_Register() {
1168 int insert_here, check_here, shifter, isDuplicate;
1169 CRnodeStruct *to_ptr = NULL;
1173 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1175 if (p->routesToRegister == NULL)
return;
1178 printf (
"actually_do_CRoutes_Register, vector size %d\n",vectorSize(p->routesToRegister));
1181 for (ind=0; ind<vectorSize(p->routesToRegister); ind++ ) {
1184 newEntry = vector_get(
struct CR_RegStruct *, p->routesToRegister, ind);
1187 printf (
"CRoutes_Register adrem %d from %u ",newEntry->adrem, newEntry->from);
1190 printf (
"off %u to %u intptr %p\n",
1191 newEntry->fromoffset, newEntry->to, newEntry->intptr);
1192 printf (
"CRoutes_Register, CRoutes_Count is %d\n",p->CRoutes_Count);
1196 if (!p->CRoutes_Initiated) {
1198 p->CRoutes_MAX = 25;
1199 p->CRoutes = MALLOC (
struct CRStruct *,
sizeof (*p->CRoutes) * p->CRoutes_MAX);
1201 p->CRoutes[0].routeFromNode = X3D_NODE(0);
1202 p->CRoutes[0].fnptr = 0;
1203 p->CRoutes[0].tonode_count = 0;
1204 p->CRoutes[0].tonodes = NULL;
1205 p->CRoutes[0].isActive = FALSE;
1206 p->CRoutes[0].interpptr = 0;
1207 p->CRoutes[0].intTimeStamp = 0;
1208 p->CRoutes[1].routeFromNode = X3D_NODE(-1);
1209 p->CRoutes[1].fnptr = 0x8FFFFFFF;
1210 p->CRoutes[1].tonode_count = 0;
1211 p->CRoutes[1].tonodes = NULL;
1212 p->CRoutes[1].isActive = FALSE;
1213 p->CRoutes[1].interpptr = 0;
1214 p->CRoutes[1].intTimeStamp = 0;
1215 p->CRoutes_Count = 2;
1216 p->CRoutes_Initiated = TRUE;
1219 p->CRoutes[0].CL_Interpolator = NULL;
1220 p->CRoutes[1].CL_Interpolator = NULL;
1227 while (newEntry->from > p->CRoutes[insert_here].routeFromNode) {
1229 printf (
"comparing %u to %u\n",newEntry->from, p->CRoutes[insert_here].routeFromNode);
1236 while ((newEntry->from == p->CRoutes[insert_here].routeFromNode) &&
1237 (newEntry->fromoffset > p->CRoutes[insert_here].fnptr)) {
1239 printf (
"same routeFromNode, different offset\n");
1249 printf (
"ok, CRoutes_Register - is this a duplicate? comparing from (%d %d), fnptr (%d %d) intptr (%d %d) and tonodes %d\n",
1250 p->CRoutes[insert_here].routeFromNode, newEntry->from,
1251 p->CRoutes[insert_here].fnptr, newEntry->fromoffset,
1252 p->CRoutes[insert_here].interpptr, newEntry->intptr,
1253 p->CRoutes[insert_here].tonodes);
1256 check_here = insert_here;
1258 while ((p->CRoutes[check_here].routeFromNode==newEntry->from) &&
1259 (p->CRoutes[check_here].fnptr==newEntry->fromoffset) &&
1260 (newEntry->adrem == 0 || p->CRoutes[check_here].interpptr==newEntry->intptr) &&
1261 (p->CRoutes[check_here].tonodes!=0)) {
1264 toof = newEntry->toOfs;
1266 if ((toN == (p->CRoutes[check_here].tonodes)->routeToNode) &&
1267 (toof == (p->CRoutes[check_here].tonodes)->foffset)) {
1271 printf (
"duplicate route; maybe this is a remove? \n");
1275 if (newEntry->adrem == 1) {
1277 printf (
"definite duplicate, returning\n");
1284 FREE_IF_NZ(p->CRoutes[check_here].tonodes);
1285 for (shifter = check_here; shifter < p->CRoutes_Count; shifter++) {
1287 printf (
"copying from %d to %d\n",shifter, shifter-1);
1289 memcpy ((
void *)&p->CRoutes[shifter],
1290 (
void *)&p->CRoutes[shifter+1],
1293 p->CRoutes_Count --;
1295 printf (
"routing table now %d\n",p->CRoutes_Count);
1296 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1297 printf (
"%d: %u %u %u\n",shifter, p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1298 p->CRoutes[shifter].interpptr);
1309 if (newEntry->adrem == 1 && !isDuplicate) {
1311 printf (
"CRoutes, inserting at %d\n",insert_here);
1315 for (shifter = p->CRoutes_Count; shifter > insert_here; shifter--) {
1316 memcpy ((
void *)&p->CRoutes[shifter], (
void *)&p->CRoutes[shifter-1],
sizeof(
struct CRStruct));
1318 printf (
"Copying from index %d to index %d\n",shifter, shifter-1);
1324 p->CRoutes[insert_here].routeFromNode = newEntry->from;
1325 p->CRoutes[insert_here].fnptr = newEntry->fromoffset;
1326 p->CRoutes[insert_here].isActive = FALSE;
1327 p->CRoutes[insert_here].tonode_count = 0;
1328 p->CRoutes[insert_here].tonodes = NULL;
1329 p->CRoutes[insert_here].len = returnRoutingElementLength(newEntry->fieldType);
1330 p->CRoutes[insert_here].interpptr = (void (*)(
void*))newEntry->intptr;
1331 p->CRoutes[insert_here].direction_flag = newEntry->scrdir;
1332 p->CRoutes[insert_here].extra = newEntry->extra;
1333 p->CRoutes[insert_here].intTimeStamp = 0;
1335 p->CRoutes[insert_here].CL_Interpolator = newEntry->CL_Interpolator;
1339 if ((p->CRoutes[insert_here].tonodes =
1340 MALLOC(CRnodeStruct *,
sizeof(CRnodeStruct))) == NULL) {
1341 fprintf(stderr,
"CRoutes_Register: calloc failed to allocate memory.\n");
1343 p->CRoutes[insert_here].tonode_count = 1;
1346 to_ptr = &(p->CRoutes[insert_here].tonodes[0]);
1347 to_ptr->routeToNode = newEntry->to;
1348 to_ptr->foffset = newEntry->toOfs;
1352 if (p->CRoutes_Count >= (p->CRoutes_MAX-2)) {
1354 p->CRoutes_MAX += 50;
1355 p->CRoutes =(
struct CRStruct *) REALLOC (p->CRoutes, sizeof (*p->CRoutes) * p->CRoutes_MAX);
1358 p->CRoutes_Count ++;
1361 printf (
"routing table now %d\n",p->CRoutes_Count);
1362 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1363 printf (
"%d: from: %p offset: %u Interpolator %p direction %d, len %d extra %p : ",shifter,
1364 p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1365 p->CRoutes[shifter].interpptr, p->CRoutes[shifter].direction_flag, p->CRoutes[shifter].len, p->CRoutes[shifter].extra);
1366 for (insert_here = 0; insert_here < p->CRoutes[shifter].tonode_count; insert_here++) {
1367 printf (
" to: %p %u",p->CRoutes[shifter].tonodes[insert_here].routeToNode,
1368 p->CRoutes[shifter].tonodes[insert_here].foffset);
1376 free_routes_to_register(p->routesToRegister);
1377 p->routesToRegister = NULL;
1379 printf (
"routing table now %d\n",p->CRoutes_Count);
1380 for (shifter = 0; shifter < p->CRoutes_Count; shifter ++) {
1381 printf (
"%3d from: %p offset: %u Interp %p dir %d, len %d extra %p :\n",shifter,
1382 p->CRoutes[shifter].routeFromNode, p->CRoutes[shifter].fnptr,
1383 p->CRoutes[shifter].interpptr, p->CRoutes[shifter].direction_flag, p->CRoutes[shifter].len, p->CRoutes[shifter].extra);
1384 for (insert_here = 0; insert_here < p->CRoutes[shifter].tonode_count; insert_here++) {
1385 printf (
" to: %p %u\n",p->CRoutes[shifter].tonodes[insert_here].routeToNode,
1386 p->CRoutes[shifter].tonodes[insert_here].foffset);
1392void lock_and_do_routes_register()
1394 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1395 MUTEX_LOCK_ROUTING_UPDATES
1396 actually_do_CRoutes_Register();
1397 MUTEX_FREE_LOCK_ROUTING_UPDATES
1401#ifdef DEBUG_VALIDNODE
1403void mark_event_check (
struct X3D_Node *from,
int totalptr,
char *fn,
int line) {
1404 printf (
"mark_event_check: at %s:%d\n",fn,line);
1405 if (X3D_NODE_CHECK(from)) {
1407 printf (
"mark_event_check, routing from a %s\n",stringNodeType(from->_nodeType));
1410 printf (
"mark_event_check, not a real node %d\n",from);
1412 mark_event(from,totalptr);
1413 printf (
"mark_event_check: finished at %s:%d\n",fn,line);
1425void mark_event (
struct X3D_Node *from,
int totalptr) {
1427 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1429 if(from == 0)
return;
1432 X3D_NODE_CHECK(from);
1435 if (!p->CRoutes_Initiated) {
1438 if (p->initialEventBeforeRoutesCount >= p->preRouteTableSize) {
1439 p->preRouteTableSize += POSSIBLEINITIALROUTES;
1440 p->preEvents=REALLOC (p->preEvents,
1443 p->preEvents[p->initialEventBeforeRoutesCount].from = from;
1444 p->preEvents[p->initialEventBeforeRoutesCount].totalptr = totalptr;
1445 p->initialEventBeforeRoutesCount++;
1446 UNLOCK_PREROUTETABLE
1454 printf (
"\nmark_event, from %s (%u) fromoffset %u\n", stringNodeType(from->_nodeType),from, totalptr);
1459 while (from > p->CRoutes[findit].routeFromNode) {
1461 printf (
"mark_event, skipping past %x %x, index %d\n",from, p->CRoutes[findit].routeFromNode, findit);
1468 while ((from == p->CRoutes[findit].routeFromNode) &&
1469 (totalptr != p->CRoutes[findit].fnptr)) findit ++;
1473 printf (
"ep, (%#x %#x) (%#x %#x) at %d \n",
1474 from,p->CRoutes[findit].routeFromNode, totalptr,
1475 p->CRoutes[findit].fnptr,findit);
1480 while ((from == p->CRoutes[findit].routeFromNode) &&
1481 (totalptr == p->CRoutes[findit].fnptr)) {
1483 printf (
"found event at %d\n",findit);
1485 if (p->CRoutes[findit].intTimeStamp!=p->thisIntTimeStamp) {
1486 p->CRoutes[findit].isActive=TRUE;
1487 p->CRoutes[findit].intTimeStamp=p->thisIntTimeStamp;
1491 else printf (
"routing loop broken, findit %d\n",findit);
1497 printf (
"done mark_event\n");
1502void mark_event_B (
struct X3D_Node *lastFrom,
int lastptr,
struct X3D_Node *from,
int totalptr) {
1504 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1506 if(from == 0)
return;
1509 X3D_NODE_CHECK(from);
1512 if (!p->CRoutes_Initiated) {
1515 if (p->initialEventBeforeRoutesCount >= p->preRouteTableSize) {
1516 p->preRouteTableSize += POSSIBLEINITIALROUTES;
1517 p->preEvents=REALLOC (p->preEvents,
1520 p->preEvents[p->initialEventBeforeRoutesCount].from = from;
1521 p->preEvents[p->initialEventBeforeRoutesCount].totalptr = totalptr;
1522 p->initialEventBeforeRoutesCount++;
1523 UNLOCK_PREROUTETABLE
1531 printf (
"\nmark_event, from %s (%u) fromoffset %u\n", stringNodeType(from->_nodeType),from, totalptr);
1536 while (from > p->CRoutes[findit].routeFromNode) {
1538 printf (
"mark_event, skipping past %x %x, index %d\n",from, p->CRoutes[findit].routeFromNode, findit);
1545 while ((from == p->CRoutes[findit].routeFromNode) &&
1546 (totalptr != p->CRoutes[findit].fnptr)) findit ++;
1550 printf (
"ep, (%#x %#x) (%#x %#x) at %d \n",
1551 from,p->CRoutes[findit].routeFromNode, totalptr,
1552 p->CRoutes[findit].fnptr,findit);
1557 while ((from == p->CRoutes[findit].routeFromNode) &&
1558 (totalptr == p->CRoutes[findit].fnptr)) {
1561 printf (
"found event at %d\n",findit);
1563 isCycle = (p->CRoutes[findit].tonodes[0].routeToNode == lastFrom &&
1564 p->CRoutes[findit].tonodes[0].foffset == lastptr);
1566 if (p->CRoutes[findit].intTimeStamp!=p->thisIntTimeStamp) {
1567 p->CRoutes[findit].isActive=TRUE;
1568 p->CRoutes[findit].intTimeStamp=p->thisIntTimeStamp;
1572 else printf (
"routing loop broken, findit %d\n",findit);
1578 printf (
"done mark_event\n");
1592int getScriptControlCount() {
1594 ttglobal tg = (ttglobal)gglobal();
1595 return tg->CRoutes.max_script_found;
1599 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1600 return vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1603void setScriptControlIndex(
int actualscript,
struct CRscriptStruct *sc){
1604 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1605 vector_set(
struct CRscriptStruct*,p->ScriptControl,actualscript,sc);
1607int isScriptControlOK(
int actualscript)
1610 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1611 cs = vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1613 return cs->scriptOK;
1615int isScriptControlInitialized(
int actualscript)
1619 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1621 if(actualscript < p->JSMaxScript){
1622 cs = vector_get(
struct CRscriptStruct*,p->ScriptControl,actualscript);
1624 if(cs->_initialized) ret = TRUE;
1629int loadstatus_Script(
struct X3D_Script *script){
1632 if(script->__scriptObj){
1633 struct Shader_Script * shader=X3D_SCRIPT(script)->__scriptObj;
1634 istate = isScriptControlInitialized(shader->num);
1639void initializeAnyScripts()
1656 ttglobal tg = (ttglobal)gglobal();
1657 if( tg->CRoutes.max_script_found != tg->CRoutes.max_script_found_and_initialized)
1661 for (i=tg->CRoutes.max_script_found_and_initialized+1; i <= tg->CRoutes.max_script_found; i++)
1664 JSCreateScriptContext(i);
1665 JSInitializeScriptAndFields(i);
1666 ScriptControl = getScriptControlIndex(i);
1667 if (ScriptControl->scriptOK)
1668 jsActualrunScript(i,
"initialize()");
1672 tg->CRoutes.max_script_found_and_initialized = tg->CRoutes.max_script_found;
1685void CRoutes_js_new (
int num,
int scriptType) {
1687 ttglobal tg = gglobal();
1689 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
1693 cs->thisScriptType = scriptType;
1696 if (num > tg->CRoutes.max_script_found) tg->CRoutes.max_script_found = num;
1708void mark_script (
int num) {
1717 getScriptControlIndex(num)->scr_act = TRUE;
1732 int JSparamNameIndex,
int type,
int extra,
int len) {
1744 int touched_flag=FALSE;
1749 ttglobal tg = gglobal();
1775 if(shader->num > -1 && shader->loaded){
1776 actualscript = shader->num;
1783 if(!isScriptControlInitialized(actualscript)){
1788 if (actualscript > tg->CRoutes.max_script_found_and_initialized) {
1794 if(!isScriptControlOK(actualscript)){
1823 touched_flag = get_valueChanged_flag((
int)JSparamNameIndex,actualscript);
1826 if (touched_flag!= 0) {
1839 js_setField_javascriptEventOut_B(any,type, len, extra,
1855 resetScriptTouchedFlag ((
int) actualscript, (
int) JSparamNameIndex);
1877 printf (
"%f finished gatherScriptEventOuts loop\n",TickTime());
1882void JSparamnamesShutdown(){
1883 ttglobal tg = gglobal();
1884 ppCRoutes p = (ppCRoutes)tg->CRoutes.prv;
1886 FREE_IF_NZ(p->JSparamnames);
1887 tg->CRoutes.jsnameindex = -1;
1888 tg->CRoutes.MAXJSparamNames = 0;
1891void kill_javascript(
void) {
1893 ttglobal tg = gglobal();
1894 ppCRoutes p = (ppCRoutes)tg->CRoutes.prv;
1897 printf (
"calling kill_javascript()\n");
1898 zeroScriptHandles();
1899 if (jsIsRunning() != 0) {
1900 for (i=0; i<=tg->CRoutes.max_script_found_and_initialized; i++) {
1902 ScriptControl = getScriptControlIndex(i);
1904 if (ScriptControl->cx != 0) {
1905 JSDeleteScriptContext(i);
1907 setScriptControlIndex(i,NULL);
1912 tg->CRoutes.max_script_found = -1;
1913 tg->CRoutes.max_script_found_and_initialized = -1;
1915 JSparamnamesShutdown();
1921 printf (
"done kill_javascript\n");
1925void cleanupDie(
int num,
const char *msg) {
1933 sc->thisScriptType = NOSCRIPT;
1934 sc->eventsProcessed = NULL;
1937 sc->_initialized = FALSE;
1938 sc->scriptOK = FALSE;
1939 sc->scriptText = NULL;
1940 sc->paramList = NULL;
1987void JSMaxAlloc2(
int num){
1988 ttglobal tg = gglobal();
1989 ppCRoutes p = (ppCRoutes)tg->CRoutes.prv;
1990 if(!p->ScriptControl)
1993 if(p->ScriptControl->allocn <= num){
1996 istart = p->ScriptControl->allocn;
1997 iend = upper_power_of_two(num+1);
1998 p->ScriptControl->data = REALLOC(p->ScriptControl->data,iend*
sizeof(
struct CRscriptStruct *));
1999 p->ScriptControl->allocn = iend;
2000 p->JSMaxScript = p->ScriptControl->allocn;
2004 for(i=istart;i<iend;i++)
2008int unInitializeScript(
struct X3D_Node *node){
2010 if(node && node->_nodeType == NODE_Script){
2018 count = sscript->num;
2019 ScriptControl = getScriptControlIndex(count);
2020 if (ScriptControl->cx != 0)
2021 JSDeleteScriptContext(count);
2022 setScriptControlIndex(count,NULL);
2023 FREE_IF_NZ(ScriptControl);
2033 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2034 #ifdef JAVASCRIPTVERBOSE
2035 printf(
"JSinit: script %d\n",num);
2039 if (script->num >= p->JSMaxScript) {
2040 JSMaxAlloc2(script->num);
2042 cs = newScriptControl();
2043 setScriptControlIndex(script->num,cs);
2045 cs->script = script;
2050void SaveScriptText(
int num,
const char *text) {
2051 ttglobal tg = gglobal();
2052 ppCRoutes p = (ppCRoutes)tg->CRoutes.prv;
2056 if (num >= p->JSMaxScript) {
2057 ConsoleMessage (
"SaveScriptText: warning, script %d initialization out of order",num);
2060 ScriptControl = getScriptControlIndex(num);
2061 FREE_IF_NZ(ScriptControl->scriptText);
2062 ScriptControl->scriptText = STRDUP(text);
2065 jsClearScriptControlEntries(num);
2067 if (((
int)num) > tg->CRoutes.max_script_found) tg->CRoutes.max_script_found = num;
2075 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2076 return p->JSparamnames;
2080 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2081 p->JSparamnames = JSparamnames;
2092int JSparamIndex (
const char *name,
const char *type,
int mod) {
2096 ttglobal tg = gglobal();
2100 printf (
"start of JSparamIndex, name %s, type %s\n",name,type);
2101 printf (
"start of JSparamIndex, lengths name %d, type %d\n",
2102 strlen(name),strlen(type));
2105 ty = findFieldInFIELDTYPES(type);
2108 printf (
"JSparamIndex, type %d, %s\n",ty,type);
2115 for (ctr=0; ctr<=tg->CRoutes.jsnameindex; ctr++) {
2116 if (ty==JSparamnames[ctr].type) {
2117 if ((strlen(JSparamnames[ctr].name) == len) &&
2118 (strncmp(name,JSparamnames[ctr].name,len)==0)) {
2120 printf (
"JSparamIndex, duplicate, returning %d\n",ctr);
2130 tg->CRoutes.jsnameindex ++;
2133 if (tg->CRoutes.jsnameindex >= tg->CRoutes.MAXJSparamNames) {
2135 tg->CRoutes.MAXJSparamNames += 100;
2136 setJSparamnames( (
struct CRjsnameStruct*)REALLOC (JSparamnames,
sizeof(*JSparamnames) * tg->CRoutes.MAXJSparamNames));
2137 JSparamnames = getJSparamnames();
2140 if (len > MAXJSVARIABLELENGTH-2) len = MAXJSVARIABLELENGTH-2;
2141 strncpy (JSparamnames[tg->CRoutes.jsnameindex].name,name,len);
2142 JSparamnames[tg->CRoutes.jsnameindex].name[len] = 0;
2143 JSparamnames[tg->CRoutes.jsnameindex].type = ty;
2144 JSparamnames[tg->CRoutes.jsnameindex].kind = mod;
2145 JSparamnames[tg->CRoutes.jsnameindex].eventInFunction = NULL;
2146 JSparamnames[tg->CRoutes.jsnameindex].traceable = NULL;
2148 printf (
"JSparamIndex, returning %d\n",tg->JScript.jsnameindex);
2151 return tg->CRoutes.jsnameindex;
2167char * BOOL_STRING(
int inp) {
if (inp)
return "true ";
else return "false ";}
2181union anyVrml* get_anyVrml(
struct X3D_Node* node,
int offset,
int *type,
int *mode)
2185 int fromMode, fromType, fromOffset;
2187 fromType = INT_ID_UNDEFINED;
2188 fromMode = INT_ID_UNDEFINED;
2189 fromOffset = offset;
2192 switch(node->_nodeType)
2194 case NODE_ShaderProgram:
2195 case NODE_ComposedShader:
2196 case NODE_PackagedShader:
2202 switch(fromNode->_nodeType)
2204 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(fromNode)->__scriptObj);
break;
2205 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2206 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(fromNode)->_shaderUserDefinedFields);
break;
2207 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(fromNode)->_shaderUserDefinedFields);
break;
2208 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2210 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, fromOffset);
2211 fromAny = &sfield->value;
2212 fromType = sfield->fieldDecl->fieldType;
2213 fromMode = sfield->fieldDecl->PKWmode;
2222 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, fromOffset);
2223 fromAny = &pfield->defaultVal;
2224 fromType = pfield->type;
2225 fromMode = pfield->mode;
2230 const int * offsets;
2232 fromAny = (
union anyVrml*)offsetPointer_deref(
void *,fromNode , fromOffset);
2234 offsets = NODE_OFFSETS[fromNode->_nodeType];
2235 while(*offsets > -1)
2238 if(offsets[1]==fromOffset)
2240 fromType = offsets[2];
2241 fromMode = PKW_from_KW(offsets[3]);
2244 offsets += FIELDOFFSET_LENGTH;
2254void cleanFieldIfManaged(
int type,
int mode,BOOL isPublic,
struct X3D_Node* parent,
int offset)
2268 if(isManagedField(mode,type,isPublic))
2270 int n,k,haveSomething,fromType,fromMode;
2273 any = get_anyVrml(parent,offset,&fromType,&fromMode);
2274 haveSomething = (type==FIELDTYPE_SFNode && any->sfnode) || (type==FIELDTYPE_MFNode && any->mfnode.n);
2275 haveSomething = haveSomething && parent;
2277 if(type==FIELDTYPE_SFNode){
2278 plist = &any->sfnode;
2281 plist = any->mfnode.p;
2287 remove_parent(sfn,parent);
2289 sfn->referenceCount--;
2291 if(type==FIELDTYPE_MFNode) {
2299void add_mfparents(
struct X3D_Node* newParent,
union anyVrml* mfnode,
int mftype)
2302 if(mftype != FIELDTYPE_MFNode)
return;
2303 for(i=0;i<mfnode->mfnode.n;i++)
2305 add_parent(mfnode->mfnode.p[i],newParent,__FILE__,__LINE__);
2320char *findFIELDNAMES0(
struct X3D_Node *node,
int offset);
2323const char *stringMode(
int pkwmode,
int cute){
2324 const char **strmode;
2325 const char *cutemode[] = {
"init",
"in",
"out",
"inOut" };
2326 const char *fullmode[] = {
"initializeOnly",
"inputOnly",
"outputOnly",
"inputOutput"};
2328 if(cute) strmode = cutemode;
2332 case PKW_initializeOnly:
2334 case PKW_inputOutput:
2338 case PKW_outputOnly:
2345void print_field_value(FILE *fp,
int typeIndex,
union anyVrml* value);
2349void setBit(
unsigned char *bitfield,
int k)
2353 bitfield[kbyte] = bitfield[kbyte] | (1 << kbit);
2356void clearBit(
unsigned char *bitfield,
int k)
2360 bitfield[kbyte] = bitfield[kbyte] & (~(1 << kbit));
2363void toggleBit(
unsigned char *bitfield,
int k)
2367 bitfield[kbyte] = bitfield[kbyte] ^ (1 << kbit);
2369int testBit(
unsigned char *bitfield,
int k)
2373 return bitfield[kbyte] & (1 << kbit);
2375void printBits(
unsigned char *bitfield,
int nbytes){
2376 int nbits = nbytes * 8;
2377 for(
int i=0;i<nbits;i++)
2378 printf(
"%d", testBit(bitfield,i)?1:0);
2381void flag_fieldchange(
struct X3D_Node * toNode,
int toOffset){
2387 int bit = toOffset / 4;
2388 setBit(toNode->_fieldchange,bit);
2392void propagate_events_B() {
2397 union anyVrml *fromAny, *toAny;
2398 struct X3D_Node *fromNode, *toNode, *lastFromNode;
2399 int fromOffset, toOffset, lastFromOffset, last_markme;
2404 int len, isize, type, sftype, isMF, itime, nRoutesDone, modeFrom, modeTo, debugRoutes;
2406 CRnodeStruct *to_ptr = NULL;
2408 ttglobal tg = gglobal();
2409 p = (ppCRoutes)tg->CRoutes.prv;
2412 printf (
"\npropagate_events start\n");
2415 type = INT_ID_UNDEFINED;
2418 p->thisIntTimeStamp ++;
2419 lastFromOffset = -1;
2420 lastFromNode = NULL;
2421 last_markme = FALSE;
2425 printf(
"current time=%d routecount=%d\n",p->thisIntTimeStamp,p->CRoutes_Count);
2431 for (counter = 1; counter < p->CRoutes_Count-1; counter++) {
2434 fromNode = p->CRoutes[counter].routeFromNode;
2435 fromOffset = p->CRoutes[counter].fnptr;
2436 itime = p->CRoutes[counter].intTimeStamp;
2437 switch(fromNode->_nodeType)
2439 case NODE_ShaderProgram:
2440 case NODE_ComposedShader:
2442 case NODE_PackagedShader:
2448 switch(fromNode->_nodeType)
2450 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(fromNode)->__scriptObj);
break;
2451 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2452 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(fromNode)->_shaderUserDefinedFields);
break;
2453 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(fromNode)->_shaderUserDefinedFields);
break;
2454 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(fromNode)->_shaderUserDefinedFields);
break;
2456 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, fromOffset);
2457 fromAny = &sfield->value;
2459 type = sfield->fieldDecl->fieldType;
2461 sftype = type - isMF;
2464 isize = sizeofSForMF(sftype);
2465 if(isMF) len =
sizeof(int) +
sizeof(
void*);
2467 modeFrom = sfield->fieldDecl->PKWmode;
2470 if(fromNode->_nodeType == NODE_Script){
2474 markme = last_markme;
2475 if(!(fromNode==lastFromNode && fromOffset==lastFromOffset)){
2477 if(SM_method() == 0){
2479 int JSparamNameIndex = sfield->fieldDecl->JSparamNameIndex;
2480 markme = gatherScriptEventOut_B(fromAny,shader,JSparamNameIndex,type,0,len);
2485 markme = sfield->valueChanged;
2487 sfield->valueChanged = 0;
2492 if (p->CRoutes[counter].intTimeStamp!=p->thisIntTimeStamp) {
2493 p->CRoutes[counter].isActive=TRUE;
2494 p->CRoutes[counter].intTimeStamp=p->thisIntTimeStamp;
2497 last_markme = markme;
2509 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, fromOffset);
2510 fromAny = &pfield->defaultVal;
2511 type = pfield->type;
2512 modeFrom = pfield->mode;
2517 const int * offsets;
2519 fromAny = (
union anyVrml*)offsetPointer_deref(
void *,fromNode , fromOffset);
2521 offsets = NODE_OFFSETS[fromNode->_nodeType];
2522 while(*offsets > -1)
2525 if(offsets[1]==fromOffset)
2528 modeFrom = PKW_from_KW(offsets[3]);
2531 offsets += FIELDOFFSET_LENGTH;
2539 sftype = type - isMF;
2542 isize = sizeofSForMF(sftype);
2543 if(isMF) len =
sizeof(int) +
sizeof(
void*);
2547 for (to_counter = 0; to_counter < p->CRoutes[counter].tonode_count; to_counter++) {
2548 modeTo = PKW_inputOnly;
2549 to_ptr = &(p->CRoutes[counter].tonodes[to_counter]);
2550 if (to_ptr == NULL) {
2551 printf(
"WARNING: tonode at %u is NULL in propagate_events.\n",
2557 printf(
"propagate_events: counter %d to_counter %u act %s from %u off %u to %u off %u oint %u dir %d\n",
2558 counter, to_counter, BOOL_STRING(p->CRoutes[counter].isActive),
2559 p->CRoutes[counter].routeFromNode, p->CRoutes[counter].fnptr,
2560 to_ptr->routeToNode, to_ptr->foffset, p->CRoutes[counter].interpptr,
2561 p->CRoutes[counter].direction_flag);
2564 if (p->CRoutes[counter].isActive == TRUE) {
2566 p->CRoutes[counter].isActive = FALSE;
2574 toNode = to_ptr->routeToNode;
2575 toOffset = to_ptr->foffset;
2579 if (toNode != NULL) {
2580 switch(toNode->_nodeType)
2582 case NODE_ShaderProgram:
2583 case NODE_ComposedShader:
2584 case NODE_PackagedShader:
2590 switch(toNode->_nodeType)
2592 case NODE_Script: shader =(
struct Shader_Script *)(X3D_SCRIPT(toNode)->__scriptObj);
break;
2593 case NODE_ComposedShader: shader =(
struct Shader_Script *)(X3D_COMPOSEDSHADER(toNode)->_shaderUserDefinedFields);
break;
2594 case NODE_Effect: shader =(
struct Shader_Script *)(X3D_EFFECT(toNode)->_shaderUserDefinedFields);
break;
2595 case NODE_ShaderProgram: shader =(
struct Shader_Script *)(X3D_SHADERPROGRAM(toNode)->_shaderUserDefinedFields);
break;
2596 case NODE_PackagedShader: shader =(
struct Shader_Script *)(X3D_PACKAGEDSHADER(toNode)->_shaderUserDefinedFields);
break;
2598 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, toOffset);
2599 toAny = &sfield->value;
2600 modeTo = sfield->fieldDecl->PKWmode;
2608 pfield= vector_get(
struct ProtoFieldDecl*, pstruct->iface, toOffset);
2609 toAny = &pfield->defaultVal;
2610 modeTo = pfield->mode;
2614 toAny = (
union anyVrml*)offsetPointer_deref(
void *,toNode , toOffset);
2617 const int *offsets = NODE_OFFSETS[toNode->_nodeType];
2618 while(*offsets > -1)
2621 if(offsets[1]==fromOffset)
2623 modeTo = PKW_from_KW(offsets[3]);
2626 offsets += FIELDOFFSET_LENGTH;
2644 if (toNode != NULL) {
2645 cleanFieldIfManaged(type,modeTo,1,toNode,toOffset);
2647 shallow_copy_field(type,fromAny,toAny);
2648 flag_fieldchange(toNode,toOffset);
2651 registerParentIfManagedField(type,modeTo,1, toAny, toNode);
2658 mark_event_B(fromNode,fromOffset, toNode, toOffset);
2663 char *fromName, *toName, *fromFieldName, *toFieldName, *fromModeName, *toModeName, *fromNodeType, *toNodeType;
2664 char fromNameP[100], toNameP[100];
2665 sprintf(fromNameP,
"%p",fromNode);
2666 sprintf(toNameP,
"%p",toNode);
2667 fromName = parser_getNameFromNode(fromNode);
2668 if(!fromName) fromName = &fromNameP[0];
2669 toName = parser_getNameFromNode(toNode);
2670 if(!toName) toName = &toNameP[0];
2671 fromFieldName = findFIELDNAMES0(fromNode,fromOffset);
2672 toFieldName = findFIELDNAMES0(toNode,toOffset);
2673 if(!toName) toName = &toNameP[0];
2674 fromNodeType = (
char *)stringNodeType(fromNode->_nodeType);
2675 if(fromNode->_nodeType == NODE_Proto)
2676 fromNodeType = ((
struct ProtoDefinition*)(X3D_PROTO(fromNode)->__protoDef))->protoName;
2677 toNodeType = (
char *)stringNodeType(toNode->_nodeType);
2678 if(toNode->_nodeType == NODE_Proto)
2679 toNodeType = ((
struct ProtoDefinition*)(X3D_PROTO(toNode)->__protoDef))->protoName;
2680 fromModeName = (
char *)stringMode(modeFrom,1);
2681 toModeName = (
char *)stringMode(modeTo, 1);
2682 printf(
" %s %s.%s %s TO %s %s.%s %s %d ",fromNodeType,fromName,fromFieldName,fromModeName,
2683 toNodeType,toName,toFieldName,toModeName,itime);
2684 print_field_value(stdout,type,toAny);
2692 if (toNode != NULL) {
2693 switch(toNode->_nodeType)
2700 shader =(
struct Shader_Script *)(X3D_SCRIPT(toNode)->__scriptObj);
2716 sfield= vector_get(
struct ScriptFieldDecl*, shader->fields, toOffset);
2719 if(isScriptControlInitialized(shader->num) && isScriptControlOK(shader->num))
2721 int JSparamNameIndex = sfield->fieldDecl->JSparamNameIndex;
2723 mark_script(shader->num);
2726 getField_ToJavascript_B(shader->num, JSparamNameIndex, type, (
union anyVrml* ) toAny->mfnode.p, toAny->mfnode.n);
2728 getField_ToJavascript_B(shader->num, JSparamNameIndex, type, toAny, len);
2736 case NODE_ShaderProgram:
2737 case NODE_ComposedShader:
2739 case NODE_PackagedShader:
2743 getField_ToShader(toNode, toOffset, toAny, type);
2753 if (p->CRoutes[counter].interpptr != 0)
2758 printf(
"propagate_events: index %d is an interpolator\n",counter);
2762 tg->CRoutes.CRoutesExtra = p->CRoutes[counter].extra;
2764 p->CRoutes[counter].interpptr((
void *)(toNode));
2778 update_node(toNode);
2782 lastFromNode = fromNode;
2783 lastFromOffset = fromOffset;
2787 havinterp = havinterp || runQueuedDirectOutputs();
2790 }
while (havinterp==TRUE);
2793 for (counter =0; counter <= tg->CRoutes.max_script_found_and_initialized; counter++) {
2797 sc->scr_act = FALSE;
2798 js_cleanup_script_context(counter);
2809 printf (
"done propagate_events\n\n");
2812void propagate_events()
2814 propagate_events_B();
2827void printStatsEvents(){
2828 ConsoleMessage(
"%25s %d\n",
"ClockEvent count", ((ppCRoutes)gglobal()->CRoutes.prv)->num_ClockEvents);
2836 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2839 ne = p->num_ClockEvents;
2840 for (counter =0; counter < ne; counter ++) {
2841 ce = p->ClockEvents[counter];
2843 ce.interpptr(ce.tonode);
2861 if (p->routesToRegister != NULL) {
2862 MUTEX_LOCK_ROUTING_UPDATES
2863 actually_do_CRoutes_Register();
2864 MUTEX_FREE_LOCK_ROUTING_UPDATES
2870 if (p->preEvents != NULL) {
2871 if (p->CRoutes_Initiated) {
2875 printf (
"doing preEvents, we have %d events \n",p->initialEventBeforeRoutesCount);
2878 for (counter = 0; counter < p->initialEventBeforeRoutesCount; counter ++) {
2879 MARK_EVENT(p->preEvents[counter].from, p->preEvents[counter].totalptr);
2881 p->initialEventBeforeRoutesCount = 0;
2882 p->preRouteTableSize = 0;
2883 FREE_IF_NZ(p->preEvents);
2884 UNLOCK_PREROUTETABLE
2896 ne = p->num_ClockEvents;
2897 for (counter =0; counter < ne; counter ++) {
2898 ce = p->ClockEvents[counter];
2900 ce.interpptr(ce.tonode);
2922int getRoutesCount(
void) {
2923 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2925 return p->CRoutes_Count;
2928void getSpecificRoute (
int routeNo,
struct X3D_Node **fromNode,
int *fromOffset,
2929 struct X3D_Node **toNode,
int *toOffset) {
2930 CRnodeStruct *to_ptr = NULL;
2931 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2934 if ((routeNo <1) || (routeNo >= p->CRoutes_Count)) {
2935 *fromNode = NULL; *fromOffset = 0; *toNode = NULL; *toOffset = 0;
2941 *fromNode = p->CRoutes[routeNo].routeFromNode;
2942 *fromOffset = p->CRoutes[routeNo].fnptr;
2944 if (p->CRoutes[routeNo].tonode_count != 1) {
2945 printf (
"huh? tonode count %d\n",p->CRoutes[routeNo].tonode_count);
2946 *toNode = 0; *toOffset = 0;
2951 to_ptr = &(p->CRoutes[routeNo].tonodes[0]);
2952 *toNode = to_ptr->routeToNode;
2953 *toOffset = to_ptr->foffset;
2967void kill_routing (
void) {
2968 ppCRoutes p = (ppCRoutes)gglobal()->CRoutes.prv;
2972 if (p->CRoutes_Initiated) {
2973 p->CRoutes_Initiated = FALSE;
2974 p->CRoutes_Count = 0;
2976 FREE_IF_NZ (p->CRoutes);
2978 printf (
"kill_routing done\n");
2983void Multimemcpy (
struct X3D_Node *toNode,
struct X3D_Node *fromNode,
void *tn,
void *fn,
size_t multitype) {
2991 void *fromptr, *toptr;
2996 printf (
"Multimemcpy, copying structures from %p (%s) to %p (%s) %p %p type %d\n",
2997 fromNode, stringNodeType(fromNode->_nodeType),
2998 toNode, stringNodeType(toNode->_nodeType),
3014 fromptr = (
void *)mv3ffn->p;
3017 fromcount = mv3ffn->n;
3021 tocount = mv3ftn->n;
3022 printf (
"Multimemcpy, fromcount %d\n",fromcount);
3026 switch (multitype) {
3027 case ROUTING_SFNODE: structlen =
sizeof (
void *);
break;
3028 case ROUTING_MFNODE: structlen =
sizeof (
void *);
break;
3029 case ROUTING_SFIMAGE: structlen =
sizeof (
void *);
break;
3030 case ROUTING_MFSTRING: structlen =
sizeof (
void *);
break;
3031 case ROUTING_MFFLOAT: structlen =
sizeof (float);
break;
3032 case ROUTING_MFROTATION: structlen =
sizeof (
struct SFRotation);
break;
3033 case ROUTING_MFINT32: structlen =
sizeof (int);
break;
3034 case ROUTING_MFCOLOR: structlen =
sizeof (
struct SFColor);
break;
3035 case ROUTING_MFVEC2F: structlen =
sizeof (
struct SFVec2f);
break;
3036 case ROUTING_MFVEC3F: structlen =
sizeof (
struct SFColor);
break;
3037 case ROUTING_MFVEC3D: structlen =
sizeof (
struct SFVec3d);
break;
3038 case ROUTING_MFDOUBLE: structlen =
sizeof (double);
break;
3039 case ROUTING_MFMATRIX4F: structlen =
sizeof (
struct SFMatrix4f);
break;
3040 case ROUTING_MFMATRIX4D: structlen =
sizeof (
struct SFMatrix4d);
break;
3041 case ROUTING_MFVEC2D: structlen =
sizeof (
struct SFVec2d);
break;
3042 case ROUTING_MFVEC4F: structlen =
sizeof (
struct SFVec4f);
break;
3043 case ROUTING_MFVEC4D: structlen =
sizeof (
struct SFVec4d);
break;
3044 case ROUTING_MFMATRIX3F: structlen =
sizeof (
struct SFMatrix3f);
break;
3045 case ROUTING_MFMATRIX3D: structlen =
sizeof (
struct SFMatrix3d);
break;
3047 case ROUTING_SFSTRING: {
3060 memcpy (&fStr,fn,
sizeof (
void *));
3061 memcpy (&tStr,tn,
sizeof (
void *));
3066 verify_Uni_String(tStr, fStr->strptr);
3080 if(multitype==ROUTING_SFNODE){
3082 memcpy (tn,fn,structlen);
3087 int nele = fromcount;
3088 FREE_IF_NZ (mv3ftn->p);
3090 if( multitype == ROUTING_MFNODE ) nele = (int) upper_power_of_two(nele);
3091 mv3ftn->p = MALLOC (
struct SFVec3f *, structlen*nele);
3092 toptr = (
void *)mv3ftn->p;
3095 mv3ftn->n = fromcount;
3098 printf (
"Multimemcpy, fromcount %d tocount %d fromptr %p toptr %p\n",fromcount,tocount,fromptr,toptr);
3102 memcpy (toptr,fromptr,structlen * fromcount);
3111 if (toNode != NULL) {
3112 if (multitype==ROUTING_SFNODE) {
3121 sfnodeptr = any->sfnode;
3123 printf (
"got a ROUTING_SFNODE, adding %u to %u\n",(
unsigned int) fn, (
unsigned int) toNode);
3125 ADD_PARENT(X3D_NODE(sfnodeptr),toNode);
3127 if (multitype==ROUTING_MFNODE) {
3132 printf (
"fromcount %d tocount %d\n",fromcount, tocount);
3133 printf (
"ROUTING - have to add parents... \n");
3136 for (count = 0; count < mv3ffn->n; count++) {
3138 printf (
"node in place %d is %u ",count,arrptr[count]);
3139 printf (
"%s ",stringNodeType(arrptr[count]->_nodeType));
3143 ADD_PARENT(arrptr[count],toNode);
3155static bool canRouteOnGPUTo(
struct X3D_Node *me) {
3158 if (me == NULL)
return FALSE;
3159 printf (
"canRouteOnGPUTo = %s\n",stringNodeType(me->_nodeType));
3160 for (i=0; i< vectorSize(me->_parentVector); i++) {
3162 printf (
"parent %d is a %s\n",i,stringNodeType(par->_nodeType));
3163 switch (par->_nodeType) {
3164 case NODE_TriangleSet :
3165 case NODE_IndexedTriangleSet:
3168 default:
return FALSE;