Changeset 37


Ignore:
Timestamp:
04/22/07 10:54:43 (12 years ago)
Author:
art
Message:

good

Files:
13 edited

Legend:

Unmodified
Added
Removed
  • Bindings/glfw/Event.h

    r1 r37  
    2727                 **/ 
    2828                class _NRExport OnCreateWindowEvent : public nrEngine::Event{ 
     29                         
     30                        META_Event(OnCreateWindowEvent) 
     31                         
    2932                        public: 
    3033                                //! Constructor 
     
    6669                 **/ 
    6770                class _NRExport OnResizeWindowEvent : public nrEngine::Event{ 
     71                 
     72                        META_Event(OnResizeWindowEvent) 
     73                         
    6874                        public: 
    6975                                //! Constructor 
     
    8995                 **/ 
    9096                class _NRExport OnCloseWindowEvent : public nrEngine::Event{ 
     97                 
     98                        META_Event(OnCloseWindowEvent) 
     99                         
    91100                        public: 
    92101                                OnCloseWindowEvent() : nrEngine::Event(nrEngine::Priority::IMMEDIATE) {} 
     
    103112                class _NRExport KeyboardEvent : public nrEngine::Event{ 
    104113 
     114                        META_Event(KeyboardEvent) 
     115                         
    105116                        public: 
    106117 
     
    131142                **/ 
    132143                class _NRExport OnKeyboardPressEvent : public KeyboardEvent { 
     144                 
     145                        META_Event(OnKeyboardPressEvent) 
     146                         
    133147                        public: 
    134148                                OnKeyboardPressEvent(nrEngine::keyIndex key = nrEngine::KEY_UNKNOWN) : KeyboardEvent(key) {} 
     
    139153                **/ 
    140154                class _NRExport OnKeyboardReleaseEvent : public KeyboardEvent { 
     155                         
     156                        META_Event(OnKeyboardReleaseEvent) 
     157                         
    141158                        public: 
    142159                                OnKeyboardReleaseEvent(nrEngine::keyIndex key = nrEngine::KEY_UNKNOWN) : KeyboardEvent(key) {} 
     
    149166                 **/ 
    150167                class _NRExport OnMouseMoveEvent : public nrEngine::Event { 
     168                         
     169                        META_Event(OnMouseMoveEvent) 
     170                         
    151171                        public: 
    152172 
  • Plugins/dynamicResources/Monitor.cpp

    r35 r37  
    211211                                        // do only reloading on non-empty resources 
    212212                                        it->resource.lockResource(); 
    213                                                 mRoot->sResourceManager()->reload(it->resource); 
    214                                                 NR_Log(Log::LOG_PLUGIN, Log::LL_CHATTY, "dynamicResources: Monitored %s resource was modified, so reload it!", it->resourceName.c_str()); 
     213                                                NR_Log(Log::LOG_PLUGIN, Log::LL_DEBUG, "dynamicResources: Monitored %s resource was modified!", it->resourceName.c_str()); 
     214                                                //it->resource.getBase()->reload(); 
     215                                                it->resource.getBase()->setResourceDirty(true); 
    215216                                        it->resource.unlockResource(); 
    216217                                }else{ 
  • nrEngine/include/Event.h

    r33 r37  
    2424namespace nrEngine{ 
    2525 
     26        /** 
     27        * Macro for definining event type information. 
     28        * Use this macro in all event definitions of classes 
     29        * derived from Event. 
     30        * 
     31        * \ingroup event  
     32        **/ 
     33        #define META_Event(type) \ 
     34                public:\ 
     35                        virtual const char* getEventType() const { return #type; } 
     36                 
     37         
    2638        //! Base untemplated class used for the event instancies 
    2739        /** 
     
    3345         **/ 
    3446        class _NRExport Event { 
     47                 
     48                META_Event(Event) 
     49                 
    3550                public: 
    3651 
     
    4459                         **/ 
    4560                        const Priority& getPriority(); 
    46  
     61                         
    4762                        /** 
    4863                         * Check whenever this class is of the same type 
     
    6075                        } 
    6176 
    62         protected: 
     77                protected: 
    6378                        /** 
    6479                        * Create new instance of a base class Event. 
     
    7489                        Event(Priority prior); 
    7590 
    76  
    7791                private: 
    7892 
    7993                        //! Priority of the message 
    8094                        Priority mPriority; 
    81  
    8295        }; 
    8396 
  • nrEngine/include/Resource.h

    r35 r37  
    151151                void setResourceFilename(const std::list<std::string>& flist); 
    152152 
     153                /** 
     154                 * Set the resource as dirty. If resource is marked as dirty, then it  
     155                 * will be reloaded on next access. 
     156                 * @param dirty True to mark resource as dirty otherwise false. 
     157                 * @note After the resource is reloaded it will be unmarked 
     158                 **/ 
     159                NR_FORCEINLINE void setResourceDirty(bool dirty) { mResIsDirty = dirty; } 
     160                 
     161                /** 
     162                * Check whenever a resource is dirty. Dirty resources require  
     163                * reloading as soon as possible (i.e. on next access) 
     164                **/ 
     165                NR_FORCEINLINE bool isResourceDirty() { return mResIsDirty; } 
     166                 
    153167        protected: 
    154168                 
     
    193207                 * own without loading by loader. 
    194208                 **/ 
    195                 NR_FORCEINLINE void markResourceLoaded() { mResIsLoaded = true; } 
     209                NR_FORCEINLINE void markResourceLoaded() { mResIsLoaded = true; mResIsDirty = false; } 
    196210                 
    197211                /** 
     
    239253                std::string mResName; 
    240254                 
     255                //! Set this variable to reload the resource on next access 
     256                bool mResIsDirty; 
     257                 
    241258                /** 
    242259                 * Set the resource type for this resource. 
     
    247264                NR_FORCEINLINE void     setResourceType(const std::string& type) { mResType = type; } 
    248265 
    249 #if 0 
    250                 /** 
    251                  * If the unloading of resource is done through the resource manager, 
    252                  * so this method will be called. 
    253                  **/ 
    254                 Result unloadResThroughLoader(); 
    255                  
    256                 /** 
    257                  * Reload the resource through the according resource loader. 
    258                  **/ 
    259                 Result reloadResThroughLoader(); 
    260  
    261                 /** 
    262                  * Remove the resource through it's loader 
    263                  **/ 
    264                 Result removeResThroughLoader(); 
    265 #endif 
    266266                /** 
    267267                * Get shared pointer from this class 
  • nrEngine/include/ResourceHolder.h

    r35 r37  
    154154                        * we do work that has to be done if a resource was used. 
    155155                        **/ 
    156                         NR_FORCEINLINE void touchResource(){ 
    157                                 // count up the access count variable 
    158                                 countAccess ++; 
    159                         } 
     156                        void touchResource(); 
    160157                         
    161158                        /** 
  • nrEngine/include/Timer.h

    r23 r37  
    6767                float32 getFrameInterval() const { return static_cast<float32>(_frameTime); } 
    6868         
     69                /** 
     70                * Returns real frame interval based on Clock::getRealFrameInterval(); 
     71                **/ 
     72                float32 getRealFrameInterval() const; 
     73                 
    6974                /** 
    7075                * Returns true if this timer is currently sleeping/paused 
  • nrEngine/include/events/EngineEvent.h

    r1 r37  
    5353        **/ 
    5454        class _NRExport ScriptEvent : public Event { 
     55                 
     56                META_Event(ScriptEvent) 
     57                 
    5558                protected: 
    5659                         
     
    7982         **/ 
    8083        class _NRExport ScriptRegisterFunctionEvent : public ScriptEvent { 
     84                 
     85                META_Event(ScriptRegisterFunctionEvent) 
     86                 
    8187                public: 
    8288                        //! Get the function name which has been registered 
     
    111117         **/ 
    112118        class _NRExport ScriptRemoveFunctionEvent : public ScriptEvent { 
     119                 
     120                META_Event (ScriptRemoveFunctionEvent) 
     121                 
    113122                public: 
    114123                        //! Get the function name which has been registered 
  • nrEngine/include/events/KernelEvent.h

    r1 r37  
    3434         **/ 
    3535        class _NRExport KernelEvent : public Event { 
     36         
     37                META_Event(KernelEvent) 
     38 
    3639                public: 
    3740 
  • nrEngine/include/events/KernelTaskEvent.h

    r1 r37  
    3232         **/ 
    3333        class _NRExport KernelStartTaskEvent : public KernelEvent { 
     34         
     35                META_Event(KernelStartTaskEvent) 
     36                 
    3437                private: 
    3538                        KernelStartTaskEvent(const std::string& taskName, TaskId id, Priority prior = Priority::IMMEDIATE) 
     
    4750         **/ 
    4851        class _NRExport KernelStopTaskEvent : public KernelEvent { 
     52                 
     53                META_Event(KernelStopTaskEvent) 
     54                 
    4955                private: 
    5056                        KernelStopTaskEvent(const std::string& taskName, TaskId id, Priority prior = Priority::IMMEDIATE) 
     
    6268         **/ 
    6369        class _NRExport KernelSuspendTaskEvent : public KernelEvent { 
     70                 
     71                META_Event(KernelSuspendTaskEvent) 
     72                 
    6473                private: 
    6574                        KernelSuspendTaskEvent(const std::string& taskName, TaskId id, Priority prior = Priority::IMMEDIATE) 
     
    7786         **/ 
    7887        class _NRExport KernelResumeTaskEvent : public KernelEvent { 
     88         
     89                META_Event(KernelResumeTaskEvent) 
     90                 
    7991                private: 
    8092                        KernelResumeTaskEvent(const std::string& taskName, TaskId id, Priority prior = Priority::IMMEDIATE) 
  • nrEngine/src/EventManager.cpp

    r1 r37  
    110110                _nrEngineProfile("EventManager.emit"); 
    111111 
     112 
    112113                // if user want to send the message to all channels 
    113114                if (name.length() == 0){ 
     115                        NR_Log(Log::LOG_ENGINE, Log::LL_CHATTY, "EventManager: Emit event '%s' to all channels", event->getEventType()); 
    114116                        ChannelDatabase::iterator it = mChannelDb.begin(); 
    115117                        for (; it != mChannelDb.end(); it++) 
     
    117119 
    118120                }else{ 
     121                        NR_Log(Log::LOG_ENGINE, Log::LL_CHATTY, "EventManager: Emit event '%s' to '%s'", event->getEventType(), name.c_str()); 
    119122                        // get the channel according to the name and emit the message 
    120123                        SharedPtr<EventChannel> channel = getChannel(name); 
  • nrEngine/src/Resource.cpp

    r35 r37  
    2929                mResIsEmpty = false; 
    3030                mResDataSize = sizeof(*this); 
     31                mResIsDirty = false; 
    3132                setResourceType(resType); 
    3233        } 
     
    7374 
    7475                        // if ok, then inform resource manager, that we are reloaded now 
    75                         if (ret == OK) 
     76                        if (ret == OK){ 
    7677                                Engine::sResourceManager()->notifyLoaded(this); 
    77                         else 
     78                                mResIsDirty = false; 
     79                        }else 
    7880                                return ret; 
    7981                } 
     
    9193        } 
    9294 
    93 #if 0 
    94         //---------------------------------------------------------------------------------- 
    95         Result IResource::unloadResThroughLoader() 
    96         { 
    97                 // check for valid loader 
    98                 if (mResLoader == NULL) 
    99                 { 
    100                         char msg[128]; 
    101                         sprintf(msg, "Resource %s does not get valid loader!", getResName().c_str()); 
    102                         NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    103                 } 
    104                 return mResLoader->unload(getSharedPtrFromThis()); 
    105         } 
    106  
    107         //---------------------------------------------------------------------------------- 
    108         Result IResource::reloadResThroughLoader() 
    109         { 
    110                 // check for valid loader 
    111                 if (mResLoader == NULL) 
    112                 { 
    113                         char msg[128]; 
    114                         sprintf(msg, "Resource %s does not get valid loader!", getResName().c_str()); 
    115                         NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    116                 } 
    117                 return mResLoader->reload(getSharedPtrFromThis()); 
    118         } 
    119          
    120         //---------------------------------------------------------------------------------- 
    121         Result IResource::removeResThroughLoader() 
    122         { 
    123                 // check for valid loader 
    124                 if (mResLoader == NULL) 
    125                 { 
    126                         char msg[128]; 
    127                         sprintf(msg, "Resource %s does not get valid loader!", getResName().c_str()); 
    128                         NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    129                 } 
    130                 return mResLoader->remove(getSharedPtrFromThis()); 
    131         } 
    132 #endif   
    13395        //---------------------------------------------------------------------------------- 
    13496        void IResource::addResourceFilename(const std::string& filename) 
  • nrEngine/src/ResourceHolder.cpp

    r35 r37  
    145145                NR_ASSERT(getEmpty() != NULL && "Empty resource must be defined"); 
    146146                 
    147                 // touch the resource 
    148                 touchResource(); 
    149  
    150147                // check if empty is locked, then return empty resource 
    151148                if (isEmptyLocked()) return getEmpty(); 
     
    155152                { 
    156153                        // check if we have locked to an empty resource 
    157                         if (mResource->isResourceLoaded() || isLocked()){ 
     154                        if (mResource->isResourceLoaded() || isLocked()) 
     155                        { 
     156                                touchResource(); 
    158157                                return mResource; 
    159158                        } 
     
    163162        } 
    164163 
     164        //---------------------------------------------------------------------------------- 
     165        void ResourceHolder::touchResource() 
     166        { 
     167                // check if resource need to be reloaded 
     168                if (mResource->isResourceDirty()) mResource->reload(); 
     169                 
     170                // count up the access count variable 
     171                countAccess ++; 
     172        } 
     173 
    165174}; 
    166175 
  • nrEngine/src/Timer.cpp

    r28 r37  
    5858        } 
    5959 
     60         
     61        //------------------------------------------------------------------------ 
     62        float32 Timer::getRealFrameInterval() const 
     63        { 
     64                return _clock.getRealFrameInterval(); 
     65        } 
     66 
    6067}; // end namespace      
    6168 
Note: See TracChangeset for help on using the changeset viewer.