Changeset 5082 in orxonox.OLD for trunk/src/lib/graphics/render2D/element_2d.cc

Timestamp:

Aug 19, 2005, 1:29:18 PM (19 years ago)

Author:

bensch

Message:

orxonox/trunk: implemented PNode-functionality in Element2D,
update and debugDraw still missing

File:

• trunk/src/lib/graphics/render2D/element_2d.cc (modified) (11 diffs)

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

@@ -24 +24 @@
 #include "tinyxml.h"
 #include "class_list.h"
+#include "list.h"
 
 using namespace std;
@@ -59 +60 @@
   this->setAlignment(E2D_ALIGN_NONE);
   this->layer = E2D_TOP;
+  this->setParentMode2D(E2D_PARENT_ALL);
+
+  this->bRelCoorChanged = true;
+  this->bRelDirChanged = true;
 
   Render2D::getInstance()->registerElement2D(this);
@@ -180 +185 @@
 void Element2D::setRelCoor2D (const Vector& relCoord)
 {
+  this->relCoordinate = relCoord;
+  this->bRelCoorChanged = true;
 }
 
@@ -185 +192 @@
 void Element2D::setRelCoor2D (float x, float y, float z)
 {
+  this->setAbsCoor2D(Vector(x,y,z));
 }
 
 void Element2D::setRelCoorSoft2D(const Vector& relCoordSoft, float bias)
 {
-}
-
-void Element2D::setRelCoorSoft2D(float x, float y, float dontCare, float bias)
-{
+  if (likely(this->toCoordinate == NULL))
+    this->toCoordinate = new Vector();
+
+  *this->toCoordinate = relCoordSoft;
+  this->bias = bias;
+}
+
+void Element2D::setRelCoorSoft2D(float x, float y, float depth, float bias)
+{
+  this->setRelCoorSoft2D(Vector(x, y, depth), bias);
 }
 
 void Element2D::setAbsCoor2D (const Vector& absCoord)
 {
+  if( likely(this->parentMode & E2D_PARENT_MOVEMENT))
+  {
+    /* if you have set the absolute coordinates this overrides all other changes */
+    if (likely(this->parent != NULL))
+      this->relCoordinate = absCoord - parent->getAbsCoor2D ();
+    else
+      this->relCoordinate = absCoord;
+  }
+  if( this->parentMode & E2D_PARENT_ROTATE_MOVEMENT)
+  {
+    if (likely(this->parent != NULL))
+      this->relCoordinate = absCoord - parent->getAbsCoor2D ();
+    else
+      this->relCoordinate = absCoord;
+  }
+
+  this->bRelCoorChanged = true;
 }
 
 void Element2D::setAbsCoor2D (float x, float y, float depth)
 {
+  this->setAbsCoor2D(Vector(x, y, depth));
 }
 
 void Element2D::shiftCoor (const Vector& shift)
 {
+  this->relCoordinate += shift;
+  this->bRelCoorChanged = true;
+
 }
 
@@ -210 +245 @@
 void Element2D::setRelDir2D (float relDir)
 {
+  this->relDirection = relDir;
+  this->bRelDirChanged = true;
 }
 
 void Element2D::setRelDirSoft2D(float relDirSoft, float bias)
 {
+  if (likely(this->toDirection == NULL))
+    this->toDirection = new float;
+
+  *this->toDirection = relDirSoft;
+  this->bias = bias;
 }
 
 void Element2D::setAbsDir2D (float absDir)
 {
+  if (likely(this->parent != NULL))
+    this->relDirection = absDir - this->parent->getAbsDir2D();
+  else
+    this->relDirection = absDir;
+
+  this->bRelDirChanged = true;
 }
 
 void Element2D::shiftDir (float shiftDir)
 {
+  this->relDirection = this->relDirection + shiftDir;
+  this->bRelDirChanged = true;
 }
 
@@ -227 +277 @@
 void Element2D::addChild2D (Element2D* child, int parentingMod)
 {
+  if( likely(child->parent != NULL))
+  {
+    PRINTF(4)("PNode::addChild() - reparenting node: removing it and adding it again\n");
+    child->parent->children->remove(child);
+  }
+  child->parentMode = parentMode;
+  child->parent = this;
+  this->children->add(child);
+  child->parentCoorChanged();
 }
 
 void Element2D::addChild2D (const char* childName)
 {
+  Element2D* childNode = dynamic_cast<Element2D*>(ClassList::getObject(childName, CL_ELEMENT_2D));
+  if (childNode != NULL)
+    this->addChild2D(childNode);
 }
 
 void Element2D::removeChild2D (Element2D* child)
 {
+  child->remove2D();
+  this->children->remove(child);
+  child->parent = NULL;
 }
 
 void Element2D::remove2D()
 {
+  tIterator<Element2D>* iterator = this->children->getIterator();
+  Element2D* pn = iterator->nextElement();
+
+  while( pn != NULL)
+  {
+    NullElement2D::getInstance()->addChild2D(pn, pn->getParentMode2D());
+    pn = iterator->nextElement();
+  }
+  delete iterator;
+  this->parent->children->remove(this);
 }
 
@@ -244 +319 @@
 void Element2D::setParent2D (Element2D* parent)
 {
+  parent->addChild2D(this);
 }
 
 void Element2D::setParent2D (const char* parentName)
 {
-}
-
-
-void Element2D::softReparent(PNode* parentNode, float bias)
-{
-}
-
-void Element2D::softReparent(const char* parentName, float bias)
-{
+  Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
+  if (parentNode != NULL)
+    parentNode->addChild2D(this);
+
+}
+
+
+void Element2D::softReparent2D(Element2D* parentNode, float bias)
+{
+  if (this->parent == parentNode)
+    return;
+
+  if (likely(this->toCoordinate == NULL))
+  {
+    this->toCoordinate = new Vector();
+    *this->toCoordinate = this->getRelCoor2D();
+  }
+  if (likely(this->toDirection == NULL))
+  {
+    this->toDirection = new float;
+    *this->toDirection = this->getRelDir2D();
+  }
+  this->bias = bias;
+
+
+  Vector tmpV = this->getAbsCoor2D();
+  float tmpQ = this->getAbsDir2D();
+
+  parentNode->addChild2D(this);
+
+  if (this->parentMode & PNODE_ROTATE_MOVEMENT)
+    ;//this->setRelCoor(this->parent->getAbsDir().inverse().apply(tmpV - this->parent->getAbsCoor()));
+  else
+    this->setRelCoor2D(tmpV - parentNode->getAbsCoor2D());
+
+  this->setRelDir2D(tmpQ - parentNode->getAbsDir2D());
+}
+
+void Element2D::softReparent2D(const char* parentName, float bias)
+{
+  Element2D* parentNode = dynamic_cast<Element2D*>(ClassList::getObject(parentName, CL_ELEMENT_2D));
+  if (parentNode != NULL)
+    this->softReparent2D(parentNode, bias);
 }
 
@@ -262 +372 @@
 void Element2D::setParentMode2D (const char* parentingMode)
 {
+  this->setParentMode2D(Element2D::charToParentingMode2D(parentingMode));
 }
 
@@ -267 +378 @@
 void Element2D::update2D (float dt)
 {
+
 }
 
@@ -272 +384 @@
 void Element2D::debug (unsigned int depth, unsigned int level) const
 {
-}
+  for (unsigned int i = 0; i < level; i++)
+    PRINT(0)(" |");
+  if (this->children->getSize() > 0)
+    PRINT(0)(" +");
+  else
+    PRINT(0)(" -");
+  PRINT(0)("Element2D(%s::%s) - absCoord: (%0.2f, %0.2f), relCoord(%0.2f, %0.2f), direction(%0.2f) - %s\n",
+  this->getClassName(),
+  this->getName(),
+  this->absCoordinate.x,
+  this->absCoordinate.y,
+  this->relCoordinate.x,
+  this->relCoordinate.y,
+  this->getAbsDir2D(),
+  Element2D::parentingModeToChar2D(parentMode));
+  if (depth >= 2 || depth == 0)
+  {
+    tIterator<Element2D>* iterator = this->children->getIterator();
+      //PNode* pn = this->children->enumerate ();
+    Element2D* pn = iterator->nextElement();
+    while( pn != NULL)
+    {
+      if (depth == 0)
+        pn->debug(0, level + 1);
+      else
+        pn->debug(depth - 1, level +1);
+      pn = iterator->nextElement();
+    }
+    delete iterator;
+  }
+}
+
+#include "color.h"
 
 void Element2D::debugDraw2D(unsigned int depth, float size, Vector color) const
 {
+
 }
 
 
 // helper functions //
-const char* Element2D::parentingModeToChar(int parentingMode)
-{
-}
-
-E2D_PARENT_MODE Element2D::charToParentingMode(const char* parentingMode)
-{
+const char* Element2D::parentingModeToChar2D(int parentingMode)
+{
+  if (parentingMode == E2D_PARENT_LOCAL_ROTATE)
+    return "local-rotate";
+  else if (parentingMode == E2D_PARENT_ROTATE_MOVEMENT)
+    return "rotate-movement";
+  else if (parentingMode == E2D_PARENT_MOVEMENT)
+    return "movement";
+  else if (parentingMode == E2D_PARENT_ALL)
+    return "all";
+  else if (parentingMode == E2D_PARENT_ROTATE_AND_MOVE)
+    return "rotate-and-move";
+}
+
+E2D_PARENT_MODE Element2D::charToParentingMode2D(const char* parentingMode)
+{
+  if (!strcmp(parentingMode, "local-rotate"))
+    return (E2D_PARENT_LOCAL_ROTATE);
+  else  if (!strcmp(parentingMode, "rotate-movement"))
+    return (E2D_PARENT_ROTATE_MOVEMENT);
+  else  if (!strcmp(parentingMode, "movement"))
+    return (E2D_PARENT_MOVEMENT);
+  else  if (!strcmp(parentingMode, "all"))
+    return (E2D_PARENT_ALL);
+  else  if (!strcmp(parentingMode, "rotate-and-move"))
+    return (E2D_PARENT_ROTATE_AND_MOVE);
 }
 
@@ -301 +466 @@
   this->positioning();
 }
+
+
+
+
+
+
+
+NullElement2D* NullElement2D::singletonRef = 0;
+
+/**
+ *  creates the one and only NullElement2D
+ * @param absCoordinate the cordinate of the Parent (normally Vector(0,0,0))
+ */
+NullElement2D::NullElement2D ()
+{
+  this->setClassID(CL_NULL_PARENT, "NullElement2D");
+  this->setName("NullElement2D");
+
+  this->setParentMode2D(E2D_PARENT_ALL);
+  NullElement2D::singletonRef = this;
+}
+
+
+/**
+ *  standard deconstructor
+ */
+NullElement2D::~NullElement2D ()
+{
+  //delete singletonRef;
+  NullElement2D::singletonRef = NULL;
+}