Source/System/GraphOp/OSGTravMaskGraphOp.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *                   contact: dan.guilliams@gmail.com                        *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39
  40 /***************************************************************************\
  41 *                             Includes                                    *
  42 \***************************************************************************/
  43
  44 #include "OSGTravMaskGraphOp.h"
  45 #include "OSGGraphOpFactory.h"
  46 #include "OSGNameAttachment.h"
  47 #include <string>
  48
  49
  50 OSG_USING_NAMESPACE
  51
  52 /***************************************************************************\
  53  *                            Description                                  *
  54 \***************************************************************************/
  55
  56 /*! \class TravMaskGraphOp
  57     \ingroup GrpSystemNodeCoresDrawablesGeometry
  58
  59     A class used to change traversal masks of nodes meeting certain criteria.
  60
  61 */
  62
  63 namespace
  64 {
  65     //! Register the GraphOp with the factory
  66     static bool registerOp(void)
  67     {
  68         GraphOpRefPtr newOp = TravMaskGraphOp::create();
  69
  70         GraphOpFactory::the()->registerOp(newOp);
  71         return true;
  72     }
  73
  74     static StaticInitFuncWrapper registerOpWrapper(registerOp);
  75
  76 } // namespace
  77
  78 /***************************************************************************\
  79  *                           Instance methods                              *
  80 \***************************************************************************/
  81
  82 /*-------------------------------------------------------------------------*\
  83  -  public                                                                 -
  84 \*-------------------------------------------------------------------------*/
  85
  86
  87 /*------------- constructors & destructors --------------------------------*/
  88
  89 TravMaskGraphOp::TravMaskGraphOp(void) :
  90     Inherited                (         ),
  91         mMatchName               (true     ),
  92     mMatchRegex              (         ),
  93     mMatchWholeName          (true     ),
  94
  95         mMatchNodeCoreType       (false    ),
  96         mNodeCoreType            (NULL     ),
  97         mMatchDerivedCoreTypes   (true     ),
  98
  99         mMatchCurTravMask        (false    ),
 100         mMatchCurTravMaskValue   (1        ),
 101         mMatchMaskCondition      (BIT_EQUAL),
 102
 103     mApplyMaskToAllDecendents(false    ),
 104     mApplyToNonMatching      (false    ),
 105         mNewTravMask             (1        ),
 106     mApplyNewMaskOperation   (BIT_EQUAL),
 107
 108         mNumChanged              (0        )
 109 {
 110         mMatchRegex = boost::xpressive::cregex::compile(
 111         ".*",
 112         boost::xpressive::regex_constants::icase);
 113 }
 114
 115 TravMaskGraphOp::~TravMaskGraphOp(void)
 116 {
 117 }
 118
 119 TravMaskGraphOpTransitPtr TravMaskGraphOp::create(void)
 120 {
 121     return TravMaskGraphOpTransitPtr(new TravMaskGraphOp());
 122 }
 123
 124 GraphOpTransitPtr TravMaskGraphOp::clone(void)
 125 {
 126     return GraphOpTransitPtr(new TravMaskGraphOp());
 127 }
 128
 129 bool TravMaskGraphOp::traverse(Node *root)
 130 {
 131     return GraphOp::traverse(root);
 132 }
 133
 134 void TravMaskGraphOp::setMatchWholeName(bool value)
 135 {
 136         mMatchWholeName = value;
 137 }
 138
 139 void TravMaskGraphOp::setMatchDerivedCoreTypes(bool value)
 140 {
 141         mMatchDerivedCoreTypes = value;
 142 }
 143
 144 void TravMaskGraphOp::setNewTravMaskOperation(UInt8 ApplyNewMaskOperation)
 145 {
 146         mApplyNewMaskOperation = ApplyNewMaskOperation;
 147 }
 148
 149 void TravMaskGraphOp::setMatchMaskCondition(UInt8 MatchMaskCondition)
 150 {
 151         mMatchMaskCondition = MatchMaskCondition;
 152 }
 153
 154 void TravMaskGraphOp::setApplyMaskToAllDecendents(bool ApplyMaskToAllDecendents)
 155 {
 156         mApplyMaskToAllDecendents = ApplyMaskToAllDecendents;
 157 }
 158
 159 void TravMaskGraphOp::setApplyToNonMatching(bool ApplyToNonMatching)
 160 {
 161         mApplyToNonMatching = ApplyToNonMatching;
 162 }
 163
 164
 165 void TravMaskGraphOp::setMatchRegex(const std::string& MatchName)
 166 {
 167         mMatchRegex = boost::xpressive::cregex::compile(
 168         MatchName,
 169         boost::xpressive::regex_constants::icase);
 170 }
 171
 172 void TravMaskGraphOp::setMatchRegex(const boost::xpressive::cregex &MatchRegex)
 173 {
 174         mMatchRegex = MatchRegex;
 175 }
 176
 177 void TravMaskGraphOp::setNodeCoreType(const std::string &TypeName)
 178 {
 179         mNodeCoreType = FieldContainerFactory::the()->findType(TypeName.c_str());
 180 }
 181
 182 void TravMaskGraphOp::setNewTravMask(UInt32 NewTraversalMask)
 183 {
 184         mNewTravMask = NewTraversalMask;
 185 }
 186
 187 void TravMaskGraphOp::setCurrentTravMaskValue(UInt32 CurrentTraversalMask)
 188 {
 189         mMatchCurTravMaskValue = CurrentTraversalMask;
 190 }
 191
 192 void TravMaskGraphOp::setMatchName(bool MatchName)
 193 {
 194         mMatchName = MatchName;
 195 }
 196
 197 void TravMaskGraphOp::setMatchNodeCoreType(bool MatchCore)
 198 {
 199         mMatchNodeCoreType = MatchCore;
 200 }
 201
 202 void TravMaskGraphOp::setMatchCurrentTravMask(bool MatchCurMask)
 203 {
 204         mMatchCurTravMask = MatchCurMask;
 205 }
 206
 207 void TravMaskGraphOp::setParams(const std::string params)
 208 {
 209     ParamSet ps(params);
 210
 211     ps("newtraversalmask",         mNewTravMask             );
 212     ps("applymasktoalldecendents", mApplyMaskToAllDecendents);
 213     ps("applytononmatching",       mApplyToNonMatching      );
 214     //ps("ApplyNewMaskOperation", mApplyNewMaskOperation);
 215
 216
 217     //Name Matching
 218     ps("matchname", mMatchName);
 219
 220     std::string MatchRegex;
 221
 222         ps("matchregex",     MatchRegex     );
 223     ps("matchwholename", mMatchWholeName);
 224
 225         mMatchRegex = boost::xpressive::cregex::compile(
 226         MatchRegex,
 227         boost::xpressive::regex_constants::icase);
 228
 229     //Type Matching
 230     ps("matchnodecoretype",     mMatchNodeCoreType    );
 231     ps("matchderivedcoretypes", mMatchDerivedCoreTypes);
 232
 233     std::string NodeCoreTypeName;
 234
 235     ps("nodecoretypename", NodeCoreTypeName);
 236
 237         mNodeCoreType =
 238         FieldContainerFactory::the()->findType(NodeCoreTypeName.c_str());
 239
 240     //Mask Matching
 241         ps("matchcurtravmask",      mMatchCurTravMask     );
 242         ps("matchcurtravmaskvalue", mMatchCurTravMaskValue);
 243         //ps("MatchMaskCondition",mMatchMaskCondition);
 244
 245     std::string out = ps.getUnusedParams();
 246
 247     if(out.length())
 248     {
 249         FWARNING(("TravMaskGraphOp doesn't have parameters '%s'.\n",
 250                 out.c_str()));
 251     }
 252 }
 253
 254 std::string TravMaskGraphOp::usage(void)
 255 {
 256     return
 257     "NodeNameTravMask: Changes traversal masks of nodes based on certain criteria.\n"
 258     "Params: name (type, default)\n"
 259     "   NewTraversalMask (UInt32, 0): Value to set the traversal mask to if it meets the matching criteria\n"
 260     "   ApplyMaskToAllDecendents (bool, false): Applies the mask operation to all decendents of a matching node\n"
 261     "   ApplyToNonMatching (bool, false): Applies the mask operation to all non-matching nodes\n"
 262
 263     "   MatchName (string, \"\"): Name to search for in the node's name.\n"
 264     "   MatchWholeName (bool, true): Matches only if the entire name matches the search regex\n"
 265
 266     "   NodeCoreTypeID (UInt32, 0): NodeCoreTypeID to check for.\n"
 267     "   MatchDerivedCoreTypes (bool, true): Will match all nodes whos type is derived from the searched NodeCore type\n"
 268
 269     "   CurTraversalMask (UInt32, 1): Current Traversal mask to check for.\n";
 270
 271 }
 272
 273 UInt32 TravMaskGraphOp::getNumChanged(void)
 274 {
 275         return mNumChanged;
 276 }
 277
 278
 279 /*-------------------------------------------------------------------------*\
 280  -  protected                                                              -
 281 \*-------------------------------------------------------------------------*/
 282
 283
 284 /*-------------------------------------------------------------------------*\
 285  -  private                                                                -
 286 \*-------------------------------------------------------------------------*/
 287
 288 Action::ResultE TravMaskGraphOp::traverseEnter(Node * const node)
 289 {
 290         bool setMask(false);
 291
 292     //Name Matching
 293         if(mMatchName)
 294         {
 295         const Char8 *namePtr = OSG::getName(node);
 296
 297         if(namePtr == NULL)
 298         {
 299             namePtr = "";
 300         }
 301
 302         if(mMatchWholeName)
 303         {
 304             setMask = boost::xpressive::regex_match (namePtr, mMatchRegex);
 305                 }
 306         else
 307         {
 308             setMask = boost::xpressive::regex_search(namePtr, mMatchRegex);
 309         }
 310         }
 311
 312
 313     //Type Matching
 314         if(mMatchNodeCoreType && mNodeCoreType != NULL)
 315     {
 316         if(mMatchDerivedCoreTypes)
 317         {
 318             if(node->getCore()->getType().isDerivedFrom(*mNodeCoreType))
 319             {
 320                 setMask = true;
 321             }
 322         }
 323         else
 324         {
 325             if(node->getCore()->getType() == *mNodeCoreType)
 326             {
 327                 setMask = true;
 328             }
 329         }
 330     }
 331
 332     //Mask Matching
 333         if(mMatchCurTravMask)
 334     {
 335         bool BitTest(false);
 336
 337         switch(mMatchMaskCondition)
 338         {
 339             case BIT_AND:
 340                 BitTest = 0x0000 != (node->getTravMask()   &
 341                                      mMatchCurTravMaskValue);
 342             break;
 343             case BIT_OR:
 344                 BitTest = 0x0000 != (node->getTravMask()   |
 345                                      mMatchCurTravMaskValue);
 346             break;
 347             case BIT_XOR:
 348                 BitTest = 0x0000 != (node->getTravMask()   ^
 349                                      mMatchCurTravMaskValue);
 350                 break;
 351             case BIT_NOT:
 352             case BIT_NOT_EQUAL:
 353                 BitTest = (node->getTravMask() != mNewTravMask);
 354                 break;
 355             case BIT_EQUAL:
 356             default:
 357                 BitTest = (node->getTravMask() == mNewTravMask);
 358                 break;
 359         }
 360
 361         if(BitTest)
 362         {
 363             setMask = true;
 364         }
 365     }
 366
 367     //If the mask should be applied to non-matching
 368     //then flip setMask
 369     if(mApplyToNonMatching)
 370     {
 371         setMask = !setMask;
 372     }
 373
 374         if(setMask)
 375         {
 376         if(mApplyMaskToAllDecendents)
 377         {
 378             TravMaskGraphOpRefPtr colMeshGrOp = TravMaskGraphOp::create();
 379
 380             colMeshGrOp->setMatchRegex(boost::xpressive::cregex::compile(".*"));
 381
 382             colMeshGrOp->setNewTravMask         (mNewTravMask          );
 383             colMeshGrOp->setNewTravMaskOperation(mApplyNewMaskOperation);
 384             colMeshGrOp->traverse               (node                  );
 385
 386             mNumChanged += colMeshGrOp->getNumChanged();
 387
 388             return Action::Skip;
 389         }
 390         else
 391         {
 392             //Apply the new traversal mask
 393             UInt32 NewMask;
 394
 395             switch(mApplyNewMaskOperation)
 396             {
 397                 case BIT_AND:
 398                     NewMask = node->getTravMask() & mNewTravMask;
 399                     break;
 400                 case BIT_OR:
 401                     NewMask = node->getTravMask() | mNewTravMask;
 402                     break;
 403                 case BIT_XOR:
 404                     NewMask = node->getTravMask() ^ mNewTravMask;
 405                     break;
 406                 case BIT_NOT:
 407                     NewMask = ~node->getTravMask();
 408                     break;
 409                 case BIT_EQUAL:
 410                 default:
 411                     NewMask = mNewTravMask;
 412                     break;
 413             }
 414                     node->setTravMask(NewMask);
 415
 416                     ++mNumChanged;
 417         }
 418         }
 419
 420     return Action::Continue;
 421 }
 422
 423 Action::ResultE TravMaskGraphOp::traverseLeave(Node            * const node,
 424                                                Action::ResultE         res )
 425 {
 426         return res;
 427 }
 428
 429
 430
 431