Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/terrain.old/src/world_entities/world_entity.cc @ 9134

Last change on this file since 9134 was 8929, checked in by ponder, 18 years ago
  • added a clipping plane for removing popping effects
  • put the update stuff from terrain::draw to terrain::tick.
File size: 20.5 KB
Line 
1
2
3/*
4   orxonox - the future of 3D-vertical-scrollers
5
6   Copyright (C) 2004 orx
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2, or (at your option)
11   any later version.
12
13   ### File Specific:
14   main-programmer: Patrick Boenzli
15   co-programmer: Christian Meyer
16*/
17#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
18
19#include "world_entity.h"
20#include "shell_command.h"
21
22#include "model.h"
23#include "md2/md2Model.h"
24#include "md3/md3_model.h"
25
26#include "util/loading/resource_manager.h"
27#include "util/loading/load_param.h"
28#include "vector.h"
29#include "obb_tree.h"
30
31#include "glgui_bar.h"
32
33#include "state.h"
34#include "camera.h"
35
36#include "collision_handle.h"
37#include "collision_event.h"
38
39#include <stdarg.h>
40
41
42using namespace std;
43
44SHELL_COMMAND(model, WorldEntity, loadModel)
45->describe("sets the Model of the WorldEntity")
46->defaultValues("models/ships/fighter.obj", 1.0f);
47
48SHELL_COMMAND(debugEntity, WorldEntity, debugWE);
49
50/**
51 *  Loads the WordEntity-specific Part of any derived Class
52 *
53 * @param root: Normally NULL, as the Derived Entities define a loadParams Function themeselves,
54 *              that can calls WorldEntities loadParams for itself.
55 */
56WorldEntity::WorldEntity()
57    : Synchronizeable()
58{
59  this->setClassID(CL_WORLD_ENTITY, "WorldEntity");
60
61  this->obbTree = NULL;
62  this->healthWidget = NULL;
63  this->healthMax = 1.0f;
64  this->health = 1.0f;
65  this->damage = 0.0f; // no damage dealt by a default entity
66  this->scaling = 1.0f;
67
68  /* OSOLETE */
69  this->bVisible = true;
70  this->bCollide = true;
71
72  this->objectListNumber = OM_INIT;
73  this->objectListIterator = NULL;
74
75  // reset all collision handles to NULL == unsubscribed state
76  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
77    this->collisionHandles[i] = NULL;
78  this->bReactive = false;
79
80  // registering default reactions:
81//   this->subscribeReaction(CREngine::CR_OBJECT_DAMAGE, CL_WORLD_ENTITY);
82
83  this->toList(OM_NULL);
84
85  modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName" ) );
86  scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling" ) );
87}
88
89/**
90 *  standard destructor
91*/
92WorldEntity::~WorldEntity ()
93{
94  State::getObjectManager()->toList(this, OM_INIT);
95
96  // Delete the model (unregister it with the ResourceManager)
97  for (unsigned int i = 0; i < this->models.size(); i++)
98    this->setModel(NULL, i);
99
100  // Delete the obbTree
101  if( this->obbTree != NULL)
102    delete this->obbTree;
103
104  if (this->healthWidget != NULL)
105    delete this->healthWidget;
106
107  this->unsubscribeReaction();
108}
109
110/**
111 * loads the WorldEntity Specific Parameters.
112 * @param root: the XML-Element to load the Data From
113 */
114void WorldEntity::loadParams(const TiXmlElement* root)
115{
116  // Do the PNode loading stuff
117  PNode::loadParams(root);
118
119  LoadParam(root, "md2texture", this, WorldEntity, loadMD2Texture)
120  .describe("the fileName of the texture, that should be loaded onto this world-entity. (must be relative to the data-dir)")
121  .defaultValues("");
122
123  // Model Loading
124  LoadParam(root, "model", this, WorldEntity, loadModel)
125  .describe("the fileName of the model, that should be loaded onto this world-entity. (must be relative to the data-dir)")
126  .defaultValues("", 1.0f, 0);
127
128  LoadParam(root, "maxHealth", this, WorldEntity, setHealthMax)
129  .describe("The Maximum health that can be loaded onto this entity")
130  .defaultValues(1.0f);
131
132  LoadParam(root, "health", this, WorldEntity, setHealth)
133  .describe("The Health the WorldEntity has at this moment")
134  .defaultValues(1.0f);
135}
136
137
138/**
139 * loads a Model onto a WorldEntity
140 * @param fileName the name of the model to load
141 * @param scaling the Scaling of the model
142 *
143 * FIXME
144 * @todo: separate the obb tree generation from the model
145 */
146void WorldEntity::loadModel(const std::string& fileName, float scaling, unsigned int modelNumber, unsigned int obbTreeDepth)
147{
148  this->modelLODName = fileName;
149  this->scaling = scaling;
150
151  std::string name = fileName;
152
153  if (  name.find( ResourceManager::getInstance()->getDataDir() ) == 0 )
154  {
155    name.erase(ResourceManager::getInstance()->getDataDir().size());
156  }
157
158  this->modelFileName = name;
159
160  if (!fileName.empty())
161  {
162    // search for the special character # in the LoadParam
163    if (fileName.find('#') != std::string::npos)
164    {
165      PRINTF(4)("Found # in %s... searching for LOD's\n", fileName.c_str());
166      std::string lodFile = fileName;
167      unsigned int offset = lodFile.find('#');
168      for (unsigned int i = 0; i < 3; i++)
169      {
170        lodFile[offset] = 48+(int)i;
171        if (ResourceManager::isInDataDir(lodFile))
172          this->loadModel(lodFile, scaling, i);
173      }
174      return;
175    }
176    if (this->scaling <= 0.0)
177    {
178      PRINTF(1)("YOU GAVE ME A CRAPY SCALE resetting to 1.0\n");
179      this->scaling = 1.0;
180    }
181    if(fileName.find(".obj") != std::string::npos)
182    {
183      PRINTF(4)("fetching OBJ file: %s\n", fileName.c_str());
184      BaseObject* loadedModel = ResourceManager::getInstance()->load(fileName, OBJ, RP_CAMPAIGN, this->scaling);
185      if (loadedModel != NULL)
186        this->setModel(dynamic_cast<Model*>(loadedModel), modelNumber);
187      else
188        PRINTF(1)("OBJ-File %s not found.\n", fileName.c_str());
189
190      if( modelNumber == 0)
191        this->buildObbTree(obbTreeDepth);
192    }
193    else if(fileName.find(".md2") != std::string::npos)
194    {
195      PRINTF(4)("fetching MD2 file: %s\n", fileName.c_str());
196      Model* m = new MD2Model(fileName, this->md2TextureFileName, this->scaling);
197      //this->setModel((Model*)ResourceManager::getInstance()->load(fileName, MD2, RP_CAMPAIGN), 0);
198      this->setModel(m, 0);
199
200      if( m != NULL)
201        this->buildObbTree(obbTreeDepth);
202    }
203    else if(fileName.find(".md3") != std::string::npos)
204    {
205      PRINTF(4)("fetching MD3 file: %s\n", fileName.c_str());
206      Model* m = new md3::MD3Model(fileName, this->scaling);
207      this->setModel(m, 0);
208
209//       if( m != NULL)
210//         this->buildObbTree(obbTreeDepth);
211    }
212  }
213  else
214  {
215    this->setModel(NULL);
216  }
217}
218
219/**
220 * sets a specific Model for the Object.
221 * @param model The Model to set
222 * @param modelNumber the n'th model in the List to get.
223 */
224void WorldEntity::setModel(Model* model, unsigned int modelNumber)
225{
226  if (this->models.size() <= modelNumber)
227    this->models.resize(modelNumber+1, NULL);
228
229  if (this->models[modelNumber] != NULL)
230  {
231    Resource* resource = ResourceManager::getInstance()->locateResourceByPointer(dynamic_cast<BaseObject*>(this->models[modelNumber]));
232    if (resource != NULL)
233      ResourceManager::getInstance()->unload(resource, RP_LEVEL);
234    else
235    {
236      PRINTF(4)("Forcing model deletion\n");
237      delete this->models[modelNumber];
238    }
239  }
240
241  this->models[modelNumber] = model;
242
243
244  //   if (this->model != NULL)
245  //     this->buildObbTree(4);
246}
247
248
249/**
250 * builds the obb-tree
251 * @param depth the depth to calculate
252 */
253bool WorldEntity::buildObbTree(int depth)
254{
255  if (this->obbTree)
256    delete this->obbTree;
257
258  if (this->models[0] != NULL)
259  {
260    this->obbTree = new OBBTree(depth, models[0]->getModelInfo(), this);
261    return true;
262  }
263  else
264  {
265    PRINTF(1)("could not create obb-tree, because no model was loaded yet\n");
266    this->obbTree = NULL;
267    return false;
268  }
269}
270
271
272/**
273 * subscribes this world entity to a collision reaction
274 *  @param type the type of reaction to subscribe to
275 *  @param target1 a filter target (classID)
276 */
277void WorldEntity::subscribeReaction(CREngine::CRType type, long target1)
278{
279  this->subscribeReaction(type);
280
281  // add the target filter
282  this->collisionHandles[type]->addTarget(target1);
283}
284
285
286/**
287 * subscribes this world entity to a collision reaction
288 *  @param type the type of reaction to subscribe to
289 *  @param target1 a filter target (classID)
290 */
291void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2)
292{
293  this->subscribeReaction(type);
294
295  // add the target filter
296  this->collisionHandles[type]->addTarget(target1);
297  this->collisionHandles[type]->addTarget(target2);
298}
299
300
301/**
302 * subscribes this world entity to a collision reaction
303 *  @param type the type of reaction to subscribe to
304 *  @param target1 a filter target (classID)
305 */
306void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3)
307{
308  this->subscribeReaction(type);
309
310  // add the target filter
311  this->collisionHandles[type]->addTarget(target1);
312  this->collisionHandles[type]->addTarget(target2);
313  this->collisionHandles[type]->addTarget(target3);
314}
315
316
317/**
318 * subscribes this world entity to a collision reaction
319 *  @param type the type of reaction to subscribe to
320 *  @param target1 a filter target (classID)
321 */
322void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3, long target4)
323{
324  this->subscribeReaction(type);
325
326  // add the target filter
327  this->collisionHandles[type]->addTarget(target1);
328  this->collisionHandles[type]->addTarget(target2);
329  this->collisionHandles[type]->addTarget(target3);
330  this->collisionHandles[type]->addTarget(target4);
331}
332
333
334/**
335 * subscribes this world entity to a collision reaction
336 *  @param type the type of reaction to subscribe to
337 *  @param nrOfTargets number of target filters
338 *  @param ... the targets as classIDs
339 */
340void WorldEntity::subscribeReaction(CREngine::CRType type)
341{
342  if( this->collisionHandles[type] != NULL)  {
343    PRINTF(2)("Registering for a CollisionReaction already subscribed to! Skipping\n");
344    return;
345  }
346
347  this->collisionHandles[type] = CREngine::getInstance()->subscribeReaction(this, type);
348
349  // now there is at least one collision reaction subscribed
350  this->bReactive = true;
351}
352
353
354/**
355 * unsubscribes a specific reaction from the worldentity
356 *  @param type the reaction to unsubscribe
357 */
358void WorldEntity::unsubscribeReaction(CREngine::CRType type)
359{
360  if( this->collisionHandles[type] == NULL)
361    return;
362
363  CREngine::getInstance()->unsubscribeReaction(this->collisionHandles[type]);
364  this->collisionHandles[type] = NULL;
365
366  // check if there is still any handler registered
367  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
368  {
369    if( this->collisionHandles[i] != NULL)
370    {
371      this->bReactive = true;
372      return;
373    }
374  }
375  this->bReactive = false;
376}
377
378
379/**
380 * unsubscribes all collision reactions
381 */
382void WorldEntity::unsubscribeReaction()
383{
384  for( int i = 0; i < CREngine::CR_NUMBER; i++)
385    this->unsubscribeReaction((CREngine::CRType)i);
386
387  // there are no reactions subscribed from now on
388  this->bReactive = false;
389}
390
391
392/**
393 * registers a new collision event to this world entity
394 *  @param entityA entity of the collision
395 *  @param entityB entity of the collision
396 *  @param bvA colliding bounding volume of entityA
397 *  @param bvB colliding bounding volume of entityA
398 */
399bool WorldEntity::registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
400{
401  // is there any handler listening?
402  if( !this->bReactive)
403    return false;
404
405  // get a collision event
406  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
407  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
408  c->collide(entityA, entityB, bvA, bvB);
409
410  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
411    if( this->collisionHandles[i] != NULL)
412      this->collisionHandles[i]->registerCollisionEvent(c);
413  return true;
414}
415
416
417/**
418 * registers a new collision event to this woeld entity
419 *  @param entity the entity that collides
420 *  @param plane it stands on
421 *  @param position it collides on the plane
422 */
423bool WorldEntity::registerCollision(WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position)
424{
425  // is there any handler listening?
426  if( !this->bReactive)
427    return false;
428
429
430  // get a collision event
431  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
432  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
433  c->collide(entity, groundEntity, normal, position);
434
435  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
436    if( this->collisionHandles[i] != NULL)
437      this->collisionHandles[i]->registerCollisionEvent(c);
438  return true;
439}
440
441
442/**
443 * @brief moves this entity to the List OM_List
444 * @param list the list to set this Entity to.
445 *
446 * this is the same as a call to State::getObjectManager()->toList(entity , list);
447 * directly, but with an easier interface.
448 *
449 * @todo inline this (peut etre)
450 */
451void WorldEntity::toList(OM_LIST list)
452{
453  State::getObjectManager()->toList(this, list);
454}
455
456void WorldEntity::toReflectionList()
457{
458  State::getObjectManager()->toReflectionList( this );
459}
460
461void removeFromReflectionList()
462{
463/// TODO
464///  State::getObject
465}
466
467/**
468 * sets the character attributes of a worldentity
469 * @param character attributes
470 *
471 * these attributes don't have to be set, only use them, if you need them
472*/
473//void WorldEntity::setCharacterAttributes(CharacterAttributes* charAttr)
474//{}
475
476
477/**
478 *  this function is called, when two entities collide
479 * @param entity: the world entity with whom it collides
480 *
481 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
482 */
483void WorldEntity::collidesWith(WorldEntity* entity, const Vector& location)
484{
485  /**
486   * THIS IS A DEFAULT COLLISION-Effect.
487   * IF YOU WANT TO CREATE A SPECIFIC COLLISION ON EACH OBJECT
488   * USE::
489   * if (entity->isA(CL_WHAT_YOU_ARE_LOOKING_FOR)) { printf "dothings"; };
490   *
491   * You can always define a default Action.... don't be affraid just test it :)
492   */
493  //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
494}
495
496
497/**
498 *  this function is called, when two entities collide
499 * @param entity: the world entity with whom it collides
500 *
501 * Implement behaviour like damage application or other miscellaneous collision stuff in this function
502 */
503void WorldEntity::collidesWithGround(const Vector& location)
504{
505  PRINTF(0)("BSP_GROUND: %s collides \n", this->getClassName() );
506}
507
508void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
509{
510
511  // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassName() );
512
513  Vector v = this->getAbsDirX();
514  v.x *= 10.1;
515  v.y *= 10.1;
516  v.z *= 10.1;
517  Vector u = Vector(0.0,-20.0,0.0);
518
519
520  if(!(this->getAbsCoor().x == ray_2.x && this->getAbsCoor().y == ray_2.y && this->getAbsCoor().z == ray_2.z) )
521  {
522
523  this->setAbsCoor(ray_2 - v);
524
525  }
526    else
527  {
528    if(ray_1.x == this->getAbsCoor().x + v.x && ray_1.y == this->getAbsCoor().y + v.y + 0.1 && ray_1.z ==this->getAbsCoor().z + v.z)
529    {
530      this->setAbsCoor(feet -u );
531    }
532
533    this->setAbsCoor(ray_2 - v);
534
535  }
536
537
538}
539
540/**
541 *  this is called immediately after the Entity has been constructed, initialized and then Spawned into the World
542 *
543 */
544void WorldEntity::postSpawn ()
545{}
546
547
548/**
549 *  this method is called by the world if the WorldEntity leaves the game
550 */
551void WorldEntity::leaveWorld ()
552{}
553
554
555/**
556 * resets the WorldEntity to its initial values. eg. used for multiplayer games: respawning
557 */
558void WorldEntity::reset()
559{}
560
561/**
562 *  this method is called every frame
563 * @param time: the time in seconds that has passed since the last tick
564 *
565 * Handle all stuff that should update with time inside this method (movement, animation, etc.)
566*/
567void WorldEntity::tick(float time)
568{}
569
570
571/**
572 *  the entity is drawn onto the screen with this function
573 *
574 * This is a central function of an entity: call it to let the entity painted to the screen.
575 * Just override this function with whatever you want to be drawn.
576*/
577void WorldEntity::draw() const
578{
579  //PRINTF(0)("(%s::%s)\n", this->getClassName(), this->getName());
580  //  assert(!unlikely(this->models.empty()));
581  {
582    glMatrixMode(GL_MODELVIEW);
583    glPushMatrix();
584
585    /* translate */
586    glTranslatef (this->getAbsCoor ().x,
587                  this->getAbsCoor ().y,
588                  this->getAbsCoor ().z);
589    Vector tmpRot = this->getAbsDir().getSpacialAxis();
590    glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
591
592
593    // This Draws the LOD's
594    float cameraDistance = State::getCamera()->distance(this);
595    if (cameraDistance > 30 && this->models.size() >= 3 && this->models[2] != NULL)
596    {
597      this->models[2]->draw();
598    }
599    else if (cameraDistance > 10 && this->models.size() >= 2 && this->models[1] != NULL)
600    {
601      this->models[1]->draw();
602    }
603    else if (this->models.size() >= 1 && this->models[0] != NULL)
604    {
605      this->models[0]->draw();
606    }
607    glPopMatrix();
608  }
609}
610
611/**
612 * @param health the Health to add.
613 * @returns the health left (this->healthMax - health+this->health)
614 */
615float WorldEntity::increaseHealth(float health)
616{
617  this->health += health;
618  if (this->health > this->healthMax)
619  {
620    float retHealth = this->healthMax - this->health;
621    this->health = this->healthMax;
622    this->updateHealthWidget();
623    return retHealth;
624  }
625  this->updateHealthWidget();
626  return 0.0;
627}
628
629/**
630 * @param health the Health to be removed
631 * @returns 0.0 or the rest, that was not substracted (bellow 0.0)
632 */
633float WorldEntity::decreaseHealth(float health)
634{
635  this->health -= health;
636
637  if (this->health < 0)
638  {
639    float retHealth = -this->health;
640    this->health = 0.0f;
641    this->updateHealthWidget();
642    return retHealth;
643  }
644  this->updateHealthWidget();
645  return 0.0;
646
647}
648
649/**
650 * @param maxHealth the maximal health that can be loaded onto the entity.
651 */
652void WorldEntity::setHealthMax(float healthMax)
653{
654  this->healthMax = healthMax;
655  if (this->health > this->healthMax)
656  {
657    PRINTF(3)("new maxHealth is bigger as the old health. Did you really intend to do this for (%s::%s)\n", this->getClassName(), this->getName());
658    this->health = this->healthMax;
659  }
660  this->updateHealthWidget();
661}
662
663/**
664 * @brief creates the HealthWidget
665 *
666 * since not all entities need an HealthWidget, it is only created on request.
667 */
668void WorldEntity::createHealthWidget()
669{
670  if (this->healthWidget == NULL)
671  {
672    this->healthWidget = new OrxGui::GLGuiBar();
673    this->healthWidget->setSize2D(30,400);
674    this->healthWidget->setAbsCoor2D(10,100);
675
676    this->updateHealthWidget();
677  }
678  else
679    PRINTF(3)("Allready created the HealthWidget for %s::%s\n", this->getClassName(), this->getName());
680}
681
682void WorldEntity::increaseHealthMax(float increaseHealth)
683{
684  this->healthMax += increaseHealth;
685  this->updateHealthWidget();
686}
687
688
689OrxGui::GLGuiWidget* WorldEntity::getHealthWidget()
690{
691  this->createHealthWidget();
692  return this->healthWidget;
693}
694
695/**
696 * @param visibility shows or hides the health-bar
697 * (creates the widget if needed)
698 */
699void WorldEntity::setHealthWidgetVisibilit(bool visibility)
700{
701  if (visibility)
702  {
703    if (this->healthWidget != NULL)
704      this->healthWidget->show();
705    else
706    {
707      this->createHealthWidget();
708      this->updateHealthWidget();
709      this->healthWidget->show();
710    }
711  }
712  else if (this->healthWidget != NULL)
713    this->healthWidget->hide();
714}
715
716/**
717 * @brief updates the HealthWidget
718 */
719void WorldEntity::updateHealthWidget()
720{
721  if (this->healthWidget != NULL)
722  {
723    this->healthWidget->setMaximum(this->healthMax);
724    this->healthWidget->setValue(this->health);
725  }
726}
727
728
729/**
730 * DEBUG-DRAW OF THE BV-Tree.
731 * @param depth What depth to draw
732 * @param drawMode the mode to draw this entity under
733 */
734void WorldEntity::drawBVTree(int depth, int drawMode) const
735{
736  glMatrixMode(GL_MODELVIEW);
737  glPushMatrix();
738  /* translate */
739  glTranslatef (this->getAbsCoor ().x,
740                this->getAbsCoor ().y,
741                this->getAbsCoor ().z);
742  /* rotate */
743  Vector tmpRot = this->getAbsDir().getSpacialAxis();
744  glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
745
746
747  if (this->obbTree)
748    this->obbTree->drawBV(depth, drawMode);
749
750
751  glPopMatrix();
752}
753
754
755/**
756 * Debug the WorldEntity
757 */
758void WorldEntity::debugEntity() const
759{
760  PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassName(), this->getName());
761  this->debugNode();
762  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber) , this->models.size());
763  for (unsigned int i = 0; i < this->models.size(); i++)
764  {
765    if (models[i] != NULL)
766      PRINT(0)(" : %d:%s", i, this->models[i]->getName());
767  }
768  PRINT(0)("\n");
769
770}
771
772
773/**
774 * handler for changes on registred vars
775 * @param id id's which changed
776 */
777void WorldEntity::varChangeHandler( std::list< int > & id )
778{
779  if ( std::find( id.begin(), id.end(), modelFileName_handle ) != id.end() ||
780       std::find( id.begin(), id.end(), scaling_handle ) != id.end()
781     )
782  {
783    loadModel( modelFileName, scaling );
784  }
785
786  PNode::varChangeHandler( id );
787}
788
Note: See TracBrowser for help on using the repository browser.