Changeset 496 for code/branches/FICN/src/orxonox/objects

Timestamp:

Dec 12, 2007, 10:37:30 PM (17 years ago)

Author:

landauf

Message:

added files from objecthierarchy, changed includes

Location:

code/branches/FICN/src/orxonox/objects

Files:

• BaseObject.cc (modified) (3 diffs)
• BaseObject.h (modified) (2 diffs)
• CMakeLists.txt (modified) (1 diff)
• Test.h (modified) (1 diff)
• Tickable.h (modified) (1 diff)
• Timer.h (modified) (7 diffs)
• test3.cc (modified) (2 diffs)
• test3.h (modified) (1 diff)

code/branches/FICN/src/orxonox/objects/BaseObject.cc

@@ +1 @@
+/*!
+    @file BaseObject.cc
+    @brief Implementation of the BaseObject class.
+*/
+
 #include "BaseObject.h"
 
@@ -5 +10 @@
     CreateFactory(BaseObject);
 
+    /**
+        @brief Constructor: Registers the object in the BaseObject-list.
+    */
     BaseObject::BaseObject()
     {
@@ -10 +18 @@
     }
 
+    /**
+        @brief Destructor
+    */
     BaseObject::~BaseObject()
     {
     }
-    
 }

code/branches/FICN/src/orxonox/objects/BaseObject.h

@@ +1 @@
+/*!
+    @file BaseObject.h
+    @brief Definition of the BaseObject class.
+
+    The BaseObject is the parent of all classes representing an instance in the game.
+*/
+
 #ifndef _BaseObject_H__
 #define _BaseObject_H__
 
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "tinyxml/tinyxml.h"
 
 namespace orxonox
 {
+    //! The BaseObject is the parent of all classes representing an instance in the game.
     class BaseObject : virtual public OrxonoxClass
     {
@@ -11 +20 @@
             BaseObject();
             virtual ~BaseObject();
-                        virtual void loadParams(TiXmlElement* xmlElem) {}
-            
+            virtual void loadParams(TiXmlElement* xmlElem) {}
     };
 }

code/branches/FICN/src/orxonox/objects/CMakeLists.txt

@@ -3 +3 @@
 SET( OBJECTS_SRC_FILES
   BaseObject.cc
+  WorldEntity.cc
   test1.cc
   test2.cc

code/branches/FICN/src/orxonox/objects/Test.h

@@ -3 +3 @@
 
 #include "BaseObject.h"
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
 
 namespace orxonox

code/branches/FICN/src/orxonox/objects/Tickable.h

@@ +1 @@
+/*!
+    @file Tickable.h
+    @brief Definition of the Tickable interface.
+
+    The Tickable interface provides a tick(dt) function, that gets called every frame.
+    float dt is the time since the last frame.
+
+    Attention:
+    Classes derived from a Tickable that want to have a tick(dt) function on their part, MUST call the
+    parent::tick(dt) function explicit in their implementation of tick(dt) because it's a virtual function.
+*/
+
 #ifndef _Tickable_H__
 #define _Tickable_H__
 
-#include <OgreFrameListener.h>
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "OgreFrameListener.h"
 
 namespace orxonox
 {
-    class TickFrameListener;
+    class TickFrameListener; // Forward declaration
 
+    //! The Tickable interface provides a tick(dt) function, that gets called every frame.
     class Tickable : virtual public OrxonoxClass
     {
         public:
+            /**
+                @brief Gets called every frame.
+                @param dt The time since the last frame
+            */
             virtual void tick(float dt) = 0;
 
         protected:
+            /**
+                @brief Constructor: Registers the object in the Tickable-list
+            */
             Tickable() { RegisterRootObject(Tickable); }
     };
 
+    //! The TickFrameListener calls the tick(dt) function of all Tickables every frame.
     class TickFrameListener : public Ogre::FrameListener
     {
         private:
+            /** @brief Gets called before a frame gets rendered. */
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                // Iterate through all Tickables and call their tick(dt) function
                 for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
                     it->tick(evt.timeSinceLastFrame);

code/branches/FICN/src/orxonox/objects/Timer.h

@@ +1 @@
+/*!
+    @file Timer.h
+    @brief Definition and Implementation of the Timer class.
+
+    The Timer is a callback-object, calling a given function after a given time-interval.
+
+    Usage:
+    header.h:
+        class ClassName
+        {
+            public:
+                ClassName();
+                void functionName();
+                Timer myTimer;
+        };
+
+    source.cc:
+        ClassName::ClassName()
+        {
+            myTimer.setTimer(interval_in_seconds, bLoop, this, &ClassName::functionName);
+        }
+
+        void ClassName::functionName()
+        {
+            whateveryouwant();
+            something(else);
+        }
+*/
+
 #ifndef _Timer_H__
 #define _Timer_H__
 
-#include <OgreFrameListener.h>
-#include "../core/IdentifierIncludes.h"
+#include "../core/CoreIncludes.h"
+#include "OgreFrameListener.h"
 
 namespace orxonox
 {
+    //! TimerBase is the parent of the Timer class.
     class TimerBase : public OrxonoxClass
     {
@@ -12 +42 @@
 
         public:
+            /** @brief Constructor: Sets the default-values. */
             TimerBase()
             {
@@ -25 +56 @@
             virtual void run() const = 0;
 
+            /** @brief Starts the Timer: Function-call after 'interval' seconds. */
             inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
+            /** @brief Stops the Timer. */
             inline void stopTimer() { this->bActive_ = false; this->time_ = this->interval_; }
+            /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */
             inline void pauseTimer() { this->bActive_ = false; }
+            /** @brief Unpauses the Timer - continues with the given state. */
             inline void unpauseTimer() { this->bActive_ = true; }
+            /** @returns true if the Timer is active (= not stoped, not paused). */
             inline bool isActive() const { return this->bActive_; }
 
         protected:
-            float interval_;
-            bool bLoop_;
-            bool bActive_;
+            float interval_;    //!< The time-interval in seconds
+            bool bLoop_;        //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;      //!< If true, the Timer ticks and calls the function if the time's up
 
-            float time_;
+            float time_;        //!< Internal variable, counting the time till the next function-call
     };
 
+    //! The Timer is a callback-object, calling a given function after a given time-interval.
     template <class T = BaseObject>
     class Timer : public TimerBase
     {
         public:
+            /** @brief Constructor: Sets the default-values. */
             Timer()
             {
@@ -49 +87 @@
             }
 
+            /**
+                @brief Constructor: Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param timerFunction A function pointer to the function to call
+            */
             Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
             {
@@ -54 +99 @@
             }
 
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param timerFunction A function pointer to the function to call
+            */
             void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
             {
@@ -65 +117 @@
             }
 
+            /** @brief Calls the given function of the given object. */
             void run() const
             {
@@ -75 +128 @@
     };
 
+    //! The TimerFrameListener manages all Timers in the game.
     class TimerFrameListener : public Ogre::FrameListener
     {
         private:
+            /** @brief Gets called before a frame gets rendered. */
             bool frameStarted(const Ogre::FrameEvent &evt)
             {
+                // Iterate through all Timers
                 for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; ++it)
                 {
                     if (it->isActive())
                     {
+                        // If active: Decrease the timer by the duration of the last frame
                         it->time_ -= evt.timeSinceLastFrame;
 
                         if (it->time_ <= 0)
                         {
+                            // It's time to call the function
                             if (it->bLoop_)
-                                it->time_ += it->interval_;
+                                it->time_ += it->interval_; // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.
                             else
-                                it->stopTimer();
+                                it->stopTimer(); // Stop the timer if we don't want to loop
 
                             it->run();

code/branches/FICN/src/orxonox/objects/test3.cc

@@ -10 +10 @@
     {
         RegisterObject(Test3);
+
+        this->setConfigValues();
+    }
+
+    void Test3::setConfigValues()
+    {
+        SetConfigValue(value_int_, -100);
+        SetConfigValue(value_double_, 10.555678);
+        SetConfigValue(value_bool_, true);
+        SetConfigValue(value_string_, "Dies ist ein Test");
+        SetConfigValue(value_vector2_, Vector2(101, 202));
+        SetConfigValue(value_vector3_, Vector3(13, 26, 39));
+        SetConfigValue(value_colourvalue_, ColourValue(1.0, 0.5, 0.25, 0.887));
     }
 
@@ -15 +28 @@
     {
     }
+
+        #include <fstream>
+    void Test3::configOutput()
+    {
+        std::cout << this->value_int_ << std::endl;
+        std::cout << this->value_double_ << std::endl;
+        std::cout << this->value_bool_ << std::endl;
+        std::cout << this->value_string_ << std::endl;
+        std::cout << this->value_vector2_ << std::endl;
+        std::cout << this->value_vector3_ << std::endl;
+        std::cout << this->value_colourvalue_ << std::endl;
+    }
+
         #define testandcout(code) \
           std::cout << #code << " " << code << "\n"

code/branches/FICN/src/orxonox/objects/test3.h

@@ -15 +15 @@
             virtual ~Test3();
 
+            void setConfigValues();
+
             void usefullClassesIsATest(Test1* test1);
             void usefullClassesIsATest(Test2* test2);
+
+            void configOutput();
+
+        private:
+            int                 value_int_;
+            double              value_double_;
+            bool                value_bool_;
+            std::string         value_string_;
+            Vector2             value_vector2_;
+            Vector3             value_vector3_;
+            ColourValue         value_colourvalue_;
     };
 }