Changeset 32 for nrEngine


Ignore:
Timestamp:
04/10/2007 11:05:42 PM (12 years ago)
Author:
art
Message:
 
Location:
nrEngine
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/IThread.h

    r14 r32  
    2020#include "Prerequisities.h" 
    2121 
    22 //#include <pthread.h> 
    23                  
     22#include <boost/thread/thread.hpp> 
     23 
    2424namespace nrEngine{ 
    2525 
     
    131131                         * will be updated and managed as a thread. 
    132132                         **/ 
    133                         static void* run(void* mythread); 
     133                        static void run(void* mythread); 
    134134 
    135135                        //! Kernel is a friend class 
     
    190190 
    191191                        // Mutex to lock the data before use 
    192                         // pthread_mutex_t mMutex; 
     192                        //pthread_mutex_t mMutex; 
    193193 
    194194                        //! Store here the thread instance 
    195                         //pthread_t     mThread; 
     195                        SharedPtr<boost::thread> mThread; 
    196196 
    197197                        //! Thread attributes 
    198198                        //pthread_attr_t mThreadAttr; 
    199199                         
     200                         
    200201                        //! Change a thread to new state, use mutex to lock the state 
    201202                        void changeState(ThreadState newState); 
  • nrEngine/include/PluginLoader.h

    r15 r32  
    9898                 **/ 
    9999                std::string getLastPluginError(); 
    100                                  
     100                 
     101                /** 
     102                 * @see IResourceLoader::getSuffix() 
     103                 **/ 
     104                std::string getSuffix(const std::string& resType); 
     105 
    101106 
    102107                //! New scripting function to allow loading of plugins 
  • nrEngine/include/Resource.h

    r31 r32  
    9393                * Get the file name from which one this resource can be restored or loaded 
    9494                **/ 
    95                 NR_FORCEINLINE const std::string&       getResFileName() const {return mResFileName;} 
     95                NR_FORCEINLINE const std::list<std::string>&    getResFilenameList() const {return mResFileNames;} 
    9696 
    9797                /** 
     
    168168                 
    169169                /** 
    170                  * Set resource file name  
    171                  * @param filename Filename for the file associated with the resource  
    172                  **/ 
    173                  void setResourceFilename(const std::string& filename) { mResFileName = filename; } 
     170                 * Add resource file name. The filename is used to associated the resource with. 
     171                 * If a resource is build upon of a multiple files, then all the files should 
     172                 * be added through this method. 
     173                 * @param filename Filename of a file associated with the resource  
     174                 **/ 
     175                 void addResourceFilename(const std::string& filename); 
     176                  
     177                 /** 
     178                  * @see addResourceFilename(const std::string& filename) 
     179                  * @param flist List of filenames to add  
     180                  **/ 
     181                 void addResourceFilename(const std::list<std::string>& flist); 
    174182                  
    175183        private: 
     
    193201                ResourceHandle  mResHandle; 
    194202 
    195                 //! Filename from which one this resource can be reloaded/loaded 
    196                 std::string     mResFileName; 
     203                //! File associated with the resource 
     204                std::list<std::string>  mResFileNames; 
    197205 
    198206                //! Count of bytes that this resource is occupies in the memory 
    199                 std::size_t             mResDataSize; 
     207                std::size_t     mResDataSize; 
    200208 
    201209                //! Name of the resource type 
    202                 std::string             mResType; 
     210                std::string     mResType; 
    203211                 
    204212                //! Group name to which one this resource own 
  • nrEngine/include/ResourceLoader.h

    r15 r32  
    293293                        } 
    294294                         
     295                        /** 
     296                         * This method will return back a proper suffix according to the resource type. 
     297                         * Derived classes should overwrite this method, because they know which suffix  
     298                         * are proper to use. The suffix does not contain dot. Empty suffixes are possible. 
     299                         * @param resType Resource type for which one suffix is generated 
     300                         **/ 
     301                        virtual std::string getSuffix(const std::string& resType){return std::string();} 
     302                         
     303 
    295304                private: 
    296305                         
  • nrEngine/include/ResourcePtr.h

    r30 r32  
    4646 
    4747                        /** 
     48                        * Create an empty resource pointer, that do not point to anywhere 
     49                        **/ 
     50                        IResourcePtr() 
     51                        { 
     52                                mHolder.reset(); 
     53                        } 
     54 
     55                        /** 
    4856                        * Virtual destructor 
    4957                        **/ 
     
    163171                        } 
    164172 
    165                         /** 
    166                         * Simple constructor that is declared as protected/private, so that this 
    167                         * pointer con not be created outside as from the resource management system 
    168                         **/ 
    169                         IResourcePtr() 
    170                         { 
    171                                 mHolder.reset(); 
    172                         } 
    173173 
    174174        }; 
  • nrEngine/include/Result.h

    r27 r32  
    6161                NOT_VALID_DATOR         = 1 << 2, 
    6262 
    63  
     63                //! Generic time out error  
     64                TIME_OUT                = 1 << 3, 
     65                 
    6466                //------------------------------------------------------------------------------ 
    6567 
  • nrEngine/include/ScriptLoader.h

    r15 r32  
    7777                        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    7878                         
     79                        /** 
     80                        * @see IResourceLoader::getSuffix() 
     81                        **/ 
     82                        std::string getSuffix(const std::string& resType); 
    7983 
    8084        }; 
  • nrEngine/src/IThread.cpp

    r14 r32  
    3333        { 
    3434                // delete the thread object if it is not empty 
    35                 //if (mThread){ 
    36                         //delete mThread; 
     35                //if (mThread) 
     36                //{ 
     37                //      delete mThread; 
    3738                //} 
    3839        } 
     
    4243        { 
    4344                // Check if we have already a thread created 
    44                 /*if (mThread) 
     45                if (mThread) 
    4546                { 
    4647                        NR_Log(Log::LOG_KERNEL, Log::LL_WARNING, "IThread: the appropriate thread is already running!"); 
    4748                        return; 
    48                 }*/ 
     49                } 
    4950                NR_Log(Log::LOG_KERNEL, "IThread: Create thread and start it"); 
    5051 
     
    5960                 
    6061                // now create a thread and let it run 
    61                 mThreadState = THREAD_RUNNING; 
    6262                int res = pthread_create(&mThread, &mThreadAttr, IThread::run, (void *)this); 
    6363                if (res){ 
     
    6666                }*/ 
    6767    
     68                mThreadState = THREAD_RUNNING; 
     69                mThread.reset(new boost::thread(boost::bind(IThread::run, this))); 
     70                 
    6871        } 
    6972 
     
    8184                        return; 
    8285                }*/ 
     86                mThread->join(); 
    8387        } 
    8488 
     
    117121                // use pthread to yield the timeslice 
    118122                //pthread_yield(); 
     123                boost::thread::yield(); 
    119124        } 
    120125 
    121126        //-------------------------------------------------------------------- 
    122         void* IThread::run(void* _mythread) 
     127        void IThread::run(void* _mythread) 
    123128        { 
    124129                // try to cast the given parameter to IThread pointer 
     
    127132                { 
    128133                        NR_Log(Log::LOG_KERNEL, Log::LL_ERROR, "IThread: not valid parameter was specified for IThread::run(void*) method"); 
    129                         return NULL; 
     134                        return; 
    130135                } 
    131136                 
     
    166171 
    167172                // exit the thread 
    168                 pthread_exit(NULL); 
     173                //return NULL; 
    169174        } 
    170175 
  • nrEngine/src/Makefile

    r22 r32  
    5757INCPATH += -I../include 
    5858CFLAGS += -fPIC 
    59 LIBS += -ldl 
     59LIBS += -ldl -lboost_thread 
    6060 
    6161# define files for installation 
  • nrEngine/src/PluginLoader.cpp

    r15 r32  
    7171                return OK; 
    7272        } 
    73                  
     73 
     74        //---------------------------------------------------------------------------------- 
     75        std::string PluginLoader::getSuffix(const std::string& resType) 
     76        { 
     77#if NR_PLATFORM == NR_PLATFORM_WIN32 
     78                return std::string("dll"); 
     79#elif NR_PLATFORM == NR_PLATFORM_LINUX 
     80                return std::string("so"); 
     81#endif 
     82        } 
     83 
    7484        //---------------------------------------------------------------------------------- 
    7585        Result PluginLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
  • nrEngine/src/Resource.cpp

    r25 r32  
    9898                return mResLoader->remove(getSharedPtrFromThis()); 
    9999        } 
     100         
     101        //---------------------------------------------------------------------------------- 
     102        void IResource::addResourceFilename(const std::string& filename) 
     103        { 
     104                // first check if such a filename already exists 
     105                std::list<std::string>::iterator it = std::find(mResFileNames.begin(), mResFileNames.end(), filename); 
     106                if (it == mResFileNames.end()) 
     107                        mResFileNames.push_back(filename); 
     108        } 
     109         
     110        //---------------------------------------------------------------------------------- 
     111        void IResource::addResourceFilename(const std::list<std::string>& flist) 
     112        { 
     113                std::list<std::string>::const_iterator it = flist.begin(); 
     114                for (; it != flist.end(); it++) 
     115                        addResourceFilename(*it); 
     116        } 
     117 
    100118}; 
    101119 
  • nrEngine/src/ResourceLoader.cpp

    r27 r32  
    5454                bool typeFound = false; 
    5555                std::string type; 
    56  
     56                std::string newFileName = fileName; 
     57                 
    5758                // we search for the type if no type is specified 
    58                 if (resourceType.length() == 0){ 
     59                if (resourceType.length() == 0) 
     60                { 
    5961                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceLoader \"%s\" try to find according resource type by filename \"%s\"", mName.c_str(), fileName.c_str(), fileName.c_str()); 
    6062 
     
    7577                        } 
    7678 
     79                        // if no type foud, then check if suffix is defined 
     80                        if (!typeFound && resourceType.length() > 0) 
     81                        { 
     82                                type = getSuffix(resourceType); 
     83                                if (type.length() > 0) 
     84                                {        
     85                                        typeFound = true; 
     86                                        newFileName = fileName + std::string(".") + type; 
     87                                } 
     88                        } 
     89                         
    7790                        // if no type was specified so give up 
    78                         if (!typeFound){ 
    79                                 NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s neither resource type nor valid file ending was found, give up!", mName.c_str()); 
     91                        if (!typeFound) 
     92                        { 
     93                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s: neither resource type nor valid file ending was found, give up!", mName.c_str()); 
    8094                                return SharedPtr<IResource>(); 
    8195                        } 
     
    92106 
    93107                // setup some data on resource 
    94                 res->mResFileName = fileName; 
     108                res->addResourceFilename(newFileName); 
    95109                res->mResName = name; 
    96110                res->mResGroup = group; 
    97111 
    98112                // now call the implemented loading function 
    99                 if (loadResourceImpl(res.get(), fileName, param) != OK) 
    100                 { 
    101                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), fileName.c_str()); 
     113                if (loadResourceImpl(res.get(), newFileName, param) != OK) 
     114                { 
     115                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), newFileName.c_str()); 
    102116                        remove(res); 
    103117                        return SharedPtr<IResource>(); 
  • nrEngine/src/ScriptLoader.cpp

    r30 r32  
    5555                return OK; 
    5656        } 
     57         
     58        //---------------------------------------------------------------------------------- 
     59        std::string ScriptLoader::getSuffix(const std::string& resType) 
     60        { 
     61                if (resType == "nrScript") 
     62                        return "nrscript"; 
     63                else if (resType == "Script") 
     64                        return "script"; 
     65                else if (resType == "Config") 
     66                        return "cfg"; 
     67                 
     68                return std::string(); 
     69        } 
    5770 
    5871        //---------------------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.