Show
Ignore:
Timestamp:
10/21/14 10:27:28 (2 hours ago)
Author:
robert
Message:

Removed checks against Drawable as these are no longer required.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osg/ImageSequence.cpp

    r13186 r13191  
    2323using namespace osg; 
    2424 
     25ImageSequence::ImageData::ImageData() 
     26{ 
     27} 
     28 
     29ImageSequence::ImageData::ImageData(const ImageData& id): 
     30    _filename(id._filename), 
     31    _image(id._image), 
     32    _imageRequest(id._imageRequest) 
     33{ 
     34} 
     35 
     36ImageSequence::ImageData& ImageSequence::ImageData::operator = (const ImageSequence::ImageData& rhs) 
     37{ 
     38    if (&rhs!=this) 
     39    { 
     40        _filename = rhs._filename; 
     41        _image = rhs._image; 
     42        _imageRequest = rhs._imageRequest; 
     43    } 
     44    return *this; 
     45} 
     46 
    2547ImageSequence::ImageSequence() 
    2648{ 
     
    97119void ImageSequence::computeTimePerImage() 
    98120{ 
    99     if (!_fileNames.empty()) _timePerImage = _length / double(_fileNames.size()); 
    100     else if (!_images.empty()) _timePerImage = _length / double(_images.size()); 
     121    if (!_imageDataList.empty()) _timePerImage = _length / double(_imageDataList.size()); 
    101122    else _timePerImage = _length; 
    102123} 
     
    106127    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    107128 
    108     if (pos>=_fileNames.size()) _fileNames.resize(pos); 
    109     _fileNames[pos] = fileName; 
     129    if (pos>=_imageDataList.size()) _imageDataList.resize(pos); 
     130    _imageDataList[pos]._filename = fileName; 
    110131} 
    111132 
     
    113134{ 
    114135    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    115     return pos<_fileNames.size() ? _fileNames[pos] : std::string(); 
     136    return pos<_imageDataList.size() ? _imageDataList[pos]._filename : std::string(); 
    116137} 
    117138 
     
    119140{ 
    120141    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    121     _fileNames.push_back(fileName); 
     142    _imageDataList.push_back(ImageData()); 
     143    _imageDataList.back()._filename = fileName; 
    122144    computeTimePerImage(); 
    123145} 
     
    127149    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    128150 
    129     OSG_INFO<<"ImageSequence::setImage("<<pos<<","<<image->getFileName()<<")"<<std::endl; 
    130  
    131     if (pos>=_images.size()) _images.resize(pos+1); 
    132  
    133     _images[pos] = image; 
    134  
    135     // prune from file requested list. 
    136     FilesRequested::iterator itr = _filesRequested.find(image->getFileName()); 
    137     if (itr!=_filesRequested.end()) _filesRequested.erase(itr); 
     151    if (pos>=_imageDataList.size()) _imageDataList.resize(pos+1); 
     152 
     153    _imageDataList[pos]._image = image; 
     154    _imageDataList[pos]._filename = image->getFileName(); 
    138155} 
    139156 
     
    141158{ 
    142159    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    143     return pos<_images.size() ? _images[pos].get() : 0; 
     160    return pos<_imageDataList.size() ? _imageDataList[pos]._image.get() : 0; 
    144161} 
    145162 
     
    147164{ 
    148165    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    149     return pos<_images.size() ? _images[pos].get() : 0; 
     166    return pos<_imageDataList.size() ? _imageDataList[pos]._image.get() : 0; 
    150167} 
    151168 
     
    157174 
    158175    // OSG_NOTICE<<"merging image in order expected : "<<image->getFileName()<<std::endl; 
    159     _images.push_back(image); 
     176    _imageDataList.push_back(ImageData()); 
     177    _imageDataList.back()._image = image; 
    160178 
    161179    computeTimePerImage(); 
     
    163181    if (data()==0) 
    164182    { 
    165         setImageToChild(_images.front().get()); 
    166     } 
    167 } 
    168  
    169 void ImageSequence::setImageToChild(const osg::Image* image) 
    170 { 
    171     // OSG_NOTICE<<"setImageToChild("<<image<<")"<<std::endl; 
    172  
     183        setImageToChild(_imageDataList.size()-1); 
     184    } 
     185} 
     186 
     187void ImageSequence::setImageToChild(int pos) 
     188{ 
     189     
     190    const osg::Image* image = (pos>=0 && pos<static_cast<int>(_imageDataList.size())) ? _imageDataList[pos]._image.get() : 0; 
    173191    if (image==0) return; 
    174192 
    175193    // check to see if data is changing, if not don't apply 
    176     if (image->data() == data()) return; 
     194    if (image->data() == data()) 
     195    { 
     196        return; 
     197    } 
     198 
     199 
     200    if (_mode==PAGE_AND_DISCARD_USED_IMAGES && _previousAppliedImageIndex>=0) 
     201    { 
     202        if (_previousAppliedImageIndex<pos) 
     203        { 
     204            OSG_INFO<<"Moving forward from "<<_previousAppliedImageIndex<<" to "<<pos<<std::endl; 
     205            while(_previousAppliedImageIndex<pos) 
     206            { 
     207                _imageDataList[_previousAppliedImageIndex]._image = 0; 
     208                OSG_INFO<<"   deleting "<<_previousAppliedImageIndex<<std::endl; 
     209                ++_previousAppliedImageIndex; 
     210            } 
     211        } 
     212        else if (_previousAppliedImageIndex>pos) 
     213        { 
     214            OSG_INFO<<"Moving back from "<<_previousAppliedImageIndex<<" to "<<pos<<std::endl; 
     215            while(_previousAppliedImageIndex>pos) 
     216            { 
     217                _imageDataList[_previousAppliedImageIndex]._image = 0; 
     218                OSG_INFO<<"   deleting "<<_previousAppliedImageIndex<<std::endl; 
     219                --_previousAppliedImageIndex; 
     220            } 
     221        }         
     222    } 
     223     
     224 
     225    _previousAppliedImageIndex = pos; 
    177226 
    178227    setImage(image->s(),image->t(),image->r(), 
     
    198247    if (time<0.0) return 0; 
    199248    int index = int(time/_timePerImage); 
    200     if (index>=int(_images.size())) return int(_images.size())-1; 
     249    if (index>=int(_imageDataList.size())) return int(_imageDataList.size())-1; 
    201250    return index; 
    202251} 
     
    223272    { 
    224273        time = _seekTime; 
     274        useDirectTimeRequest = true; 
    225275        _referenceTime =  fs->getSimulationTime() - time/_timeMultiplier; 
    226276    } 
     
    248298    _seekTimeSet = false; 
    249299 
    250     bool pruneOldImages = false; 
    251  
    252     switch(_mode) 
    253     { 
    254         case(PRE_LOAD_ALL_IMAGES): 
    255         { 
    256             if (irh && _fileNames.size()>_images.size()) 
    257             { 
    258                 FileNames::iterator itr = _fileNames.begin(); 
    259                 for(unsigned int i=0;i<_images.size();++i) ++itr; 
    260  
    261                 for(; itr!=_fileNames.end(); ++itr) 
    262                 { 
    263                     osg::Image* image = irh->readImageFile(*itr); 
    264                     _images.push_back(image); 
    265                 } 
    266             } 
    267  
    268             irh = 0; 
    269             break; 
    270         } 
    271         case(PAGE_AND_RETAIN_IMAGES): 
    272         { 
    273             break; 
    274         } 
    275         case(PAGE_AND_DISCARD_USED_IMAGES): 
    276         { 
    277             pruneOldImages = true; 
    278             break; 
     300    if (irh && _mode==PRE_LOAD_ALL_IMAGES) 
     301    { 
     302        for(ImageDataList::iterator itr = _imageDataList.begin(); 
     303            itr != _imageDataList.end(); 
     304            ++itr) 
     305        { 
     306            if (!(itr->_image) && !(itr->_filename.empty())) 
     307            { 
     308                itr->_image = irh->readImageFile(itr->_filename); 
     309            } 
    279310        } 
    280311    } 
     
    283314    // OSG_NOTICE<<"time= "<<time<<" _timePerImage="<<_timePerImage<<" index="<<index<<" _length="<<_length<<std::endl; 
    284315 
    285     if (index>=int(_images.size())) index = int(_images.size())-1; 
    286  
    287     if (index>=0 && index<int(_images.size())) 
    288     { 
    289         if (pruneOldImages) 
    290         { 
     316    if (index>=int(_imageDataList.size())) index = int(_imageDataList.size())-1; 
     317 
     318    if (index>=0 && index<int(_imageDataList.size())) 
     319    { 
     320        // need to find the nearest relevant change. 
     321        if (!_imageDataList[index]._image) 
     322        {             
    291323            if (_previousAppliedImageIndex<index) 
    292324            { 
    293325                OSG_DEBUG<<"ImageSequence::update(..) Moving forward by "<<index-_previousAppliedImageIndex<<std::endl; 
    294                 while (index>=0 && !_images[index].valid()) 
     326                while (index>=0 && !_imageDataList[index]._image.valid()) 
    295327                { 
    296328                    --index; 
     
    300332            { 
    301333                OSG_DEBUG<<"ImageSequence::update(..) Moving back by "<<_previousAppliedImageIndex-index<<std::endl; 
    302                 while (index<static_cast<int>(_images.size()) && !_images[index].valid()) 
     334                while (index<static_cast<int>(_imageDataList.size()) && !_imageDataList[index]._image.valid()) 
    303335                { 
    304336                    ++index; 
    305337                } 
    306338            } 
     339        } 
     340         
     341        if (index>=0 && index!=_previousAppliedImageIndex) 
     342        { 
     343            setImageToChild(index); 
     344        } 
     345    } 
     346 
     347    // OSG_NOTICE<<"time = "<<time<<std::endl; 
     348 
     349    if (!irh) return; 
     350 
     351    if (useDirectTimeRequest) 
     352    { 
     353        int i = int(time/_timePerImage); 
     354        if ((i>=int(_imageDataList.size()) || !_imageDataList[i]._image)) 
     355        { 
     356             i = osg::clampTo<int>(i, 0, _imageDataList.size()-1); 
     357 
     358             OSG_INFO<<"Requesting file, entry="<<i<<" : _fileNames[i]="<<_imageDataList[i]._filename<<std::endl; 
     359             irh->requestImageFile(_imageDataList[i]._filename, this, i, time, fs, _imageDataList[i]._imageRequest, _readOptions.get()); 
     360        } 
     361    } 
     362    else 
     363    { 
     364        double preLoadTime = time + osg::minimum(irh->getPreLoadTime()*_timeMultiplier, _length); 
     365 
     366        int startLoadIndex = int(time/_timePerImage); 
     367        if (startLoadIndex>=int(_imageDataList.size())) startLoadIndex = int(_imageDataList.size())-1; 
     368        if (startLoadIndex<0) startLoadIndex = 0; 
     369 
     370        int endLoadIndex = int(preLoadTime/_timePerImage); 
     371        if (endLoadIndex>=int(_imageDataList.size())) 
     372        { 
     373            if (looping) 
     374            { 
     375                endLoadIndex -= int(_imageDataList.size()); 
     376            } 
    307377            else 
    308378            { 
    309                 // OSG_NOTICE<<"ImageSequence::update(..) Same index."<<std::endl; 
    310             } 
    311         } 
    312  
    313         if (index>=0) 
    314         { 
    315             // OSG_NOTICE<<"at time "<<time<<" setting child = "<<index<<std::endl; 
    316  
    317             if (_previousAppliedImageIndex!=index) 
    318             { 
    319                 if (_previousAppliedImageIndex >= 0 && 
    320                     _previousAppliedImageIndex<int(_images.size()) && 
    321                     pruneOldImages) 
     379                endLoadIndex = int(_imageDataList.size())-1; 
     380            } 
     381        } 
     382        if (endLoadIndex<0) endLoadIndex = 0; 
     383 
     384        double requestTime = time; 
     385 
     386        if (endLoadIndex<startLoadIndex) 
     387        { 
     388            for(int i=startLoadIndex; i<int(_imageDataList.size()); ++i) 
     389            { 
     390                if (!_imageDataList[i]._image) 
    322391                { 
    323                     _images[_previousAppliedImageIndex] = 0; 
    324                 } 
    325  
    326                 setImageToChild(_images[index].get()); 
    327  
    328                 _previousAppliedImageIndex = index; 
    329             } 
    330         } 
    331     } 
    332  
    333     // OSG_NOTICE<<"time = "<<time<<std::endl; 
    334  
    335     if (!irh) return; 
    336  
    337     if (useDirectTimeRequest) 
    338     { 
    339         int i = int(time/_timePerImage); 
    340         if ((i>=int(_images.size()) || !_images[i])) 
    341         { 
    342              i = osg::clampTo<int>(i, 0, _fileNames.size()-1); 
    343              if (_filesRequested.count(_fileNames[i])==0) 
    344              { 
    345                  OSG_INFO<<"Requesting file, entry="<<i<<" : _fileNames[i]="<<_fileNames[i]<<std::endl; 
    346                 //_filesRequested.insert(_fileNames[i]); 
    347                 irh->requestImageFile(_fileNames[i], this, i, time, fs); 
    348              } 
    349              else 
    350              { 
    351                  OSG_DEBUG<<"File already requested, entry="<<i<<" : _fileNames[i]="<<_fileNames[i]<<std::endl; 
    352              } 
    353         } 
    354     } 
    355     else 
    356     { 
    357         double preLoadTime = time + osg::minimum(irh->getPreLoadTime()*_timeMultiplier, _length); 
    358  
    359         int startLoadIndex = int(time/_timePerImage); 
    360         if (startLoadIndex>=int(_images.size())) startLoadIndex = int(_images.size())-1; 
    361         if (startLoadIndex<0) startLoadIndex = 0; 
    362  
    363         int endLoadIndex = int(preLoadTime/_timePerImage); 
    364         if (endLoadIndex>=int(_fileNames.size())) 
    365         { 
    366             if (looping) 
    367             { 
    368                 endLoadIndex -= int(_fileNames.size()); 
    369             } 
    370             else 
    371             { 
    372                 endLoadIndex = int(_fileNames.size())-1; 
    373             } 
    374         } 
    375         if (endLoadIndex<0) endLoadIndex = 0; 
    376  
    377         double requestTime = time; 
    378  
    379         if (endLoadIndex<startLoadIndex) 
    380         { 
    381             for(int i=startLoadIndex; i<int(_fileNames.size()); ++i) 
    382             { 
    383                 if ((i>=int(_images.size()) || !_images[i]) && _filesRequested.count(_fileNames[i])==0) 
    384                 { 
    385                     //_filesRequested.insert(_fileNames[i]); 
    386                     irh->requestImageFile(_fileNames[i], this, i, requestTime, fs); 
     392                    irh->requestImageFile(_imageDataList[i]._filename, this, i, requestTime, fs, _imageDataList[i]._imageRequest, _readOptions.get()); 
    387393                } 
    388394                requestTime += _timePerImage; 
     
    391397            for(int i=0; i<=endLoadIndex; ++i) 
    392398            { 
    393                 if ((i>=int(_images.size()) || !_images[i]) && _filesRequested.count(_fileNames[i])==0) 
     399                if (!_imageDataList[i]._image) 
    394400                { 
    395                     //_filesRequested.insert(_fileNames[i]); 
    396                     irh->requestImageFile(_fileNames[i], this, i, requestTime, fs); 
     401                    irh->requestImageFile(_imageDataList[i]._filename, this, i, requestTime, fs, _imageDataList[i]._imageRequest, _readOptions.get()); 
    397402                } 
    398403                requestTime += _timePerImage; 
     
    403408            for(int i=startLoadIndex; i<=endLoadIndex; ++i) 
    404409            { 
    405                 if ((i>=int(_images.size()) || !_images[i]) && _filesRequested.count(_fileNames[i])==0) 
     410                if (!_imageDataList[i]._image) 
    406411                { 
    407                     //_filesRequested.insert(_fileNames[i]); 
    408                     irh->requestImageFile(_fileNames[i], this, i, requestTime, fs); 
     412                    irh->requestImageFile(_imageDataList[i]._filename, this, i, requestTime, fs, _imageDataList[i]._imageRequest, _readOptions.get()); 
    409413                } 
    410414                requestTime += _timePerImage; 
     
    412416        } 
    413417 
    414  
    415     } 
    416  
    417 } 
     418    } 
     419 
     420}