Changeset 10755

Show
Ignore:
Timestamp:
11/16/09 15:47:52 (4 years ago)
Author:
robert
Message:

Removed usaged of throw and catch to enable better compatibility with embedded systems that don't support C++ exceptions efficiently.

Location:
OpenSceneGraph/trunk/src
Files:
6 modified

Legend:

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

    r10737 r10755  
    2626#include <OpenThreads/ScopedLock> 
    2727#include <OpenThreads/Mutex> 
     28 
     29// #define CHECK_CONSISTENCY 
    2830 
    2931using namespace osg; 
     
    457459bool GLBufferObjectSet::checkConsistency() const 
    458460{ 
     461#ifndef CHECK_CONSISTENCY 
    459462    return true; 
    460  
     463#else 
    461464    // osg::notify(osg::NOTICE)<<"GLBufferObjectSet::checkConsistency()"<<std::endl; 
    462465    // check consistency of linked list. 
     
    471474            if ((to->_next)->_previous != to) 
    472475            { 
    473                 osg::notify(osg::NOTICE)<<"Error (to->_next)->_previous != to "<<std::endl; 
    474                 throw "Error (to->_next)->_previous != to "; 
     476                osg::notify(osg::NOTICE)<<"GLBufferObjectSet::checkConsistency() : Error (to->_next)->_previous != to "<<std::endl; 
     477                return false; 
    475478            } 
    476479        } 
     
    479482            if (_tail != to) 
    480483            { 
    481                 osg::notify(osg::NOTICE)<<"Error _trail != to"<<std::endl; 
    482                 throw "Error _trail != to"; 
     484                osg::notify(osg::NOTICE)<<"GLBufferObjectSet::checkConsistency() : Error _trail != to"<<std::endl; 
     485                return false; 
    483486            } 
    484487        } 
     
    499502 
    500503    return true; 
     504#endif 
    501505} 
    502506 
  • OpenSceneGraph/trunk/src/osg/Image.cpp

    r10710 r10755  
    660660    { 
    661661     
    662         // throw exception?? not for now, will simply set values to 0. 
     662        // failed to allocate memory, for now, will simply set values to 0. 
    663663        _s = 0; 
    664664        _t = 0; 
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r10746 r10755  
    5050// #define DO_TIMING 
    5151 
     52#define CHECK_CONSISTENCY 
     53 
    5254namespace osg { 
    5355 
     
    170172bool Texture::TextureObjectSet::checkConsistency() const 
    171173{ 
    172 //    return true; 
    173  
     174#ifndef CHECK_CONSISTENCY 
     175    return true; 
     176#else 
    174177    // osg::notify(osg::NOTICE)<<"TextureObjectSet::checkConsistency()"<<std::endl; 
    175178    // check consistency of linked list. 
     
    184187            if ((to->_next)->_previous != to) 
    185188            { 
    186                 osg::notify(osg::NOTICE)<<"Error (to->_next)->_previous != to "<<std::endl; 
    187                 throw "Error (to->_next)->_previous != to "; 
     189                osg::notify(osg::NOTICE)<<"Texture::TextureObjectSet::checkConsistency() : Error (to->_next)->_previous != to "<<std::endl; 
     190                return false; 
    188191            } 
    189192        } 
     
    192195            if (_tail != to) 
    193196            { 
    194                 osg::notify(osg::NOTICE)<<"Error _trail != to"<<std::endl; 
    195                 throw "Error _trail != to"; 
     197                osg::notify(osg::NOTICE)<<"Texture::TextureObjectSet::checkConsistency() : Error _trail != to"<<std::endl; 
     198                return false; 
    196199            } 
    197200        } 
     
    212215 
    213216    return true; 
     217#endif 
    214218} 
    215219 
  • OpenSceneGraph/trunk/src/osgUtil/TriStripVisitor.cpp

    r9630 r10755  
    404404        arrayComparitor.accept(ra); 
    405405 
    406         try 
    407         { 
    408             triangle_stripper::tri_stripper stripifier(taf._in_indices); 
    409             stripifier.SetCacheSize(_cacheSize); 
    410             stripifier.SetMinStripSize(_minStripSize); 
    411  
    412             triangle_stripper::tri_stripper::primitives_vector outPrimitives; 
    413             stripifier.Strip(&outPrimitives); 
    414  
    415             triangle_stripper::tri_stripper::primitives_vector::iterator pitr; 
    416             if (_generateFourPointPrimitivesQuads) 
    417             { 
    418                 osg::notify(osg::WARN)<<"Collecting all quads"<<std::endl; 
    419  
    420                 typedef triangle_stripper::tri_stripper::primitives_vector::iterator prim_iterator; 
    421                 typedef std::multimap<unsigned int,prim_iterator> QuadMap; 
    422                 QuadMap quadMap; 
    423  
    424                 // pick out quads and place them in the quadMap, and also look for the max  
    425                 for(pitr=outPrimitives.begin(); 
    426                     pitr!=outPrimitives.end(); 
    427                     ++pitr) 
    428                 { 
    429                     if (pitr->m_Indices.size()==4) 
    430                     { 
    431                         std::swap(pitr->m_Indices[2],pitr->m_Indices[3]); 
    432                         unsigned int minValue = *(std::max_element(pitr->m_Indices.begin(),pitr->m_Indices.end())); 
    433                         quadMap.insert(QuadMap::value_type(minValue,pitr)); 
    434                     } 
    435                 } 
    436  
    437  
    438                 // handle the quads 
    439                 if (!quadMap.empty()) 
    440                 { 
    441                     IndexList indices; 
    442                     indices.reserve(4*quadMap.size()); 
    443  
    444                     // adds all the quads into the quad primitive, in ascending order  
    445                     // and the QuadMap stores the quad's in ascending order. 
    446                     for(QuadMap::iterator qitr=quadMap.begin(); 
    447                         qitr!=quadMap.end(); 
    448                         ++qitr) 
    449                     { 
    450                         pitr = qitr->second; 
    451  
    452                         unsigned int min_pos = 0; 
    453                         for(i=1;i<4;++i) 
    454                         { 
    455                             if (pitr->m_Indices[min_pos]>pitr->m_Indices[i])  
    456                                 min_pos = i; 
    457                         } 
    458                         indices.push_back(pitr->m_Indices[min_pos]); 
    459                         indices.push_back(pitr->m_Indices[(min_pos+1)%4]); 
    460                         indices.push_back(pitr->m_Indices[(min_pos+2)%4]); 
    461                         indices.push_back(pitr->m_Indices[(min_pos+3)%4]); 
    462                     }             
    463  
    464                     bool inOrder = true; 
    465                     unsigned int previousValue = indices.front(); 
    466                     for(IndexList::iterator qi_itr=indices.begin()+1; 
    467                         qi_itr!=indices.end() && inOrder; 
    468                         ++qi_itr) 
    469                     { 
    470                         inOrder = (previousValue+1)==*qi_itr; 
    471                         previousValue = *qi_itr; 
    472                     } 
    473  
    474  
    475                     if (inOrder) 
    476                     { 
    477                         new_primitives.push_back(new osg::DrawArrays(GL_QUADS,indices.front(),indices.size())); 
    478                     } 
    479                     else 
    480                     { 
    481                         unsigned int maxValue = *(std::max_element(indices.begin(),indices.end())); 
    482  
    483                         if (maxValue>=65536) 
    484                         { 
    485                             osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_QUADS); 
    486                             std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); 
    487                             new_primitives.push_back(elements); 
    488                         } 
    489                         else 
    490                         { 
    491                             osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(GL_QUADS); 
    492                             std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); 
    493                             new_primitives.push_back(elements); 
    494                         } 
    495                     } 
    496                 }     
    497             }         
    498  
    499             // handle non quad primitives     
     406        triangle_stripper::tri_stripper stripifier(taf._in_indices); 
     407        stripifier.SetCacheSize(_cacheSize); 
     408        stripifier.SetMinStripSize(_minStripSize); 
     409 
     410        triangle_stripper::tri_stripper::primitives_vector outPrimitives; 
     411        if (!stripifier.Strip(&outPrimitives))  
     412        { 
     413            osg::notify(osg::WARN)<<"Error: TriStripVisitor::stripify(Geometry& geom) failed."<<std::endl; 
     414            return; 
     415        } 
     416 
     417        triangle_stripper::tri_stripper::primitives_vector::iterator pitr; 
     418        if (_generateFourPointPrimitivesQuads) 
     419        { 
     420            osg::notify(osg::INFO)<<"Collecting all quads"<<std::endl; 
     421 
     422            typedef triangle_stripper::tri_stripper::primitives_vector::iterator prim_iterator; 
     423            typedef std::multimap<unsigned int,prim_iterator> QuadMap; 
     424            QuadMap quadMap; 
     425 
     426            // pick out quads and place them in the quadMap, and also look for the max  
    500427            for(pitr=outPrimitives.begin(); 
    501428                pitr!=outPrimitives.end(); 
    502429                ++pitr) 
    503430            { 
    504                 if (!_generateFourPointPrimitivesQuads || pitr->m_Indices.size()!=4) 
    505                 { 
    506                     bool inOrder = true; 
    507                     unsigned int previousValue = pitr->m_Indices.front(); 
    508                     for(triangle_stripper::tri_stripper::indices::iterator qi_itr=pitr->m_Indices.begin()+1; 
    509                         qi_itr!=pitr->m_Indices.end() && inOrder; 
    510                         ++qi_itr) 
     431                if (pitr->m_Indices.size()==4) 
     432                { 
     433                    std::swap(pitr->m_Indices[2],pitr->m_Indices[3]); 
     434                    unsigned int minValue = *(std::max_element(pitr->m_Indices.begin(),pitr->m_Indices.end())); 
     435                    quadMap.insert(QuadMap::value_type(minValue,pitr)); 
     436                } 
     437            } 
     438 
     439 
     440            // handle the quads 
     441            if (!quadMap.empty()) 
     442            { 
     443                IndexList indices; 
     444                indices.reserve(4*quadMap.size()); 
     445 
     446                // adds all the quads into the quad primitive, in ascending order  
     447                // and the QuadMap stores the quad's in ascending order. 
     448                for(QuadMap::iterator qitr=quadMap.begin(); 
     449                    qitr!=quadMap.end(); 
     450                    ++qitr) 
     451                { 
     452                    pitr = qitr->second; 
     453 
     454                    unsigned int min_pos = 0; 
     455                    for(i=1;i<4;++i) 
    511456                    { 
    512                         inOrder = (previousValue+1)==*qi_itr; 
    513                         previousValue = *qi_itr; 
     457                        if (pitr->m_Indices[min_pos]>pitr->m_Indices[i])  
     458                            min_pos = i; 
    514459                    } 
    515  
    516                     if (inOrder) 
     460                    indices.push_back(pitr->m_Indices[min_pos]); 
     461                    indices.push_back(pitr->m_Indices[(min_pos+1)%4]); 
     462                    indices.push_back(pitr->m_Indices[(min_pos+2)%4]); 
     463                    indices.push_back(pitr->m_Indices[(min_pos+3)%4]); 
     464                }             
     465 
     466                bool inOrder = true; 
     467                unsigned int previousValue = indices.front(); 
     468                for(IndexList::iterator qi_itr=indices.begin()+1; 
     469                    qi_itr!=indices.end() && inOrder; 
     470                    ++qi_itr) 
     471                { 
     472                    inOrder = (previousValue+1)==*qi_itr; 
     473                    previousValue = *qi_itr; 
     474                } 
     475 
     476 
     477                if (inOrder) 
     478                { 
     479                    new_primitives.push_back(new osg::DrawArrays(GL_QUADS,indices.front(),indices.size())); 
     480                } 
     481                else 
     482                { 
     483                    unsigned int maxValue = *(std::max_element(indices.begin(),indices.end())); 
     484 
     485                    if (maxValue>=65536) 
    517486                    { 
    518                         new_primitives.push_back(new osg::DrawArrays(pitr->m_Type,pitr->m_Indices.front(),pitr->m_Indices.size())); 
     487                        osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(GL_QUADS); 
     488                        std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); 
     489                        new_primitives.push_back(elements); 
    519490                    } 
    520491                    else 
    521492                    { 
    522                         unsigned int maxValue = *(std::max_element(pitr->m_Indices.begin(),pitr->m_Indices.end())); 
    523                         if (maxValue>=65536) 
    524                         { 
    525                             osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(pitr->m_Type); 
    526                             elements->reserve(pitr->m_Indices.size()); 
    527                             std::copy(pitr->m_Indices.begin(),pitr->m_Indices.end(),std::back_inserter(*elements)); 
    528                             new_primitives.push_back(elements); 
    529                         } 
    530                         else 
    531                         { 
    532                             osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(pitr->m_Type); 
    533                             elements->reserve(pitr->m_Indices.size()); 
    534                             std::copy(pitr->m_Indices.begin(),pitr->m_Indices.end(),std::back_inserter(*elements)); 
    535                             new_primitives.push_back(elements); 
    536                         } 
     493                        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(GL_QUADS); 
     494                        std::copy(indices.begin(),indices.end(),std::back_inserter(*elements)); 
     495                        new_primitives.push_back(elements); 
    537496                    } 
    538497                } 
     498            }     
     499        }         
     500 
     501        // handle non quad primitives     
     502        for(pitr=outPrimitives.begin(); 
     503            pitr!=outPrimitives.end(); 
     504            ++pitr) 
     505        { 
     506            if (!_generateFourPointPrimitivesQuads || pitr->m_Indices.size()!=4) 
     507            { 
     508                bool inOrder = true; 
     509                unsigned int previousValue = pitr->m_Indices.front(); 
     510                for(triangle_stripper::tri_stripper::indices::iterator qi_itr=pitr->m_Indices.begin()+1; 
     511                    qi_itr!=pitr->m_Indices.end() && inOrder; 
     512                    ++qi_itr) 
     513                { 
     514                    inOrder = (previousValue+1)==*qi_itr; 
     515                    previousValue = *qi_itr; 
     516                } 
     517 
     518                if (inOrder) 
     519                { 
     520                    new_primitives.push_back(new osg::DrawArrays(pitr->m_Type,pitr->m_Indices.front(),pitr->m_Indices.size())); 
     521                } 
     522                else 
     523                { 
     524                    unsigned int maxValue = *(std::max_element(pitr->m_Indices.begin(),pitr->m_Indices.end())); 
     525                    if (maxValue>=65536) 
     526                    { 
     527                        osg::DrawElementsUInt* elements = new osg::DrawElementsUInt(pitr->m_Type); 
     528                        elements->reserve(pitr->m_Indices.size()); 
     529                        std::copy(pitr->m_Indices.begin(),pitr->m_Indices.end(),std::back_inserter(*elements)); 
     530                        new_primitives.push_back(elements); 
     531                    } 
     532                    else 
     533                    { 
     534                        osg::DrawElementsUShort* elements = new osg::DrawElementsUShort(pitr->m_Type); 
     535                        elements->reserve(pitr->m_Indices.size()); 
     536                        std::copy(pitr->m_Indices.begin(),pitr->m_Indices.end(),std::back_inserter(*elements)); 
     537                        new_primitives.push_back(elements); 
     538                    } 
     539                } 
    539540            } 
    540  
    541             geom.setPrimitiveSetList(new_primitives); 
    542  
    543             #if 0  
    544             // debugging code for indentifying the tri-strips.        
    545                     osg::Vec4Array* colors = new osg::Vec4Array(new_primitives.size()); 
    546                     for(i=0;i<colors->size();++i) 
    547                     { 
    548                         (*colors)[i].set(((float)rand()/(float)RAND_MAX), 
    549                                          ((float)rand()/(float)RAND_MAX), 
    550                                          ((float)rand()/(float)RAND_MAX), 
    551                                          1.0f); 
    552                     } 
    553                     geom.setColorArray(colors); 
    554                     geom.setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE_SET); 
    555             #endif         
    556  
    557         } 
    558         catch(const char* errorMessage) 
    559         { 
    560             osg::notify(osg::WARN)<<"Warning: '"<<errorMessage<<"' exception thrown from triangle_stripper"<<std::endl; 
    561         } 
    562         catch(triangle_stripper::tri_stripper::triangles_indices_error&) 
    563         { 
    564             osg::notify(osg::WARN)<<"Warning: triangles_indices_error exception thrown from triangle_stripper"<<std::endl; 
    565         } 
    566         catch(...) 
    567         { 
    568             osg::notify(osg::WARN)<<"Warning: Unhandled exception thrown from triangle_stripper"<<std::endl; 
    569         } 
    570  
     541        } 
     542 
     543        geom.setPrimitiveSetList(new_primitives); 
     544 
     545        #if 0  
     546        // debugging code for indentifying the tri-strips.        
     547                osg::Vec4Array* colors = new osg::Vec4Array(new_primitives.size()); 
     548                for(i=0;i<colors->size();++i) 
     549                { 
     550                    (*colors)[i].set(((float)rand()/(float)RAND_MAX), 
     551                                     ((float)rand()/(float)RAND_MAX), 
     552                                     ((float)rand()/(float)RAND_MAX), 
     553                                     1.0f); 
     554                } 
     555                geom.setColorArray(colors); 
     556                geom.setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE_SET); 
     557        #endif         
    571558    } 
    572559    else 
  • OpenSceneGraph/trunk/src/osgUtil/TriStrip_tri_stripper.cpp

    r7414 r10755  
    1313// tri_stripper.cpp: implementation of the Tri Stripper class. 
    1414// 
    15 // Copyright (C) 2002 Tanguy Fautré. 
     15// Copyright (C) 2002 Tanguy Fautrï¿œ. 
    1616// For conditions of distribution and use, 
    1717// see copyright notice in tri_stripper.h 
     
    2020 
    2121#include "TriStrip_tri_stripper.h" 
    22  
     22#include <osg/Notify> 
    2323 
    2424 
     
    3939////////////////////////////////////////////////////////////////////// 
    4040 
    41 void tri_stripper::Strip(primitives_vector * out_pPrimitivesVector) 
     41bool tri_stripper::Strip(primitives_vector * out_pPrimitivesVector) 
    4242{ 
    4343    // verify that the number of indices is correct 
    4444    if (m_TriIndices.size() % 3 != 0) 
    45         throw triangles_indices_error(); 
     45    { 
     46        osg::notify(osg::NOTICE)<<"Warning: tri_stripper::Strip(..) invalid number of triangle indices."<<std::endl; 
     47        return false; 
     48    } 
    4649 
    4750    // clear possible garbage 
     
    5962 
    6063    // Launch the triangle strip generator 
    61     Stripify(); 
     64    if (!Stripify()) 
     65    { 
     66        return false; 
     67    } 
    6268 
    6369    // Add the triangles that couldn't be stripped 
     
    7076    std::swap(m_PrimitivesVector, (* out_pPrimitivesVector)); 
    7177//    m_PrimitivesVector.swap(* out_pPrimitivesVector); 
     78 
     79    return true; 
    7280} 
    7381 
     
    158166 
    159167 
    160 void tri_stripper::Stripify() 
     168bool tri_stripper::Stripify() 
    161169{ 
    162170    // Reset the triangle strip id selector 
     
    183191            // Note: BuildStrip refills m_NextCandidates 
    184192            if (TriStrip.Size() >= m_MinStripSize) 
    185                 BuildStrip(TriStrip); 
     193            { 
     194                if (!BuildStrip(TriStrip)) return false; 
     195            } 
    186196        } 
    187197 
     
    196206            m_TriHeap.pop(); 
    197207    } 
     208 
     209    return true; 
    198210} 
    199211 
     
    377389 
    378390 
    379 void tri_stripper::BuildStrip(const triangle_strip TriStrip) 
     391bool tri_stripper::BuildStrip(const triangle_strip TriStrip) 
    380392{ 
    381393    typedef triangles_graph::const_out_arc_iterator const_tri_link_iter; 
     
    440452        // Debug check: we must have found the next triangle 
    441453        //assert(LinkIt != TriNodeIt->out_end());         
    442         if (LinkIt == TriNodeIt->out_end()) throw "tri_stripper::BuildStrip(,) error, next triangle not found"; 
     454        if (LinkIt == TriNodeIt->out_end())  
     455        { 
     456            osg::notify(osg::NOTICE)<<"Warning: tri_stripper::BuildStrip(,) error, next triangle not found."<<std::endl; 
     457            return false; 
     458        } 
    443459 
    444460 
     
    450466        ClockWise = ! ClockWise; 
    451467    } 
     468    return true; 
    452469} 
    453470 
  • OpenSceneGraph/trunk/src/osgUtil/TriStrip_tri_stripper.h

    r9637 r10755  
    33////////////////////////////////////////////////////////////////////// 
    44// 
    5 //  Copyright (C) 2002 Tanguy Fautré. 
     5//  Copyright (C) 2002 Tanguy Fautrï¿œ. 
    66// 
    77//  This software is provided 'as-is', without any express or implied 
     
    2222//  3. This notice may not be removed or altered from any source distribution. 
    2323// 
    24 //  Tanguy Fautré 
     24//  Tanguy Fautrï¿œ 
    2525//  softdev@pandora.be 
    2626// 
     
    204204    typedef std::vector<primitives> primitives_vector; 
    205205 
    206     struct triangles_indices_error { }; 
    207  
    208  
    209206    // constructor/initializer 
    210207    inline tri_stripper(const indices & TriIndices); 
     
    215212 
    216213    // Stripper 
    217     void Strip(primitives_vector * out_pPrimitivesVector);    // throw triangles_indices_error(); 
     214    bool Strip(primitives_vector * out_pPrimitivesVector);  
    218215 
    219216private: 
     
    233230    void InitTriGraph(); 
    234231    void InitTriHeap(); 
    235     void Stripify(); 
     232    bool Stripify(); 
    236233    void AddLeftTriangles(); 
    237234 
     
    243240    triangle_strip FindBestStrip(); 
    244241    triangle_strip ExtendTriToStrip(const size_t StartTriPos, const triangle_strip::start_order StartOrder); 
    245     void BuildStrip(const triangle_strip TriStrip); 
     242    bool BuildStrip(const triangle_strip TriStrip); 
    246243    void AddIndice(const indice i); 
    247244    void AddIndiceToCache(const indice i, bool CacheHitCount = false);