Utility3D.cpp

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#include <PVLE/3D/Utility3D.h>
#include <PVLE/Util/TracedException.h>
#include <PVLE/Util/Math.h>
#include <PVLE/Util/Util.h>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osg/Shape>        // For HeightField class
#include <osg/Vec2>
#include <limits.h>

#include <osg/Version>
#ifndef OSG_MIN_VERSION_REQUIRED
    // Backward compatibility (OSG <2.9)
    #define OSG_MIN_VERSION_REQUIRED(MAJOR, MINOR, PATCH) ((OPENSCENEGRAPH_MAJOR_VERSION>MAJOR) || (OPENSCENEGRAPH_MAJOR_VERSION==MAJOR && (OPENSCENEGRAPH_MINOR_VERSION>MINOR || (OPENSCENEGRAPH_MINOR_VERSION==MINOR && OPENSCENEGRAPH_PATCH_VERSION>=PATCH))))
#endif


bool hasUpdateCallbackType(const osg::Node & node, const std::type_info & type) {
    const osg::NodeCallback * pCurrentCB = node.getUpdateCallback();
    if (!pCurrentCB) return false;

    // Check for unicity of the given callback type
    for(; pCurrentCB; pCurrentCB = pCurrentCB->getNestedCallback()) {
        if (typeid(*pCurrentCB) == type) return true;   // Existing type found
    }
    return false;
}

float computeAngle(const osg::Vec3f & v1, const osg::Vec3f & v2, const osg::Vec3f reference) {
    osg::Vec3f v3(v1 ^ v2);
    float angle = atan2(v3.length(), v1*v2);
    return v3*reference < 0.f ? -angle : angle;
}

double computeAngle(const osg::Vec3d & v1, const osg::Vec3d & v2, const osg::Vec3d reference) {
    osg::Vec3d v3(v1 ^ v2);
    double angle = atan2(v3.length(), v1*v2);
    return v3*reference < 0. ? -angle : angle;
}

#include <osg/Endian>

// Creates a 3D normal map from a 3D bump map.
//void createNormalMap3D(const osg::Image* image, osg::Image* normalmap, unsigned int sourcePixelIncrement, unsigned int alphaOffset)
//{
//    for(int r=1;r<image->r()-1;++r)
//    {
//        for(int t=1;t<image->t()-1;++t)
//        {
//            const unsigned char* ptr = image->data(1,t,r)+alphaOffset;
//            const unsigned char* left = image->data(0,t,r)+alphaOffset;
//            const unsigned char* right = image->data(2,t,r)+alphaOffset;
//            const unsigned char* above = image->data(1,t+1,r)+alphaOffset;
//            const unsigned char* below = image->data(1,t-1,r)+alphaOffset;
//            const unsigned char* in = image->data(1,t,r+1)+alphaOffset;
//            const unsigned char* out = image->data(1,t,r-1)+alphaOffset;
//
//            unsigned char* destination = (unsigned char*) normalmap->data(1,t,r);
//
//            for(int s=1;s<image->s()-1;++s)
//            {
//                osg::Vec3 grad((float)(*left)-(float)(*right),
//                               (float)(*below)-(float)(*above),
//                               (float)(*out) -(float)(*in));
//
//                grad.normalize();
//
//                if (grad.x()==0.0f && grad.y()==0.0f && grad.z()==0.0f)
//                {
//                    grad.set(128.0f,128.0f,128.0f);
//                }
//                else
//                {
//                    grad.x() = osg::clampBetween((grad.x()+1.0f)*128.0f,0.0f,255.0f);
//                    grad.y() = osg::clampBetween((grad.y()+1.0f)*128.0f,0.0f,255.0f);
//                    grad.z() = osg::clampBetween((grad.z()+1.0f)*128.0f,0.0f,255.0f);
//                }
//
//                *(destination++) = (unsigned char)(grad.x()); // scale and bias X.
//                *(destination++) = (unsigned char)(grad.y()); // scale and bias Y.
//                *(destination++) = (unsigned char)(grad.z()); // scale and bias Z.
//
//                *destination++ = *ptr;
//
//                ptr += sourcePixelIncrement;
//                left += sourcePixelIncrement;
//                right += sourcePixelIncrement;
//                above += sourcePixelIncrement;
//                below += sourcePixelIncrement;
//                in += sourcePixelIncrement;
//                out += sourcePixelIncrement;
//            }
//        }
//    }
//}


osg::Image * createNormalMap(const osg::Image* image)
{
    if (image->r() > 1) {
        LOG_NOTICE << "Normal map generation for 3D textures is not supported yet." << std::endl;
        return NULL;
    }
    if (image->s() <= 2 || image->t() <= 2) {
        LOG_NOTICE << "Normal map generation needs a source which is more than 2 pixel large (or long)." << std::endl;
        return NULL;
    }

    // -- Code comes from osgvolume.cpp example, and has been slightly modified (for 2D images) --
    unsigned int sourcePixelIncrement = 1;
    unsigned int alphaOffset = 0; 
    switch(image->getPixelFormat())
    {
    case(GL_ALPHA):
    case(GL_LUMINANCE):
        sourcePixelIncrement = 1;
        alphaOffset = 0;
        break;
    case(GL_LUMINANCE_ALPHA):
        sourcePixelIncrement = 2;
        alphaOffset = 1;
        break;
    case(GL_RGB):
        LOG_NOTICE << "Normal map generation will only use the first encountered color channel." << std::endl;
        sourcePixelIncrement = 3;
        alphaOffset = 0;
        break;
    case(GL_RGBA):
        LOG_NOTICE << "Normal map generation will only use the first color channel." << std::endl;
        sourcePixelIncrement = 4;
        alphaOffset = 3;
        break;
    default:
        LOG_WARN << "Source pixel format not supported for normal map generation." << std::endl;
        return NULL;
    }

    osg::Image * normalmap = new osg::Image;
    normalmap->allocateImage(image->s(), image->t(), image->r(), GL_RGB, GL_UNSIGNED_BYTE);

    if (osg::getCpuByteOrder()==osg::LittleEndian) alphaOffset = sourcePixelIncrement-alphaOffset-1;
    const unsigned char ZERO = 0;

    //if (image->r() > 1) createNormalMap3D(image, normalmap, sourcePixelIncrement, alphaOffset);       // Call function for 3D images
    //else
    {
        // Function for 2D images
        float angleX, angleY;
        //for(int t=1;t<image->t()-1;++t)
        for(int t=0;t<image->t();++t)       // Rows
        {
            const unsigned char* ptr   = image->data(0,t,0)+alphaOffset;
            const unsigned char* left  = image->data(0,t,0)+alphaOffset - sourcePixelIncrement;     // Yes "-sourcePixelIncrement"! But we'll test if that's okay below
            const unsigned char* right = image->data(1,t,0)+alphaOffset;
            const unsigned char* above = t==image->t()-1 ? &ZERO : image->data(0,t+1,0)+alphaOffset;
            const unsigned char* below = t==0 ? &ZERO : image->data(0,t-1,0)+alphaOffset;

            unsigned char* destination = (unsigned char*) normalmap->data(0,t,0);

            //for(int s=1;s<image->s()-1;++s)
            for(int s=0;s<image->s();++s)       // Columns
            {
                if (s==0)
                    angleX = ( ((float)(*right)-(float)(*image->data(s+2,t,0)+alphaOffset)) / 255.f + 1.f) * osg::PI_2;     // Copy last possible gradient
                else if (s==image->s()-1)
                    angleX = ( ((float)(*image->data(s-2,t,0)+alphaOffset)-(float)(*left)) / 255.f + 1.f) * osg::PI_2;
                else
                    angleX = ( ((float)(*left)-(float)(*right)) / 255.f + 1.f) * osg::PI_2;
                if (t==0)
                    angleY = ( ((float)(*above)-(float)(*image->data(s,t+2,0)+alphaOffset)) / 255.f + 1.f) * osg::PI_2;
                else if (t==image->t()-1)
                    angleY = ( ((float)(*image->data(s,t-2,0)+alphaOffset)-(float)(*below)) / 255.f + 1.f) * osg::PI_2;
                else
                    angleY = ( ((float)(*below)-(float)(*above)) / 255.f + 1.f) * osg::PI_2;

                // Vector in spherical coordinates => cartesian coordinates
                //x = cos(angleX);
                //y = cos(angleY);
                //z = sin(angleX) * sin(angleY);
                osg::Vec3f grad(cos(angleX), cos(angleY), sin(angleX) * sin(angleY));

                grad.x() = osg::clampBetween((grad.x()+1.0f)*128.0f,0.0f,255.0f);
                grad.y() = osg::clampBetween((grad.y()+1.0f)*128.0f,0.0f,255.0f);
                grad.z() = osg::clampBetween((grad.z()+1.0f)*128.0f,0.0f,255.0f);

                *(destination++) = (unsigned char)(grad.x()); // scale and bias X.
                *(destination++) = (unsigned char)(grad.y()); // scale and bias Y.
                *(destination++) = (unsigned char)(grad.z()); // scale and bias Z.

                //*destination++ = *ptr;        // For RGBA destination

                // Pointers may be outside the image, but everything is tested
                ptr += sourcePixelIncrement;
                left += sourcePixelIncrement;
                right += sourcePixelIncrement;
                above += sourcePixelIncrement;
                below += sourcePixelIncrement;
            }
        }
    }
    
    return normalmap;
}


class CartographyColorizator {
public:
    CartographyColorizator(float valMin = 0, float valGround = 0, float valGroundI = .5f, float valMax = 1)
        : colWater0 (0x16/255.f, 0x77/255.f, 0xB4/255.f, 1),
        colWater1 (0x49/255.f, 0xA9/255.f, 0xDB/255.f, 1),
        //colGround0(.6f, .92f, .64f, 1),
        colGround0(.35f, .75f, .2f, 1),
        colGround1(.65f, .55f, .35f, 1),
        colGround2(1, 1, 1, 1),
        valMin(valMin), valGround(valGround), valGroundI(valGroundI), valMax(valMax)
    {
        ASSERT(valMin <= valGround);
        ASSERT(valGround <= valGroundI);
        ASSERT(valGroundI <= valMax);
    }


    void valsFromHF(const osg::HeightField * pHF) {
        const UINT sizeX = pHF->getNumColumns();
        const UINT sizeY = pHF->getNumRows();
        ASSERT(sizeX > 0 && sizeY > 0);

        valMin = FLT_MAX;
        valGround = FLT_MAX;
        valGroundI = FLT_MAX;
        valMax = -FLT_MAX;
        float val;

        for(UINT x=0; x<sizeX; ++x) {
            for(UINT y=0; y<sizeY; ++y) {
                val = pHF->getVertex(x, y).z();
                clampu(valMin, val);
                clampl(valMax, val);
            }
        }
        ASSERT(valMin != FLT_MAX && valMax != -FLT_MAX);
        valGround = valMin;
        valGroundI = (valGround + valMax)*.7f;
    }


    osg::Vec4f operator()(float val) {
        ASSERT(val >= valMin && val <= valMax);
        if (val < valGround) {
            // valMin-valGround (#73C9FF or 49A9DB - #1677B4)
            return colWater1;
        } else if (val < valGroundI) {
            // valGround-valGroundI : #98EAA4 - #9E864C
            return (colGround1 - colGround0) * ((val-valGround ) / (valGroundI-valGround )) + colGround0;
        } else {
            // valGround-valMax : #9E864C - #FFFFFF
            return (colGround2 - colGround1) * ((val-valGroundI) / (valMax    -valGroundI)) + colGround1;
        }
    }

//protected:
    const osg::Vec4f colWater0;
    const osg::Vec4f colWater1;
    const osg::Vec4f colGround0;
    const osg::Vec4f colGround1;
    const osg::Vec4f colGround2;

protected:
    float valMin, valGround, valGroundI, valMax;
};


osg::Image * createHeightColorization(const osg::HeightField * pHF) {
    const UINT sizeX = pHF->getNumColumns();
    const UINT sizeY = pHF->getNumRows();
    ASSERT(sizeX > 0 && sizeY > 0);

    osg::Image * pImage = new osg::Image;
    pImage->allocateImage(sizeX, sizeY, 1, GL_RGB, GL_UNSIGNED_BYTE);
    UCHAR * pDest = pImage->data();

    CartographyColorizator cc;
    cc.valsFromHF(pHF);
    osg::Vec4f color;
    for(UINT x=0; x<sizeX; ++x) {
        for(UINT y=0; y<sizeY; ++y) {
            color = cc(pHF->getVertex(y, x).z());       // x and Y are inverted
            //color = osg::Vec4f(val, val, val, 1) * -.005;     // Debug
            clamp(color.x(), 0.f, 1.f);
            clamp(color.y(), 0.f, 1.f);
            clamp(color.z(), 0.f, 1.f);
            clamp(color.w(), 0.f, 1.f);
            *(pDest++) = static_cast<UCHAR>(color.x()*255);
            *(pDest++) = static_cast<UCHAR>(color.y()*255);
            *(pDest++) = static_cast<UCHAR>(color.z()*255);
        }
    }
    return pImage;
}

#include <osg/TexGen>
#include <osg/Texture1D>
#include <osg/Material>

osg::StateSet* create1DTextureHeightColorization(const osg::HeightField * pHF)
{
    osg::Image* image = new osg::Image;
    int noPixels = 512;

    // allocate the image data, noPixels x 1 x 1 with 4 rgba floats - equivalent to a Vec4!
    image->allocateImage(noPixels,1,1,GL_RGBA,GL_FLOAT);
    image->setInternalTextureFormat(GL_RGBA);

    // fill in the image data
    CartographyColorizator cc;
    osg::Vec4* dataPtr = (osg::Vec4*)image->data();
    for(int i=0;i<noPixels;++i) {
        *(dataPtr++) = cc(i/static_cast<float>(noPixels-1));
    }

    osg::Texture1D* texture = new osg::Texture1D;
    //texture->setWrap(osg::Texture1D::WRAP_S,osg::Texture1D::CLAMP);       // Test
    texture->setWrap(osg::Texture1D::WRAP_S,osg::Texture1D::CLAMP_TO_EDGE);     // Is MIRROR better supported by older 3D chips?
    texture->setFilter(osg::Texture1D::MIN_FILTER,osg::Texture1D::LINEAR);
    texture->setFilter(osg::Texture1D::MAG_FILTER,osg::Texture1D::LINEAR);
    texture->setImage(image);

    float valMin = FLT_MAX;
    float valMax = -FLT_MAX;
    float val;
    const UINT sizeX = pHF->getNumColumns();
    const UINT sizeY = pHF->getNumRows();
    ASSERT(sizeX > 0 && sizeY > 0);
    for(UINT x=0; x<sizeX; ++x) {
        for(UINT y=0; y<sizeY; ++y) {
#if OSG_MIN_VERSION_REQUIRED(2,9,0)
            val = pHF->getVertex(x, y).z();     // Seems ok with OSG 2.9.6
#else
            val = pHF->getHeight(x, y);         // Ok for OSG 2.8??? Needs testing
#endif
            clampu(valMin, val);
            clampl(valMax, val);
        }
    }

    osg::TexGen* texgen = new osg::TexGen;
    texgen->setMode(osg::TexGen::OBJECT_LINEAR);
    float scale = 1/(valMax-valMin);
    // z = center - .5
    // z * scale + (.5-center)*scale = 0
    texgen->setPlane(osg::TexGen::S, osg::Plane(0,0, scale, .5f-(valMin+valMax)/2*scale));

    osg::Material* material = new osg::Material;
    material->setDiffuse(osg::Material::FRONT, osg::Vec4(1,1,1,1));
    material->setAmbient(osg::Material::FRONT, osg::Vec4(.1f,.1f,.1f,1));
    material->setSpecular(osg::Material::FRONT, osg::Vec4(.1f,.1f,.1f,1));
    //material->setShininess(osg::Material::FRONT, 32);

    osg::StateSet* stateset = new osg::StateSet;
    stateset->setTextureAttribute(0,texture);
    stateset->setTextureMode(0,GL_TEXTURE_1D,osg::StateAttribute::ON);
    stateset->setTextureMode(0,GL_TEXTURE_2D,osg::StateAttribute::OFF);
    stateset->setTextureMode(0,GL_TEXTURE_3D,osg::StateAttribute::OFF);

    stateset->setTextureAttribute(0,texgen);
    stateset->setTextureMode(0,GL_TEXTURE_GEN_S,osg::StateAttribute::ON);

    stateset->setAttribute(material);

    //stateset->setTextureAttribute(0,texture,osg::StateAttribute::OVERRIDE);
    //stateset->setTextureMode(0,GL_TEXTURE_1D,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);
    //stateset->setTextureMode(0,GL_TEXTURE_2D,osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE);
    //stateset->setTextureMode(0,GL_TEXTURE_3D,osg::StateAttribute::OFF|osg::StateAttribute::OVERRIDE);

    //stateset->setTextureAttribute(0,texgen,osg::StateAttribute::OVERRIDE);
    //stateset->setTextureMode(0,GL_TEXTURE_GEN_S,osg::StateAttribute::ON|osg::StateAttribute::OVERRIDE);

    //stateset->setAttribute(material,osg::StateAttribute::OVERRIDE);

    return stateset;
}


void spotLightProcessing(osg::Image * pImage, float cutoff, float exponent, float constantAttenuation, float linearAttenuation, float quadraticAttenuation, float distFactor) {
    ASSERT(pImage->getPixelFormat() == GL_RGBA);
    ASSERT(pImage->r() == 1);
    ASSERT(cutoff>=0 && cutoff<=90);
    cutoff = osg::DegreesToRadians(cutoff);

    // -- Code comes from osgvolume.cpp example, and has been slightly modified (for 2D images) --
    unsigned int alphaOffset = 0; 
    switch(pImage->getPixelFormat())
    {
    case(GL_ALPHA):
    case(GL_LUMINANCE):
        alphaOffset = 0;
        break;
    case(GL_LUMINANCE_ALPHA):
        alphaOffset = 1;
        break;
    case(GL_RGBA):
        alphaOffset = 3;
        break;
    default:
        LOG_NOTICE << "Source pixel format not supported for spotlight map generation." << std::endl;
        return;
    }

    osg::Image * normalmap = new osg::Image;
    //normalmap->allocateImage(pImage->s(), pImage->t(), pImage->r(), GL_RGBA, GL_UNSIGNED_BYTE);

    //if (osg::getCpuByteOrder()==osg::LittleEndian) alphaOffset = sourcePixelIncrement-alphaOffset-1;

    //osg::Vec2f center((pImage->s()+1)/2, pImage->t()-1);
    osg::Vec2f center((pImage->s()+1)/2, 0);
    float dist, cosAngle, angle;
    distFactor /= pImage->t();
    for(int t=0;t<pImage->t();++t)
    {
        unsigned char* destination = pImage->data(0,t,0);
        for(int s=0;s<pImage->s();++s) {
            osg::Vec2f pos(s, t);
            osg::Vec2f dir(pos - center);
            dist = dir.length();
            if (dist > 0) {
                cosAngle = (dir/dist) * osg::Vec2f(0,1);
                angle = acosf(cosAngle);
            } else {
                cosAngle = 1;
                angle = 0;
            }
            ASSERT(angle>=0);

            destination += alphaOffset;
            if (angle > cutoff)
                *destination = 0;       // Cut off
            else {
                dist *= distFactor;
                *destination = static_cast<UCHAR>( clamp_copy(
                    1/(constantAttenuation + linearAttenuation * dist + quadraticAttenuation * dist*dist)           // Attenuations
                    * powf(cosAngle, exponent)          // Spot exponent
                    , 0.f, 1.f) * 255.f );
            }
            destination += pImage->getPixelSizeInBits()/8-alphaOffset;
        }
    }
}


osg::GraphicsContext::ScreenSettings getClosestFullscreenResolution(const osg::GraphicsContext::ScreenIdentifier & si, const osg::GraphicsContext::ScreenSettings & resolution) {
    osg::GraphicsContext::WindowingSystemInterface *wsi = osg::GraphicsContext::getWindowingSystemInterface();
    ASSERT(wsi);
    osg::GraphicsContext::ScreenSettingsList list;
    wsi->enumerateScreenSettings(si, list);

    // 1. Find closest (x,y) resolution (no refresh rate or depth) + remove those with less color depth
    int bestX=0, bestY=0, bestDelta=INT_MAX, curDelta;
    BOOST_FOREACH(const osg::GraphicsContext::ScreenSettings & curRes, list) {
        if (curRes.colorDepth < resolution.colorDepth) continue;
        if (curRes.width == resolution.width && curRes.height == resolution.height) {
            // Exact resolution match
            if (curRes.colorDepth == resolution.colorDepth && curRes.colorDepth == resolution.colorDepth)
                return resolution;      // Full match
            bestX = curRes.width;
            bestY = curRes.height;
            break;
        } else {
            curDelta = abs(curRes.width - resolution.width) + abs(curRes.height - resolution.height);
            if (curDelta < bestDelta || (curDelta == bestDelta && bestX && bestY && curRes.width > bestX && curRes.height > bestY)) {
                // Better resolution found
                bestDelta = curDelta;
                bestX = curRes.width;
                bestY = curRes.height;
            }
        }
    }
    if (bestX==0 || bestY==0) {
        LOG_NOTICE << "Can't find fullscreen resolution close to " << resolution << ".";
        return osg::GraphicsContext::ScreenSettings();
    }

    // 2. Find closest color depth
    UINT bestDepth=0, bestDepthDelta=UINT_MAX, curDepthDelta;
    BOOST_FOREACH(const osg::GraphicsContext::ScreenSettings & curRes, list) {
        if (curRes.colorDepth < resolution.colorDepth) continue;
        if (curRes.width != bestX || curRes.height != bestY) continue;
        curDepthDelta = abs(static_cast<int>(curRes.colorDepth) - static_cast<int>(resolution.colorDepth));
        if (curDepthDelta == 0) {
            // Exact resolution match
            bestDepth = curRes.colorDepth;
            break;
        } else {
            if (curDepthDelta < bestDepthDelta || (curDepthDelta == bestDepthDelta && bestDepth && curRes.colorDepth > bestDepth)) {
                // Better resolution found
                bestDepthDelta = curDepthDelta;
                bestDepth = curRes.colorDepth;
            }
        }
    }
    if (bestDepth==0) {
        LOG_NOTICE << "Can't find fullscreen resolution close to " << resolution << ".";
        return osg::GraphicsContext::ScreenSettings();
    }

    // 3. Find the highest refresh rate
    double bestRate=0;
    const osg::GraphicsContext::ScreenSettings * pBest = NULL;
    BOOST_FOREACH(const osg::GraphicsContext::ScreenSettings & curRes, list) {
        if (curRes.colorDepth < resolution.colorDepth) continue;
        if (curRes.width != bestX || curRes.height != bestY) continue;
        if (curRes.colorDepth != bestDepth) continue;
        if (curRes.refreshRate > bestRate) {
            bestRate = curRes.refreshRate;
            pBest = &curRes;
        }
    }
    if (!pBest) {
        LOG_NOTICE << "Can't find fullscreen resolution close to " << resolution << ".";
        return osg::GraphicsContext::ScreenSettings();
    }

    return *pBest;
}


std::ostream& operator<<(std::ostream& stream, const osg::GraphicsContext::ScreenSettings& settings) {
    stream << settings.width << "x" << settings.height << ", " << settings.refreshRate << " Hz, " << settings.colorDepth << " bits";
    return stream;
}


namespace osgDB {
    osg::Image * readImageFile(const boost::filesystem::path & path, const osgDB::ReaderWriter::Options* options) {
        osg::Image * p = osgDB::readImageFile(path.native_file_string(), options);
        if (!p) THROW_TRACED_EXCEPTION("Could not load " + path.string());
        return p;
    }
    osg::Image * readImageFile(const boost::filesystem::path & path) {
        osg::Image * p = osgDB::readImageFile(path.native_file_string());
        if (!p) THROW_TRACED_EXCEPTION("Could not load " + path.string());
        return p;
    }

    void writeImageFile(const osg::Image & image, const boost::filesystem::path & path) {
        if (!osgDB::writeImageFile(image, path.native_file_string())) THROW_TRACED_EXCEPTION("Could not write " + path.string());
    }

    osg::Node * readNodeFile(const boost::filesystem::path & path, const osgDB::ReaderWriter::Options* options) {
        osg::Node * p = osgDB::readNodeFile(path.native_file_string(), options);
        if (!p) THROW_TRACED_EXCEPTION("Could not load " + path.string());
        return p;
    }

    osg::Node * readNodeFile(const boost::filesystem::path & path) {
        osg::Node * p = osgDB::readNodeFile(path.native_file_string());
        if (!p) THROW_TRACED_EXCEPTION("Could not load " + path.string());
        return p;
    }

    void writeNodeFile(const osg::Node & node, const boost::filesystem::path & path) {
        if (!osgDB::writeNodeFile(node, path.native_file_string())) THROW_TRACED_EXCEPTION("Could not write " + path.string());
    }

}   // namespace osgDB

---