Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 1610


Ignore:
Timestamp:
Jun 19, 2008, 4:10:27 AM (17 years ago)
Author:
landauf
Message:
  • fixed bug #1 in ConfigValueContainer (callback not being called the first time)
  • fixed another bug in XMLPort, caused by the recently added support for extern types
Location:
code/branches/core3/src
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • code/branches/core3/src/core/ConfigValueContainer.cc

    r1596 r1610  
    6060        this->varname_ = varname;
    6161        this->callback_ = 0;
     62        this->bContainerIsNew_ = true;
     63        this->bDoInitialCallback_ = false;
     64        this->bAddedDescription_ = false;
    6265
    6366        this->value_ = defvalue;
    64         this->bAddedDescription_ = false;
    6567        this->bIsVector_ = false;
    6668
    … …  
    8284        this->sectionname_ = identifier->getName();
    8385        this->varname_ = varname;
     86        this->callback_ = 0;
     87        this->bContainerIsNew_ = true;
     88        this->bDoInitialCallback_ = false;
     89        this->bAddedDescription_ = false;
    8490
    8591        this->valueVector_ = defvalue;
    86         this->bAddedDescription_ = false;
    8792        this->bIsVector_ = true;
    8893

  • code/branches/core3/src/core/ConfigValueContainer.h

    r1596 r1610  
    103103            ConfigValueContainer& getValue(T* value, C* object)
    104104            {
    105                 if (this->callback_ && object)
    106                 {
     105std::cout << "start: " << this->getName() << std::endl;
     106                if ((this->callback_ && object) || this->bContainerIsNew_)
     107                {
     108                    if (this->bContainerIsNew_)
     109                        this->bContainerIsNew_ = false;
     110
    107111                    T temp = *value;
    108112                    this->value_.getValue(value);
    109113                    if ((*value) != temp)
    110                         this->callback_->call(object);
     114                    {
     115                        if (this->callback_ && object)
     116                            this->callback_->call(object);
     117                        else
     118                            this->bDoInitialCallback_ = true;
     119                    }
    111120                }
    112121                else
    … …  
    114123                    this->value_.getValue(value);
    115124                }
     125std::cout << "end" << std::endl;
    116126                return *this;
    117127            }
    … …  
    121131            ConfigValueContainer& getValue(std::vector<T>* value, C* object)
    122132            {
    123                 if (this->callback_ && object)
    124                 {
     133                if ((this->callback_ && object) || this->bContainerIsNew_)
     134                {
     135                    if (this->bContainerIsNew_)
     136                        this->bContainerIsNew_ = false;
     137
    125138                    std::vector<T> temp = *value;
    126 
    127139                    value->clear();
    128140                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
    … …  
    131143                    if (value->size() != temp.size())
    132144                    {
    133                         this->callback_->call(object);
     145                        if (this->callback_ && object)
     146                            this->callback_->call(object);
     147                        else
     148                            this->bDoInitialCallback_ = true;
    134149                    }
    135150                    else
    … …  
    139154                            if ((*value)[i] != temp[i])
    140155                            {
    141                                 this->callback_->call(object);
     156                                if (this->callback_ && object)
     157                                    this->callback_->call(object);
     158                                else
     159                                    this->bDoInitialCallback_ = true;
    142160                                break;
    143161                            }
    … …  
    172190
    173191            template <class T>
    174             inline ConfigValueContainer& callback(void (T::*function) (void))
     192            inline ConfigValueContainer& callback(T* object, void (T::*function) (void))
    175193            {
    176194                if (!this->callback_)
     195                {
    177196                    this->callback_ = new ConfigValueCallback<T>(function);
     197
     198                    if (this->bDoInitialCallback_)
     199                    {
     200                        this->bDoInitialCallback_ = false;
     201                        this->callback_->call(object);
     202                    }
     203                }
     204
    178205                return (*this);
    179206            }
    … …  
    215242            LanguageEntryLabel         description_;                //!< The description
    216243            ConfigValueCallbackBase*   callback_;                   //!< A callback function to call after getValue if the value changed
     244
     245            bool                       bContainerIsNew_;            //!< True if it's the first time getValue() gets called
     246            bool                       bDoInitialCallback_;         //!< True if the callback should be called as soon as it gets created
    217247    };
    218248}

  • code/branches/core3/src/core/Core.cc

    r1596 r1610  
    9696    void Core::setConfigValues()
    9797    {
    98         SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console").callback(&Core::debugLevelChanged);
    99         SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile").callback(&Core::debugLevelChanged);
    100         SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell").callback(&Core::debugLevelChanged);
    101         SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(&Core::languageChanged);
     98        SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console").callback(this, &Core::debugLevelChanged);
     99        SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile").callback(this, &Core::debugLevelChanged);
     100        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell").callback(this, &Core::debugLevelChanged);
     101        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(this, &Core::languageChanged);
    102102    }
    103103

  • code/branches/core3/src/core/Identifier.cc

    r1596 r1610  
    195195
    196196    /**
    197         @brief Tells the container to which Identifier it belongs to.
    198     */
    199     void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
    200     {
    201         container->setIdentifier(this);
    202     }
    203 
    204     /**
    205197        @brief Returns true, if the Identifier is at least of the given type.
    206198        @param identifier The identifier to compare with

  • code/branches/core3/src/core/Identifier.h

    r1596 r1610  
    206206            ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
    207207
    208             virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
     208            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
    209209            virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
    210210
    … …  
    461461    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
    462462    {
    463         Identifier::addXMLPortParamContainer(paramname, container);
    464463        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<class O>*)container;
    465464    }

  • code/branches/core3/src/core/Shell.cc

    r1596 r1610  
    9090    void Shell::setConfigValues()
    9191    {
    92         SetConfigValue(maxHistoryLength_, 100).callback(&Shell::commandHistoryLengthChanged);
    93         SetConfigValue(historyOffset_, 0).callback(&Shell::commandHistoryOffsetChanged);
     92        SetConfigValue(maxHistoryLength_, 100).callback(this, &Shell::commandHistoryLengthChanged);
     93        SetConfigValue(historyOffset_, 0).callback(this, &Shell::commandHistoryOffsetChanged);
    9494        SetConfigValueVector(commandHistory_, std::vector<std::string>());
    9595    }

  • code/branches/core3/src/core/XMLPort.h

    r1592 r1610  
    4242
    4343#define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
    44     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
     44    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
    4545#define XMLPortParamTemplate(classname, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
    46     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
     46    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
    4747
    4848#define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
    49     XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
     49    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
    5050#define XMLPortParamLoadOnlyTemplate(classname, paramname, loadfunction, xmlelement, mode, ...) \
    51     XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
    52 
    53 #define XMLPortParamExtern(classname, object, paramname, loadfunction, savefunction, xmlelement, mode) \
    54     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode);
    55 #define XMLPortParamExternTemplate(classname, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
    56     XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, object, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode);
    57 
    58 #define XMLPortParamGeneric(containername, classname, object, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
    59     orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
     51    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
     52
     53#define XMLPortParamExtern(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode) \
     54    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
     55#define XMLPortParamExternTemplate(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
     56    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
     57
     58#define XMLPortParamGeneric(containername, classname, objectclass, object, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
     59    orxonox::XMLPortClassParamContainer<objectclass>* containername = (orxonox::XMLPortClassParamContainer<objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortParamContainer(paramname)); \
    6060    if (!containername) \
    6161    { \
    62         containername = new orxonox::XMLPortClassParamContainer<classname>(std::string(paramname), loadexecutor, saveexecutor); \
    63         this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     62        containername = new orxonox::XMLPortClassParamContainer<objectclass>(std::string(paramname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor); \
     63        ClassIdentifier<classname>::getIdentifier()->addXMLPortParamContainer(paramname, containername); \
    6464    } \
    65     containername->port(object, xmlelement, mode)
     65    containername->port((BaseObject*)this, object, xmlelement, mode)
    6666
    6767
    … …  
    7272
    7373#define XMLPortObjectGeneric(containername, classname, objectclass, sectionname, loadexecutor, saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
    74     orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(this->getIdentifier()->getXMLPortObjectContainer(sectionname)); \
     74    orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortObjectContainer(sectionname)); \
    7575    if (!containername) \
    7676    { \
    77         containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
    78         this->getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
     77        containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
     78        ClassIdentifier<classname>::getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
    7979    } \
    8080    containername->port(this, xmlelement, mode)
    … …  
    103103            inline const std::string& getName() const
    104104                { return this->paramname_; }
    105             inline void setIdentifier(Identifier* identifier)
    106                 { this->identifier_ = identifier; }
    107105
    108106            virtual XMLPortParamContainer& description(const std::string description) = 0;
    … …  
    120118            ParseResult parseResult_;
    121119            Identifier* identifier_;
     120            BaseObject* owner_;
    122121    };
    123122
    … …  
    133132
    134133        public:
    135             XMLPortClassParamContainer(const std::string paramname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
     134            XMLPortClassParamContainer(const std::string paramname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
    136135            {
    137136                this->paramname_ = paramname;
     137                this->identifier_ = identifier;
    138138                this->loadexecutor_ = loadexecutor;
    139139                this->saveexecutor_ = saveexecutor;
    140140            }
    141141
    142             XMLPortParamContainer& port(T* object, Element& xmlelement, XMLPort::Mode mode)
    143             {
     142            XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
     143            {
     144                this->owner_ = owner;
    144145                this->parseParams_.object = object;
    145146                this->parseParams_.xmlelement = &xmlelement;
    … …  
    153154                        if ((attribute.size() > 0) || (this->loadexecutor_->allDefaultValuesSet()))
    154155                        {
    155                             COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")." << std::endl << ((BaseObject*)object)->getLoaderIndentation();
     156                            COUT(5) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << std::endl << this->owner_->getLoaderIndentation();
    156157                            if (this->loadexecutor_->parse(object, attribute, ","))
    157158                                this->parseResult_ = PR_finished;
    … …  
    163164                    {
    164165                        COUT(1) << std::endl;
    165                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << ((BaseObject*)object)->getLevelfile() << ":" << std::endl;
     166                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getLevelfile() << ":" << std::endl;
    166167                        COUT(1) << ex.what() << std::endl;
    167168                    }
    … …  
    178179            }
    179180
    180             XMLPortParamContainer& port(const ParseParams& parseParams)
    181             {
    182                 return this->port(parseParams.object, *parseParams.xmlelement, parseParams.mode);
     181            XMLPortParamContainer& port(BaseObject* owner, const ParseParams& parseParams)
     182            {
     183                return this->port(owner, parseParams.object, *parseParams.xmlelement, parseParams.mode);
    183184            }
    184185
    … …  
    186187            {
    187188                if (result == PR_waiting_for_default_values)
    188                     return this->port(params);
     189                    return this->port(this->owner_, params);
    189190                else
    190191                    return (*this);
    … …  
    262263            bool bApplyLoaderMask_;
    263264            bool bLoadBefore_;
     265            Identifier* identifier_;
    264266    };
    265267
    … …  
    268270    {
    269271        public:
    270             XMLPortClassObjectContainer(const std::string sectionname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
     272            XMLPortClassObjectContainer(const std::string sectionname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
    271273            {
    272274                this->sectionname_ = sectionname;
     275                this->identifier_ = identifier;
    273276                this->loadexecutor_ = loadexecutor;
    274277                this->saveexecutor_ = saveexecutor;
    … …  
    310313                                            {
    311314                                                newObject->XMLPort(*child, XMLPort::LoadObject);
    312                                                 COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
     315                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
    313316                                            }
    314317                                            else
    315318                                            {
    316                                                 COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
     319                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
    317320                                            }
    318321
    … …  
    341344                    {
    342345                        COUT(1) << std::endl;
    343                         COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
     346                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
    344347                        COUT(1) << ex.what() << std::endl;
    345348                    }

  • code/branches/core3/src/orxonox/GraphicsEngine.cc

    r1596 r1610  
    9797    SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
    9898
    99     SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(&GraphicsEngine::detailLevelParticleChanged);
     99    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
    100100  }
    101101

  • code/branches/core3/src/orxonox/Settings.cc

    r1596 r1610  
    6868  void Settings::setConfigValues()
    6969  {
    70     SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(&Settings::dataPathChanged);
     70    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
    7171  }
    7272

  • code/branches/core3/src/orxonox/objects/ParticleProjectile.cc

    r1597 r1610  
    6464    void ParticleProjectile::setConfigValues()
    6565    {
    66         SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(&ParticleProjectile::speedChanged);
     66        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback((Projectile*)this, &ParticleProjectile::speedChanged);
    6767    }
    6868

  • code/branches/core3/src/orxonox/objects/Projectile.cc

    r1596 r1610  
    7474        SetConfigValue(damage_, 15.0).description("The damage caused by the projectile");
    7575        SetConfigValue(lifetime_, 4.0).description("The time in seconds a projectile stays alive");
    76         SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(&Projectile::speedChanged);
     76        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(this, &Projectile::speedChanged);
    7777    }
    7878

  • code/branches/core3/src/orxonox/objects/RotatingProjectile.cc

    r1596 r1610  
    6565    void RotatingProjectile::setConfigValues()
    6666    {
    67         SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0)).callback(&RotatingProjectile::colourChanged);
     67        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0)).callback(this, &RotatingProjectile::colourChanged);
    6868    }
    6969

  • code/branches/core3/src/orxonox/objects/WorldEntity.cc

    r1592 r1610  
    112112        BaseObject::XMLPort(xmlelement, mode);
    113113
    114         XMLPortParamExternTemplate(Ogre::Node, this->node_, "position", setPosition, getPosition, xmlelement, mode, Ogre::Node, const Vector3&);
     114std::cout << "111111111111111\n";
     115        XMLPortParamExternTemplate(WorldEntity, Ogre::Node, this->node_, "position", setPosition, getPosition, xmlelement, mode, Ogre::Node, const Vector3&);
     116std::cout << "222222222222222\n";
    115117        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionSimple, xmlelement, mode);
    116118        XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, mode);

  • code/branches/core3/src/util/Debug.h

    r1593 r1610  
    8686
    8787  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    88    #define COUT0  \
     88   #define COUT0 \
    8989    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
    9090  #else
    … …  
    9494
    9595  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    96    #define COUT1  \
     96   #define COUT1 \
    9797    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
    9898  #else
    … …  
    170170
    171171  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    172    #define CCOUT0  \
     172   #define CCOUT0 \
    173173    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
    174174  #else
    … …  
    178178
    179179  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    180    #define CCOUT1  \
     180   #define CCOUT1 \
    181181    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
    182182  #else
Note: See TracChangeset for help on using the changeset viewer.