Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 26, 2005, 4:41:09 AM (20 years ago)
Author:
bensch
Message:

orxonox/trunk: syncing PNode to Element2D again

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/lib/graphics/render2D/element_2d.cc

    r6295 r6299  
    3030
    3131using namespace std;
    32 
    33 /**
    34  * standard constructor
    35  */
    36 Element2D::Element2D()
    37 {
    38   this->init();
    39   this->setParent2D(NullElement2D::getInstance());
    40 }
    4132
    4233/**
    … …  
    4738 * itself. Otherwise it would result in an endless Loop.
    4839 */
    49 Element2D::Element2D (Element2D* parent, E2D_LAYER layer)
    50 {
    51   this->init();
     40Element2D::Element2D (Element2D* parent, E2D_LAYER layer, short nodeFlags)
     41{
     42  this->setClassID(CL_ELEMENT_2D, "Element2D");
     43
     44  this->setVisibility(true);
     45  this->activate2D();
     46  this->setAlignment(E2D_ALIGN_NONE);
     47  this->bindNode = NULL;
     48
     49  this->parentMode = nodeFlags;
     50  this->parent = NULL;
     51  this->absDirection = 0.0;
     52  this->relDirection = 0.0;
     53  this->bRelCoorChanged = true;
     54  this->bRelDirChanged = true;
     55  this->toCoordinate = NULL;
     56  this->toDirection = NULL;
     57  this->setSize2D(1, 1);
     58
     59
    5260  this->layer = layer;
    53   // check Parenting, and if ok parent the stuff
    54   if (this->parent != NULL)
    55     this->setParent2D(parent);
    56   else if (NullElement2D::isInstanciated())
    57     this->setParent2D(NullElement2D::getInstance());
    58 }
     61  if (parent != NULL)
     62    parent->addChild2D(this);
     63}
     64
     65
     66/**
     67 * @brief the mighty NullElement
     68 * TopMost Node of them all.
     69 */
     70Element2D* Element2D::nullElement = NULL;
     71
    5972
    6073/**
    … …  
    7487Element2D::~Element2D ()
    7588{
    76   // remove the Node, delete it's children.
    77   while (this->children.size() > 0)
    78   {
    79     Element2D* child = this->children.front();
    80     this->children.pop_front();
    81     delete child;
    82   }
     89  // remove the Element2D, delete it's children (if required).
     90  std::list<Element2D*>::iterator tmp = this->children.begin();
     91  std::list<Element2D*>::iterator deleteNode;
     92  while(!this->children.empty())
     93    while (tmp != this->children.end())
     94    {
     95      deleteNode = tmp;
     96      tmp++;
     97//      printf("TEST::%s(%s) %s\n", (*deleteNode)->getName(), (*deleteNode)->getClassName(), this->getName());
     98      if ((this->parentMode & E2D_PROHIBIT_CHILD_DELETE) ||
     99          ((*deleteNode)->parentMode & E2D_PROHIBIT_DELETE_WITH_PARENT))
     100      {
     101        if (this == Element2D::nullElement && (*deleteNode)->parentMode & E2D_REPARENT_TO_NULL)
     102          delete (*deleteNode);
     103        else
     104          (*deleteNode)->reparent2D();
     105      }
     106      else
     107        delete (*deleteNode);
     108    }
     109
    83110  if (this->parent != NULL)
    84111  {
    85     this->parent->eraseChild(this);
     112    this->parent->eraseChild2D(this);
    86113    this->parent = NULL;
    87114  }
    … …  
    92119  if (this->toDirection != NULL)
    93120    delete this->toDirection;
    94 }
    95 
    96 
    97 /**
    98  * @brief initializes a Element2D
    99  */
    100 void Element2D::init()
    101 {
    102   this->setClassID(CL_ELEMENT_2D, "Element2D");
    103 
    104   this->setVisibility(true);
    105   this->setActiveness(true);
    106   this->setAlignment(E2D_ALIGN_NONE);
    107   this->layer = E2D_DEFAULT_LAYER;
    108   this->bindNode = NULL;
    109 
    110   this->setParentMode2D(E2D_PARENT_ALL);
    111   this->parent = NULL;
    112   this->absDirection = 0.0;
    113   this->relDirection = 0.0;
    114   this->bRelCoorChanged = true;
    115   this->bRelDirChanged = true;
    116   this->toCoordinate = NULL;
    117   this->toDirection = NULL;
    118   this->setSize2D(1,1);
    119 }
     121
     122  if (this == Element2D::nullElement)
     123    Element2D::nullElement = NULL;
     124}
     125
    120126
    121127/**
    … …  
    161167  LOAD_PARAM_START_CYCLE(root, element);
    162168  {
    163     LoadParam_CYCLE(element, "parent", this, Element2D, addChild2D)
     169    LoadParam_CYCLE(element, "child", this, Element2D, addChild2D)
    164170        .describe("adds a new Child to the current Node.");
    165171  }
    … …  
    213219
    214220/**
    215  * sets a node, this 2D-Element should be shown upon
     221 * @brief sets a node, this 2D-Element should be shown upon
    216222 * @param bindNode the name of the Node (should be existing)
    217223 */
    … …  
    511517  {
    512518    PRINTF(5)("Element2D::addChild() - reparenting node: removing it and adding it again\n");
    513     child->parent->eraseChild(child);
    514   }
    515   child->parent = this;
    516   if (likely(this != NULL))
    517   {
    518     // ELEMENT SORTING TO LAYERS  //
    519     unsigned int childCount = this->children.size();
    520 
    521     list<Element2D*>::iterator elem;
    522     for (elem = this->children.begin(); elem != this->children.end(); elem++)
    523     {
    524       if ((*elem)->layer < child->layer)
    525       {
    526         this->children.insert(elem, child);
    527         break;
    528       }
    529     }
    530 
    531     if (childCount == this->children.size())
    532       this->children.push_back(child);
    533     ////////////////////////////////
    534     if (unlikely(this->layer > child->getLayer()))
    535     {
    536       PRINTF(2)("Layer '%s' of Child(%s) lower than parents(%s) layer '%s'. updating...\n",
    537       Element2D::layer2DToChar(child->getLayer()),child->getName(), this->getName(), Element2D::layer2DToChar(this->layer));
    538       child->setLayer(this->layer);
    539     }
    540   }
    541   child->parentCoorChanged();
     519    child->parent->eraseChild2D(child);
     520  }
     521  if (this->checkIntegrity(child))
     522  {
     523    child->parent = this;
     524    if (likely(this != NULL))
     525    {
     526     // ELEMENT SORTING TO LAYERS  //
     527     unsigned int childCount = this->children.size();
     528
     529     list<Element2D*>::iterator elem;
     530     for (elem = this->children.begin(); elem != this->children.end(); elem++)
     531     {
     532       if ((*elem)->layer < child->layer)
     533       {
     534         this->children.insert(elem, child);
     535         break;
     536       }
     537     }
     538     if (childCount == this->children.size())
     539       this->children.push_back(child);
     540     ////////////////////////////////
     541     if (unlikely(this->layer > child->getLayer()))
     542     {
     543       PRINTF(2)("Layer '%s' of Child(%s) lower than parents(%s) layer '%s'. updating...\n",
     544       Element2D::layer2DToChar(child->getLayer()),child->getName(), this->getName(), Element2D::layer2DToChar(this->layer));
     545       child->setLayer(this->layer);
     546     }
     547   }
     548   else
     549   {
     550     PRINTF(1)("Tried to reparent2D to own child '%s::%s' to '%s::%s'.\n",
     551              this->getClassName(), this->getName(), child->getClassName(), child->getName());
     552     child->parent = NULL;
     553   }
     554  }
     555  child->parentCoorChanged2D();
    542556}
    543557
    … …  
    566580
    567581/**
     582 * !! PRIVATE FUNCTION
     583 * @brief reparents an Element2D (happens on Parents Node delete or remove and Flags are set.)
     584 */
     585void Element2D::reparent2D()
     586{
     587  if (this->parentMode & E2D_REPARENT_TO_NULL)
     588    this->setParent2D((Element2D*)NULL);
     589  else if (this->parentMode & E2D_REPARENT_TO_PARENTS_PARENT && this->parent != NULL)
     590    this->setParent2D(this->parent->getParent2D());
     591  else
     592    this->setParent2D(Element2D::getNullElement());
     593}
     594
     595
     596/**
     597 * @param child the child to be erased from this Nodes List
     598 */
     599void Element2D::eraseChild2D(Element2D* child)
     600{
     601  assert (this != NULL && child != NULL);
     602  std::list<Element2D*>::iterator childIT = std::find(this->children.begin(), this->children.end(), child);
     603  this->children.erase(childIT);
     604}
     605
     606
     607
     608/**
    568609 * remove this Element from the tree and adds all children to NullElement2D
    569610 *
    … …  
    572613void Element2D::remove2D()
    573614{
    574   list<Element2D*>::iterator child;
    575   for (child = this->children.begin(); child != this->children.end(); child++)
    576     NullElement2D::getInstance()->addChild2D(*child);
    577 
    578   this->children.clear();
    579 
     615  list<Element2D*>::iterator child = this->children.begin();
     616  list<Element2D*>::iterator reparenter;
     617  while (child != this->children.end())
     618  {
     619    reparenter = child;
     620    child++;
     621    if (this->parentMode & E2D_REPARENT_CHILDREN_ON_REMOVE ||
     622        (*reparenter)->parentMode & E2D_REPARENT_ON_PARENTS_REMOVE)
     623    {
     624      printf("TEST----------------%s ---- %s\n", this->getClassName(), (*reparenter)->getClassName());
     625      (*reparenter)->reparent2D();
     626      printf("REPARENTED TO: %s::%s\n",(*reparenter)->getParent2D()->getClassName(),(*reparenter)->getParent2D()->getName());
     627    }
     628  }
    580629  if (this->parent != NULL)
    581630  {
    582     this->parent->eraseChild(this);
     631    this->parent->eraseChild2D(this);
    583632    this->parent = NULL;
    584633  }
    585634}
    586635
    587 /**
    588  * sets the parent of this Element2D
    589  * @param parent the Parent to set
    590  */
    591 void Element2D::setParent2D (Element2D* parent)
    592 {
    593   parent->addChild2D(this);
    594 }
    595636
    596637/**
    … …  
    603644  if (parentNode != NULL)
    604645    parentNode->addChild2D(this);
    605 
     646  else
     647    PRINTF(2)("Not Found Element2D's (%s::%s) new Parent by Name: %s\n",
     648                this->getClassName(), this->getName(), parentName);
    606649}
    607650
    … …  
    634677  parentNode->addChild2D(this);
    635678
    636   if (this->parentMode & PNODE_ROTATE_MOVEMENT) //! @todo implement this.
     679  if (this->parentMode & E2D_PARENT_ROTATE_MOVEMENT) //! @todo implement this.
    637680    ;//this->setRelCoor(this->parent->getAbsDir().inverse().apply(tmpV - this->parent->getAbsCoor()));
    638681  else
    … …  
    656699}
    657700
    658 /** @param child the child to be erased from this Nodes List */
    659 void Element2D::eraseChild(Element2D* child)
    660 {
    661   assert (this != NULL && child != NULL);
    662   std::list<Element2D*>::iterator childIT = std::find(this->children.begin(), this->children.end(), child);
    663   this->children.erase(childIT);
    664 }
     701/**
     702 * @param parentMode sets the parentingMode of this Node
     703 */
     704void Element2D::setParentMode2D(E2D_PARENT_MODE parentMode)
     705{
     706  this->parentMode &= (0xfff0 | parentMode);
     707}
     708
    665709
    666710/**
    … …  
    672716  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
    673717}
     718
     719
     720/**
     721 * @returns the NullElement (and if needed (most probably) creates it)
     722 */
     723Element2D* Element2D::createNullElement()
     724{
     725  if (likely(Element2D::nullElement == NULL))
     726  {
     727    Element2D::nullElement = new Element2D(NULL, E2D_LAYER_BELOW_ALL, E2D_PARENT_MODE_DEFAULT | E2D_REPARENT_TO_NULL);
     728    Element2D::nullElement->setName("NullElement");
     729  }
     730  return Element2D::nullElement;
     731}
     732
     733
     734/**
     735 * !! PRIVATE FUNCTION
     736 * @brief checks the upward integrity (e.g if Element2D is somewhere up the Node tree.)
     737 * @param checkParent the Parent to check.
     738 * @returns true if the integrity-check succeeds, false otherwise.
     739 *
     740 * If there is a second occurence of checkParent before NULL, then a loop could get
     741 * into the Tree, and we do not want this.
     742 */
     743bool Element2D::checkIntegrity(const Element2D* checkParent) const
     744{
     745  const Element2D* parent = this;
     746  while ( (parent = parent->getParent2D()) != NULL)
     747    if (unlikely(parent == checkParent))
     748      return false;
     749  return true;
     750}
     751
    674752
    675753/**
    … …  
    796874
    797875  // UPDATE CHILDREN
    798   if(this->children.size() > 0)
     876  if(!this->children.empty() || this->parentMode & E2D_UPDATE_CHILDREN_IF_INACTIVE)
    799877  {
    800878    list<Element2D*>::iterator child;
    … …  
    803881      /* if this node has changed, make sure, that all children are updated also */
    804882      if( likely(this->bRelCoorChanged))
    805         (*child)->parentCoorChanged ();
     883        (*child)->parentCoorChanged2D();
    806884      if( likely(this->bRelDirChanged))
    807         (*child)->parentDirChanged ();
     885        (*child)->parentDirChanged2D();
    808886
    809887      (*child)->update2D(dt);
    … …  
    816894  this->bRelDirChanged = false;
    817895}
     896
    818897
    819898/**
    … …  
    865944void Element2D::tick2D(float dt)
    866945{
    867   if (this->active)
     946  if (this->bActive)
    868947    this->tick(dt);
    869948  if (this->children.size() > 0)
    … …  
    881960void Element2D::draw2D(short layer) const
    882961{
    883   if (this->visible)
     962  if (this->bVisible)
    884963    this->draw();
    885964  if (this->children.size() > 0)
    … …  
    9301009    {
    9311010      // drawing the Dependency graph
    932       if (this != NullElement2D::getInstance())
     1011      if (this != Element2D::getNullElement())
    9331012      {
    9341013        glBegin(GL_LINES);
    … …  
    10391118    return (E2D_DEFAULT_LAYER);
    10401119}
    1041 
    1042 
    1043 
    1044 
    1045 ///////////////////
    1046 // NullElement2D //
    1047 ///////////////////
    1048 NullElement2D* NullElement2D::singletonRef = 0;
    1049 
    1050 /**
    1051  * @brief creates the one and only NullElement2D
    1052  */
    1053 NullElement2D::NullElement2D () : Element2D(NULL, E2D_LAYER_BELOW_ALL)
    1054 {
    1055   this->setClassID(CL_NULL_ELEMENT_2D, "NullElement2D");
    1056   this->setName("NullElement2D");
    1057 
    1058   this->setParentMode2D(E2D_PARENT_ALL);
    1059   NullElement2D::singletonRef = this;
    1060 }
    1061 
    1062 
    1063 /**
    1064  *  standard deconstructor
    1065  */
    1066 NullElement2D::~NullElement2D ()
    1067 {
    1068   NullElement2D::singletonRef = NULL;
    1069 }
Note: See TracChangeset for help on using the changeset viewer.