Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jan 17, 2016, 10:29:21 PM (9 years ago)
Author:
landauf
Message:

merged branch cpp11_v3 back to trunk

Location:
code/trunk
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • code/trunk

  • code/trunk/src/libraries/tools/BillboardSet.cc

    r8858 r11071  
    4646    BillboardSet::BillboardSet()
    4747    {
    48         this->billboardSet_ = 0;
     48        this->billboardSet_ = nullptr;
    4949    }
    5050
    … …  
    8181        {
    8282            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    83             this->billboardSet_ = 0;
     83            this->billboardSet_ = nullptr;
    8484        }
    8585
    … …  
    104104        {
    105105            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    106             this->billboardSet_ = 0;
     106            this->billboardSet_ = nullptr;
    107107        }
    108108
    … …  
    114114        if (this->billboardSet_ && this->scenemanager_)
    115115            this->scenemanager_->destroyBillboardSet(this->billboardSet_);
    116         this->billboardSet_ = 0;
     116        this->billboardSet_ = nullptr;
    117117    }
    118118

  • code/trunk/src/libraries/tools/BulletDebugDrawer.h

    r10277 r11071  
    1313#include <btBulletCollisionCommon.h>
    1414#include <OgreFrameListener.h>
     15#include <OgreVector3.h>
     16#include <OgreColourValue.h>
    1517
    1618namespace orxonox
    … …  
    2123            BulletDebugDrawer(Ogre::SceneManager* sceneManager);
    2224            ~BulletDebugDrawer();
    23             virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color);
    24 //            virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar);
    25             virtual void drawSphere (const btVector3& p, btScalar radius, const btVector3& color);
    26             virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color);
    27             virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color);
    28             virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color);
    29             virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color);
    30             virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color);
    31 //            virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color);
     25            virtual void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) override;
     26//            virtual void drawTriangle(const btVector3& v0, const btVector3& v1, const btVector3& v2, const btVector3& color, btScalar) override;
     27            virtual void drawSphere (const btVector3& p, btScalar radius, const btVector3& color) override;
     28            virtual void drawSphere(btScalar radius, const btTransform& transform, const btVector3& color) override;
     29            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btVector3& color) override;
     30            virtual void drawBox(const btVector3& bbMin, const btVector3& bbMax, const btTransform& trans, const btVector3& color) override;
     31            virtual void drawCylinder(btScalar radius, btScalar halfHeight, int upAxis, const btTransform& transform, const btVector3& color) override;
     32            virtual void drawCone(btScalar radius, btScalar height, int upAxis, const btTransform& transform, const btVector3& color) override;
     33//            virtual void drawPlane(const btVector3& planeNormal, btScalar planeConst, const btTransform& transform, const btVector3& color) override;
    3234
    33             virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color);
     35            virtual void drawContactPoint(const btVector3& PointOnB, const btVector3& normalOnB, btScalar distance, int lifeTime, const btVector3& color) override;
    3436
    35             virtual void reportErrorWarning(const char* warningString);
    36             virtual void draw3dText(const btVector3& location, const char* textString);
     37            virtual void reportErrorWarning(const char* warningString) override;
     38            virtual void draw3dText(const btVector3& location, const char* textString) override;
    3739
    38             virtual void setDebugMode(int debugMode);
    39             virtual int getDebugMode() const;
     40            virtual void setDebugMode(int debugMode) override;
     41            virtual int getDebugMode() const override;
    4042
    4143            void configure(bool bFill, float fillAlpha);
    4244
    4345        protected:
    44             bool frameStarted(const Ogre::FrameEvent& evt);
    45             bool frameEnded(const Ogre::FrameEvent& evt);
     46            virtual bool frameStarted(const Ogre::FrameEvent& evt) override;
     47            virtual bool frameEnded(const Ogre::FrameEvent& evt) override;
    4648
    4749        private:

  • code/trunk/src/libraries/tools/DebugDrawer.cc

    r10262 r11071  
    2121{
    2222    DebugDrawer::DebugDrawer(Ogre::SceneManager *_sceneManager, float _fillAlpha) :
    23             sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(0), isEnabled(true), linesIndex(0), trianglesIndex(0)
     23            sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(nullptr), isEnabled(true), linesIndex(0), trianglesIndex(0)
    2424    {
    2525        initialise();
    … …  
    392392            manualObject->estimateVertexCount(lineVertices.size());
    393393            manualObject->estimateIndexCount(lineIndices.size());
    394             for (std::list<VertexPair>::iterator i = lineVertices.begin(); i != lineVertices.end(); i++)
     394            for (const VertexPair& pair : lineVertices)
    395395            {
    396                 manualObject->position(i->first);
    397                 manualObject->colour(i->second);
     396                manualObject->position(pair.first);
     397                manualObject->colour(pair.second);
    398398            }
    399             for (std::list<int>::iterator i = lineIndices.begin(); i != lineIndices.end(); i++)
    400                 manualObject->index(*i);
     399            for (int lineIndex : lineIndices)
     400                manualObject->index(lineIndex);
    401401        }
    402402        else
    … …  
    409409            manualObject->estimateVertexCount(triangleVertices.size());
    410410            manualObject->estimateIndexCount(triangleIndices.size());
    411             for (std::list<VertexPair>::iterator i = triangleVertices.begin(); i != triangleVertices.end(); i++)
     411            for (const VertexPair& pair : triangleVertices)
    412412            {
    413                 manualObject->position(i->first);
    414                 manualObject->colour(i->second.r, i->second.g, i->second.b, fillAlpha);
     413                manualObject->position(pair.first);
     414                manualObject->colour(pair.second.r, pair.second.g, pair.second.b, fillAlpha);
    415415            }
    416             for (std::list<int>::iterator i = triangleIndices.begin(); i != triangleIndices.end(); i++)
    417                 manualObject->index(*i);
     416            for (int triangleIndex : triangleIndices)
     417                manualObject->index(triangleIndex);
    418418        }
    419419        else
    … …  
    433433    int DebugDrawer::addLineVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
    434434    {
    435         lineVertices.push_back(VertexPair(vertex, colour));
     435        lineVertices.emplace_back(vertex, colour);
    436436        return linesIndex++;
    437437    }
    … …  
    445445    int DebugDrawer::addTriangleVertex(const Ogre::Vector3& vertex, const Ogre::ColourValue& colour)
    446446    {
    447         triangleVertices.push_back(VertexPair(vertex, colour));
     447        triangleVertices.emplace_back(vertex, colour);
    448448        return trianglesIndex++;
    449449    }

  • code/trunk/src/libraries/tools/DynamicLines.cc

    r5781 r11071  
    6969    void DynamicLines::addPoint(Real x, Real y, Real z)
    7070    {
    71         mPoints.push_back(Vector3(x,y,z));
     71        mPoints.emplace_back(x,y,z);
    7272        mDirty = true;
    7373    }

  • code/trunk/src/libraries/tools/DynamicLines.h

    r5781 r11071  
    8484    protected:
    8585        /// Implementation DynamicRenderable, creates a simple vertex-only decl
    86         virtual void createVertexDeclaration();
     86        virtual void createVertexDeclaration() override;
    8787        /// Implementation DynamicRenderable, pushes point list out to hardware memory
    88         virtual void fillHardwareBuffers();
     88        virtual void fillHardwareBuffers() override;
    8989
    9090    private:

  • code/trunk/src/libraries/tools/DynamicRenderable.h

    r5781 r11071  
    6161
    6262        /// Implementation of SimpleRenderable
    63         virtual Real getBoundingRadius(void) const;
     63        virtual Real getBoundingRadius(void) const override;
    6464        /// Implementation of SimpleRenderable
    65         virtual Real getSquaredViewDepth(const Camera* cam) const;
     65        virtual Real getSquaredViewDepth(const Camera* cam) const override;
    6666
    6767    protected:

  • code/trunk/src/libraries/tools/IcoSphere.cc

    r10262 r11071  
    116116            std::list<TriangleIndices> faces2;
    117117
    118             for (std::list<TriangleIndices>::iterator j = faces.begin(); j != faces.end(); j++)
     118            for (const TriangleIndices& f : faces)
    119119            {
    120                 TriangleIndices f = *j;
    121120                int a = getMiddlePoint(f.v1, f.v2);
    122121                int b = getMiddlePoint(f.v2, f.v3);
    … …  
    127126                removeLineIndices(f.v3, f.v1);
    128127
    129                 faces2.push_back(TriangleIndices(f.v1, a, c));
    130                 faces2.push_back(TriangleIndices(f.v2, b, a));
    131                 faces2.push_back(TriangleIndices(f.v3, c, b));
    132                 faces2.push_back(TriangleIndices(a, b, c));
     128                faces2.emplace_back(f.v1, a, c);
     129                faces2.emplace_back(f.v2, b, a);
     130                faces2.emplace_back(f.v3, c, b);
     131                faces2.emplace_back(a, b, c);
    133132
    134133                addTriangleLines(f.v1, a, c);
    … …  
    143142    void IcoSphere::addLineIndices(int index0, int index1)
    144143    {
    145         lineIndices.push_back(LineIndices(index0, index1));
     144        lineIndices.emplace_back(index0, index1);
    146145    }
    147146
    … …  
    164163    {
    165164        Ogre::Real length = vertex.length();
    166         vertices.push_back(Ogre::Vector3(vertex.x / length, vertex.y / length, vertex.z / length));
     165        vertices.emplace_back(vertex.x / length, vertex.y / length, vertex.z / length);
    167166        return index++;
    168167    }
    … …  
    189188    void IcoSphere::addFace(int index0, int index1, int index2)
    190189    {
    191         faces.push_back(TriangleIndices(index0, index1, index2));
     190        faces.emplace_back(index0, index1, index2);
    192191    }
    193192
    194193    void IcoSphere::addToLineIndices(int baseIndex, std::list<int>* target) const
    195194    {
    196         for (std::list<LineIndices>::const_iterator i = lineIndices.begin(); i != lineIndices.end(); i++)
     195        for (const LineIndices& line : lineIndices)
    197196        {
    198             target->push_back(baseIndex + (*i).v1);
    199             target->push_back(baseIndex + (*i).v2);
     197            target->push_back(baseIndex + line.v1);
     198            target->push_back(baseIndex + line.v2);
    200199        }
    201200    }
    … …  
    203202    void IcoSphere::addToTriangleIndices(int baseIndex, std::list<int>* target) const
    204203    {
    205         for (std::list<TriangleIndices>::const_iterator i = faces.begin(); i != faces.end(); i++)
     204        for (const TriangleIndices& triangle : faces)
    206205        {
    207             target->push_back(baseIndex + (*i).v1);
    208             target->push_back(baseIndex + (*i).v2);
    209             target->push_back(baseIndex + (*i).v3);
     206            target->push_back(baseIndex + triangle.v1);
     207            target->push_back(baseIndex + triangle.v2);
     208            target->push_back(baseIndex + triangle.v3);
    210209        }
    211210    }
    … …  
    217216        transform.setScale(Ogre::Vector3(scale, scale, scale));
    218217
    219         for (int i = 0; i < (int) vertices.size(); i++)
    220             target->push_back(VertexPair(transform * vertices[i], colour));
     218        for (const Ogre::Vector3& vertex : vertices)
     219            target->emplace_back(transform * vertex, colour);
    221220
    222221        return vertices.size();

  • code/trunk/src/libraries/tools/Mesh.cc

    r8858 r11071  
    4444    Mesh::Mesh()
    4545    {
    46         this->entity_ = 0;
     46        this->entity_ = nullptr;
    4747        this->bCastShadows_ = true;
    4848    }
    … …  
    7373            {
    7474                orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
    75                 this->entity_ = 0;
     75                this->entity_ = nullptr;
    7676            }
    7777        }

  • code/trunk/src/libraries/tools/OgreBulletUtils.h

    r10262 r11071  
    1010
    1111#include "tools/ToolsPrereqs.h"
     12#include <OgreVector3.h>
     13#include <OgreQuaternion.h>
     14#include <OgreColourValue.h>
     15#include <OgreMatrix3.h>
     16#include <OgreMatrix4.h>
    1217
    1318namespace orxonox
    … …  
    4247    inline Ogre::Matrix3 matrix3(const btMatrix3x3& matrix)
    4348    {
    44         return Matrix3(
     49        return Ogre::Matrix3(
    4550                matrix[0][0], matrix[0][1], matrix[0][2],
    4651                matrix[1][0], matrix[1][1], matrix[1][2],

  • code/trunk/src/libraries/tools/ParticleInterface.cc

    r11052 r11071  
    5959
    6060        this->scenemanager_ = scenemanager;
    61         this->particleSystem_ = 0;
     61        this->particleSystem_ = nullptr;
    6262
    6363        this->bEnabled_ = true;
    … …  
    8080            {
    8181                orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
    82                 this->particleSystem_ = 0;
     82                this->particleSystem_ = nullptr;
    8383            }
    8484        }
    … …  
    110110        }
    111111        else
    112             return 0;
     112            return nullptr;
    113113    }
    114114    Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
    … …  
    117117            return this->particleSystem_->getEmitter(emitterNr);
    118118        else
    119             return 0;
     119            return nullptr;
    120120    }
    121121    void ParticleInterface::removeEmitter(unsigned int emitterNr)
    … …  
    142142            return this->particleSystem_->addAffector(name);
    143143        else
    144             return 0;
     144            return nullptr;
    145145    }
    146146    Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr)
    … …  
    149149            return this->particleSystem_->getAffector(affectorNr);
    150150        else
    151             return 0;
     151            return nullptr;
    152152    }
    153153    void ParticleInterface::removeAffector(unsigned int affectorNr)

  • code/trunk/src/libraries/tools/ParticleInterface.h

    r11052 r11071  
    7878
    7979        protected:
    80             virtual void changedTimeFactor(float factor_new, float factor_old);
     80            virtual void changedTimeFactor(float factor_new, float factor_old) override;
    8181
    8282        private:

  • code/trunk/src/libraries/tools/ResourceCollection.cc

    r9667 r11071  
    4848    }
    4949
    50     ResourceCollection::~ResourceCollection()
    51     {
    52     }
    53 
    5450    void ResourceCollection::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    5551    {
    … …  
    9389    {
    9490        if (index >= resourceLocations_.size())
    95             return NULL;
     91            return nullptr;
    9692        else
    9793            return resourceLocations_[index];

  • code/trunk/src/libraries/tools/ResourceCollection.h

    r9667 r11071  
    4242    public:
    4343        ResourceCollection(Context* context);
    44         virtual ~ResourceCollection();
     44        virtual ~ResourceCollection() = default;
    4545
    46         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     46        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    4747
    4848        void setResourceGroup(const std::string& resourceGroup);
    … …  
    5454
    5555    private:
    56         ResourceCollection(const ResourceCollection&);
     56        // non-copyable:
     57        ResourceCollection(const ResourceCollection&) = delete;
     58        ResourceCollection& operator=(const ResourceCollection&) = delete;
    5759
    5860        std::string resourceGroup_;

  • code/trunk/src/libraries/tools/ResourceLocation.cc

    r10624 r11071  
    5454    }
    5555
    56     ResourceLocation::~ResourceLocation()
    57     {
    58     }
    59 
    6056    void ResourceLocation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
    6157    {

  • code/trunk/src/libraries/tools/ResourceLocation.h

    r9667 r11071  
    4444    public:
    4545        ResourceLocation(Context* context);
    46         virtual ~ResourceLocation();
     46        virtual ~ResourceLocation() = default;
    4747
    48         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     48        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
    4949
    5050        void setPath(const std::string& path) { path_ = path; }
    … …  
    6060
    6161    private:
    62         ResourceLocation(const ResourceLocation&);
     62        // non-copyable:
     63        ResourceLocation(const ResourceLocation&) = delete;
     64        ResourceLocation& operator=(const ResourceLocation&) = delete;
    6365
    6466        void load(const std::string& resourceGroup);

  • code/trunk/src/libraries/tools/Shader.cc

    r10727 r11071  
    4444        @brief Initializes the values and sets the scene manager.
    4545    */
    46     Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(0)
     46    Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(nullptr)
    4747    {
    4848        RegisterObject(Shader);
    … …  
    109109    {
    110110        // For the moment, we get the viewport always from the graphics manager
    111         // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns NULL
     111        // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns nullptr
    112112        //       after switching to a camera in a different scene (only for the first time this scene is displayed though)
    113113        this->changedCompositorName(GraphicsManager::getInstance().getViewport());
    … …  
    127127                Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
    128128                this->compositorInstance_->removeListener(this);
    129                 this->compositorInstance_ = 0;
     129                this->compositorInstance_ = nullptr;
    130130            }
    131131            if (!this->compositorName_.empty())
    … …  
    197197    {
    198198        // iterate through the list of parameters
    199         for (std::list<ParameterContainer>::iterator it = this->parameters_.begin(); it != this->parameters_.end(); ++it)
    200         {
    201             Ogre::Technique* techniquePtr = materialPtr->getTechnique(it->technique_);
     199        for (const ParameterContainer& parameter : this->parameters_)
     200        {
     201            Ogre::Technique* techniquePtr = materialPtr->getTechnique(parameter.technique_);
    202202            if (techniquePtr)
    203203            {
    204                 Ogre::Pass* passPtr = techniquePtr->getPass(it->pass_);
     204                Ogre::Pass* passPtr = techniquePtr->getPass(parameter.pass_);
    205205                if (passPtr)
    206206                {
    207207                    // change the value of the parameter depending on its type
    208                     if (it->value_.isType<int>())
    209                         passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<int>());
    210                     else if (it->value_.isType<float>())
    211                         passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<float>());
     208                    if (parameter.value_.isType<int>())
     209                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<int>());
     210                    else if (parameter.value_.isType<float>())
     211                        passPtr->getFragmentProgramParameters()->setNamedConstant(parameter.parameter_, parameter.value_.get<float>());
    212212                }
    213213                else
    214                     orxout(internal_warning) << "No pass " << it->pass_ << " in technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
     214                    orxout(internal_warning) << "No pass " << parameter.pass_ << " in technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or pass has no shader." << endl;
    215215            }
    216216            else
    217                 orxout(internal_warning) << "No technique " << it->technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
     217                orxout(internal_warning) << "No technique " << parameter.technique_ << " in compositor \"" << this->compositorName_ << "\" or technique has no pass with shader." << endl;
    218218        }
    219219        this->parameters_.clear();
    … …  
    228228        {
    229229            const Ogre::Root::PluginInstanceList& plugins = Ogre::Root::getSingleton().getInstalledPlugins();
    230             for (size_t i = 0; i < plugins.size(); ++i)
    231                 if (plugins[i]->getName() == "Cg Program Manager")
     230            for (Ogre::Plugin* plugin : plugins)
     231                if (plugin->getName() == "Cg Program Manager")
    232232                    return true;
    233233        }

  • code/trunk/src/libraries/tools/Shader.h

    r10727 r11071  
    4848    {
    4949        public:
    50             Shader(Ogre::SceneManager* scenemanager = 0);
     50            Shader(Ogre::SceneManager* scenemanager = nullptr);
    5151            virtual ~Shader();
    5252
    … …  
    8787                { return this->scenemanager_; }
    8888
    89             virtual void cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera);
     89            virtual void cameraChanged(Ogre::Viewport* viewport, Ogre::Camera* oldCamera) override;
    9090
    9191            void setParameter(unsigned short technique, unsigned short pass, const std::string& parameter, float value);
    9292            void setParameter(unsigned short technique, unsigned short pass, const std::string& parameter, int value);
    9393
    94             virtual void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr);
     94            virtual void notifyMaterialRender(Ogre::uint32 pass_id, Ogre::MaterialPtr& materialPtr) override;
    9595
    9696        private:

  • code/trunk/src/libraries/tools/TextureGenerator.cc

    r10546 r11071  
    7171namespace orxonox
    7272{
    73     std::map<std::string, std::map<ColourValue, std::string> > TextureGenerator::materials_s;
     73    std::map<std::string, std::map<ColourValue, std::string>> TextureGenerator::materials_s;
    7474    unsigned int TextureGenerator::materialCount_s = 0;
    7575

  • code/trunk/src/libraries/tools/TextureGenerator.h

    r5781 r11071  
    4949
    5050    private:
    51         TextureGenerator();
    52         TextureGenerator(const TextureGenerator&);
    53         ~TextureGenerator();
     51        // static class, no instances allowed:
     52        TextureGenerator() = delete;
     53        TextureGenerator(const TextureGenerator&) = delete;
     54        TextureGenerator& operator=(const TextureGenerator&) = delete;
     55        ~TextureGenerator() = delete;
    5456
    55         static std::map<std::string, std::map<ColourValue, std::string> > materials_s;
     57        static std::map<std::string, std::map<ColourValue, std::string>> materials_s;
    5658        static unsigned int materialCount_s;
    5759    };

  • code/trunk/src/libraries/tools/Timer.cc

    r11018 r11071  
    163163    void Timer::init()
    164164    {
    165         this->executor_ = 0;
     165        this->executor_ = nullptr;
    166166        this->interval_ = 0;
    167167        this->bLoop_ = false;

  • code/trunk/src/libraries/tools/Timer.h

    r11018 r11071  
    175175
    176176        protected:
    177             virtual float getTimeFactor();
     177            virtual float getTimeFactor() override;
    178178    };
    179179}

  • code/trunk/src/libraries/tools/interfaces/TimeFactorListener.h

    r9667 r11071  
    3939        public:
    4040            TimeFactorListener();
    41             virtual ~TimeFactorListener() {}
     41            virtual ~TimeFactorListener() = default;
    4242
    4343            static void setTimeFactor(float factor);

  • code/trunk/src/libraries/tools/interfaces/ToolsInterfaceCompilation.cc

    r10624 r11071  
    6060        float oldFactor = TimeFactorListener::timefactor_s;
    6161        TimeFactorListener::timefactor_s = factor;
    62         for (ObjectList<TimeFactorListener>::iterator it = ObjectList<TimeFactorListener>::begin(); it != ObjectList<TimeFactorListener>::end(); ++it)
    63             it->changedTimeFactor(factor, oldFactor);
     62        for (TimeFactorListener* listener : ObjectList<TimeFactorListener>())
     63            listener->changedTimeFactor(factor, oldFactor);
    6464    }
    6565
Note: See TracChangeset for help on using the changeset viewer.