Commons.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/Commons.h>
#include <PVLE/3D/Utility3D.h>

#include <osg/Vec4>
#include <osg/Geode>
#include <osg/Drawable>
#include <osg/Texture2D>
#include <osg/Image>
#include <osg/ShapeDrawable>
#include <osg/CullFace>
#include <osg/MatrixTransform>
#include <osg/Projection>
#include <osg/Material>

#include <osgDB/ReadFile>

#include <osg/Geometry>
#include <osg/LineWidth>

#include <osgText/Text>

#include <osg/BlendFunc>
#include <osg/Depth>

#include <boost/cast.hpp>

#include <PVLE/3D/MoveWithEyePointTransform.h>
#include <PVLE/Util/TracedException.h>
#include <PVLE/Util/Util.h>
#include <PVLE/Util/Rand.h>


osg::Transform * createSkySphere(const boost::filesystem::path & texturePath, float detailRatio) {
    osg::ref_ptr<osg::Transform> pSkyTransform = new MoveWithEyePointTransform;
    pSkyTransform->setCullingActive(false);     // Avoids culling to remove the sky :)

    osg::ref_ptr<osg::Geode> pSky = new osg::Geode;
    pSkyTransform->addChild(pSky);

    osg::ref_ptr<osg::TessellationHints> pTH = new osg::TessellationHints();
    pTH->setCreateBackFace(false);
    pTH->setCreateNormals(false);
    pTH->setDetailRatio(detailRatio);
    osg::ref_ptr<osg::ShapeDrawable> pShapeDrawable = new osg::ShapeDrawable(new osg::Sphere(osg::Vec3(0,0,0), 1), pTH);
    pShapeDrawable->setColor(osg::Vec4f(1,1,1,1));
    pSky->addDrawable(pShapeDrawable);

    osg::StateSet * pStateset = pSky->getOrCreateStateSet();

    osg::ref_ptr<osg::Image> pImage = osgDB::readImageFile(texturePath);
    osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
    texture->setImage(pImage);
    texture->setWrap(osg::Texture2D::WRAP_S,osg::Texture2D::REPEAT);        // Texture is supposed to be cyclic
    texture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);  // No mipmaps for the sky (it's always at the same distance). It could increase performance and/or visual quality but I (Sukender) guess keeping the original texture is the best for the sky.
    texture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);

    pStateset->setTextureAttributeAndModes(0, texture);

    pStateset->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
    pStateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
    pStateset->setAttribute(new osg::CullFace(osg::CullFace::BACK));
    pStateset->setRenderBinDetails(-1, "RenderBin");        // Render before everything else

    return pSkyTransform.release();
}


osg::Geometry * createAxisDrawable(const osg::Vec3& corner, const osg::Vec3& xdir, const osg::Vec3& ydir, const osg::Vec3& zdir) {
    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;

    osg::ref_ptr<osg::Vec3Array> coords = new osg::Vec3Array(6);
    (*coords)[0] = corner;  (*coords)[1] = corner+xdir;
    (*coords)[2] = corner;  (*coords)[3] = corner+ydir;
    (*coords)[4] = corner;  (*coords)[5] = corner+zdir;
    geom->setVertexArray(coords);

    osg::ref_ptr<osg::Vec4Array> color = new osg::Vec4Array(3);
    (*color)[0] = osg::Vec4(1,0,0,1);
    (*color)[1] = osg::Vec4(0,1,0,1);
    (*color)[2] = osg::Vec4(0,0,1,1);
    geom->setColorArray(color);
    geom->setColorBinding(osg::Geometry::BIND_PER_PRIMITIVE);

    geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES,0,6));

    osg::StateSet* pStateset = geom->getOrCreateStateSet();
    pStateset->setAttributeAndModes(new osg::LineWidth(3));
    pStateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);

    return geom.release();
}


osg::Geometry * createSegmentDrawable(const osg::Vec3 & p1, const osg::Vec3 & p2, float width, const osg::Vec4 & color1, const osg::Vec4 & color2) {
    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;

    osg::ref_ptr<osg::Vec3Array> coords = new osg::Vec3Array(2);
    (*coords)[0] = p1;
    (*coords)[1] = p2;
    geom->setVertexArray(coords);

    if (color1 == color2 || color2 == osg::Vec4(-1,-1,-1,-1)) {
        osg::ref_ptr<osg::Vec4Array> color = new osg::Vec4Array(1);
        (*color)[0] = color1;
        geom->setColorArray(color);
        geom->setColorBinding(osg::Geometry::BIND_OVERALL);
    } else {
        osg::ref_ptr<osg::Vec4Array> color = new osg::Vec4Array(2);
        (*color)[0] = color1;
        (*color)[1] = color2;
        geom->setColorArray(color);
        geom->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
    }

    geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES,0,2));

    osg::ref_ptr<osg::StateSet> pStateset = new osg::StateSet;
    osg::ref_ptr<osg::LineWidth> linewidth = new osg::LineWidth;
    linewidth->setWidth(width);
    pStateset->setAttributeAndModes(linewidth,osg::StateAttribute::ON);
    pStateset->setMode(GL_LIGHTING,osg::StateAttribute::OFF);
    geom->setStateSet(pStateset);

    return geom.release();
}


osg::Geode * createAxis(float axisSize) {
    osg::ref_ptr<osg::Geode> axis = new osg::Geode;
    axis->addDrawable(createAxisDrawable(osg::Vec3(0,0,0), osg::Vec3(axisSize,0,0), osg::Vec3(0,axisSize,0), osg::Vec3(0,0,axisSize)));
    return axis.release();
}

osg::Geode * createSegment(const osg::Vec3 & p1, const osg::Vec3 & p2, float width, const osg::Vec4 & color1, const osg::Vec4 & color2) {
    osg::ref_ptr<osg::Geode> axis = new osg::Geode;
    axis->addDrawable(createSegmentDrawable(p1, p2, width, color1, color2));
    return axis.release();
}

osg::Geometry* createSquare(const osg::Vec3& corner, const osg::Vec3& width, const osg::Vec3& height, osg::Image* image, UINT nbTextureCoords, bool invertYTexCoords) {
    // Set up the Geometry.
    osg::ref_ptr<osg::Geometry> geom = new osg::Geometry;

    osg::ref_ptr<osg::Vec3Array> coords = new osg::Vec3Array(4);
    (*coords)[0] = corner;
    (*coords)[1] = corner+width;
    (*coords)[2] = corner+width+height;
    (*coords)[3] = corner+height;
    geom->setVertexArray(coords);

    osg::ref_ptr<osg::Vec3Array> norms = new osg::Vec3Array(1);
    (*norms)[0] = width^height;
    (*norms)[0].normalize();
    geom->setNormalArray(norms);
    geom->setNormalBinding(osg::Geometry::BIND_OVERALL);

#if 0
    // Test code
    osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array(1);
    (*colors)[0] = osg::Vec4(1,1,1,1);
    geom->setColorArray(colors);
    geom->setColorBinding(osg::Geometry::BIND_OVERALL);
#else
    geom->setColorBinding(osg::Geometry::BIND_OFF);
#endif

    for (UINT i=0; i<nbTextureCoords; ++i) {
        osg::ref_ptr<osg::Vec2Array> tcoords = new osg::Vec2Array(4);
        (*tcoords)[0].set(0.0f, invertYTexCoords ? 1 : 0);
        (*tcoords)[1].set(1.0f, invertYTexCoords ? 1 : 0);
        (*tcoords)[2].set(1.0f, invertYTexCoords ? 0 : 1);
        (*tcoords)[3].set(0.0f, invertYTexCoords ? 0 : 1);
        geom->setTexCoordArray(i, tcoords);
    }

    geom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::QUADS,0,4));

    if (image) {
        osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D(image);
        texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);        // REPEAT seems also okay for simple applications
        texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
        texture->setFilter(osg::Texture::MIN_FILTER,osg::Texture::LINEAR);
        texture->setFilter(osg::Texture::MAG_FILTER,osg::Texture::LINEAR);

        geom->getOrCreateStateSet()->setTextureAttributeAndModes(0, texture, osg::StateAttribute::ON);
    }

    return geom.release();
}


void updateSquare(osg::Geometry * pGeometry, const osg::Vec3& width, const osg::Vec3& height) {
    osg::Vec3Array * pArray = boost::polymorphic_downcast<osg::Vec3Array *>(pGeometry->getVertexArray());
    updateSquare(pGeometry, (*pArray)[0], width, height);
}


void updateSquare(osg::Geometry * pGeometry, const osg::Vec3& corner, const osg::Vec3& width, const osg::Vec3& height) {
    osg::Vec3Array * pArray = boost::polymorphic_downcast<osg::Vec3Array *>(pGeometry->getVertexArray());
    (*pArray)[0] = corner;              // Useless for most applications of progress bars, but cleaner
    (*pArray)[1] = corner+width;
    (*pArray)[2] = corner+width+height;
    (*pArray)[3] = corner+height;       // Useless too :)
    pArray->dirty();
    pGeometry->dirtyBound();
}


std::pair<osg::Projection*, osg::MatrixTransform*> create2DProjection(const osg::Matrix & orthoProjectionMatrix) {
    osg::ref_ptr<osg::Projection> pProjection = new osg::Projection;
    pProjection->setMatrix(orthoProjectionMatrix);

    osg::ref_ptr<osg::MatrixTransform> pNoTransformMatrix = new osg::MatrixTransform;
    pProjection->addChild(pNoTransformMatrix);
    pNoTransformMatrix->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
    pNoTransformMatrix->setMatrix(osg::Matrix::identity());

    return std::make_pair(pProjection.release(), pNoTransformMatrix.release());
}


osg::Projection * encapsulateIn2DProjection(osg::Node * pNode, const osg::Matrix & orthoProjectionMatrix) {
    std::pair<osg::ref_ptr<osg::Projection>, osg::ref_ptr<osg::MatrixTransform> > proj = create2DProjection(orthoProjectionMatrix);
    proj.second->addChild(pNode);
    return proj.first.release();
}


void setHudStatset(osg::StateSet * pStateset) {
    // Turn lighting off for the text and disable depth test to ensure its always ontop.
    pStateset->setMode(GL_LIGHTING, osg::StateAttribute::OFF);

    // Disable depth test, and make sure that is is drawn after everything else so that it always appears on top.
    pStateset->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
    pStateset->setRenderBinDetails(11,"RenderBin");
}


void setColor(osg::StateSet * pStateSet, const osg::Vec4 & color) {
    ASSERT(pStateSet);
    osg::ref_ptr<osg::Material> pMaterial = boost::polymorphic_downcast<osg::Material *>(pStateSet->getAttribute(osg::StateAttribute::MATERIAL));
    if (!pMaterial) pMaterial = new osg::Material();
    pMaterial->setDiffuse(osg::Material::FRONT_AND_BACK, color);
    pMaterial->setAmbient(osg::Material::FRONT_AND_BACK, osg::Vec4(color.x()/2.f, color.y()/2.f, color.z()/2.f, color.w()));
    //pMaterial->setColorMode(osg::Material::AMBIENT_AND_DIFFUSE);
    pStateSet->setAttributeAndModes(pMaterial);
}

void setColor(osg::Node * pNode, const osg::Vec4 & color) {
    ASSERT(pNode);
    setColor(pNode->getOrCreateStateSet(), color);
}



osg::MatrixTransform * createShapeGeode(osg::Shape * shape, float tesselationDetailRatio) {
    osg::ref_ptr<osg::MatrixTransform> pMat = new osg::MatrixTransform();
    osg::ref_ptr<osg::Geode> pGeode = new osg::Geode;
    pMat->addChild(pGeode);
    if (tesselationDetailRatio == 0) {
        pGeode->addDrawable(new osg::ShapeDrawable(shape));
    } else {
        osg::ref_ptr<osg::TessellationHints> th = new osg::TessellationHints();
        th->setDetailRatio(tesselationDetailRatio);
        pGeode->addDrawable(new osg::ShapeDrawable(shape, th));
    }
    return pMat.release();
}

osg::MatrixTransform * createShapeGeodeBox(const osg::Vec3 & size/*, float tesselationDetailRatio*/) { return createShapeGeode(new osg::Box(osg::Vec3(0,0,0), size.x(), size.y(), size.z()), 0); }
osg::MatrixTransform * createShapeGeodeSphere(const float radius, float tesselationDetailRatio) { return createShapeGeode(new osg::Sphere(osg::Vec3(0,0,0), radius), tesselationDetailRatio); }
osg::MatrixTransform * createShapeGeodeCapsule(const float radius, const float length, float tesselationDetailRatio) { return createShapeGeode(new osg::Capsule(osg::Vec3(0,0,0), radius, length), tesselationDetailRatio); }
osg::MatrixTransform * createShapeGeodeCylinder(const float radius, const float length, float tesselationDetailRatio) { return createShapeGeode(new osg::Cylinder(osg::Vec3(0,0,0), radius, length), tesselationDetailRatio); }


osg::HeightField * readHeightMap(const boost::filesystem::path & path, const float vScale, const float hScale) {
    osg::ref_ptr<osg::Image> pImage = osgDB::readImageFile(path);
    if (!pImage.valid()) THROW_TRACED_FMT_EXCEPTION("Height map loading failed: %1%", path);
    unsigned int numColumns   = pImage->s();
    unsigned int numRows      = pImage->t();
    if (numColumns <3 || numRows <3) THROW_TRACED_EXCEPTION("Height map is too small");
    unsigned int depth        = pImage->getPixelSizeInBits() /8;
    unsigned int rowAlignment = pImage->getRowSizeInBytes() - numColumns*depth;

    osg::ref_ptr<osg::HeightField> pHF = new osg::HeightField();
    pHF->allocate(numColumns,numRows);
      pHF->setOrigin(osg::Vec3(-hScale/2,-hScale/2,-256*vScale));
      pHF->setXInterval(hScale/static_cast<float>(numColumns-1));
      pHF->setYInterval(hScale/static_cast<float>(numRows-1));

    const unsigned char * p = pImage->data();
    for(unsigned int r=0; r<numRows; ++r) {
        for(unsigned int c=0;c<numColumns;++c) {
            pHF->setHeight(c,r,(*p)*vScale);
            p += depth;
        }
        p += rowAlignment;
    }
    return pHF.release();
}


osgText::Text * createText(osgText::Font * pFont, float height, const osg::Vec3f & position, const osg::Vec4f & color) {
    osg::ref_ptr<osgText::Text> pText = new osgText::Text;
    pText->setFont(pFont);
    pText->setCharacterSize(height);
    pText->setColor(color);
    pText->setPosition(position);
    //pText->setFontResolution(64, 64);     // Default size for PVLE
    return pText.release();
}


CloudParams::CloudParams() :
    numSprites(100),
    axis(0,0,1),
    lowColor(.5f,.5f,.5f,1), hiColor(1,1,1,.7f),
    alphaOffsetMin(-.5f), alphaOffsetMax(-.2f),
    skewVMin(.05f), skewVMax(.7f),
    skewHMin(.3f), skewHMax(1.f),
    colorScaleRand(.1f)
{
    ratio = rand(2, 7);
    float densityBase = rand(.5f, 1.5f);
    density = densityBase * 5e-6f;
    spriteSizeMin = 150 / densityBase;
    spriteSizeMax = 200 / densityBase;
}


osg::Geode * createCloud(const boost::filesystem::path & imagePath, unsigned int numSprites) {
    CloudParams params;
    params.numSprites = numSprites;
    params.imagePath = imagePath;
    return createCloud(params);
}

osg::Geode * createCloud(const CloudParams & p) {
    // Put points in a box proportional to (ratio,ratio,1)
    // density = numSprites / (height * height*ratio * height*ratio)
    // density = numSprites / (height^3 * ratio^2)
    // height^3 * ratio^2 = numSprites / density
    // height = (numSprites / density / ratio^2) ^ (1/3)
    const float height = powf(p.numSprites / p.density / (p.ratio*p.ratio), 1/3.f);
    const float spriteSize = rand(p.spriteSizeMin, p.spriteSizeMax);
    const float spriteSize_2 = spriteSize/2.f;

    osg::ref_ptr<osg::Geode> geode = new osg::Geode;            // Container for cloud elements
    //osg::Matrix cloudRotate( osg::Matrix::rotate(rand(-osg::PI, osg::PI), osg::Vec3(rand(-.1f, .1f), rand(-.1f, .1f), 1)) );
    osg::Matrix cloudRotate( osg::Matrix::rotate(rand(0, 2*osg::PI), osg::Z_AXIS) );        // General rotation (to make skewH to a random axis instead of always X)

    for (unsigned i=0; i<p.numSprites; ++i) {
        float skewV = rand(p.skewVMin, p.skewVMax);
        float skewH = rand(p.skewHMin, p.skewHMax);
        float z = rand(0, sqrtf(height));   z*=z;       // Make distribution to be non linear (z = rand(0, sqrt(h))²): less particles towards the top
        float angle = rand(0, 2*osg::PI);
        float dist = rand(0, (height-z*skewV) *p.ratio*.5f);
        // Make position depending on dis, angle and skewH, and then rotate the point around the center of the cloud by 'cloudRotate'
        osg::Vec3f pos(
            toVec3(
                osg::Vec4f(dist*cos(angle), dist*sin(angle)*skewH, z, 1) * cloudRotate
            )
        );

        // Make each sprite non aligned with others, by applying a random rotation around Z, and then apply the user rotation to face the right direction
        osg::Matrix mat( osg::Matrix::rotate(rand(0, 2*osg::PI), osg::Z_AXIS) * osg::Matrix::rotate(osg::Z_AXIS, p.axis) );
        osg::Geometry * geometry = createSquare(pos - osg::Vec3(spriteSize_2, spriteSize_2, 0)*mat, osg::Vec3(spriteSize, 0, 0)*mat, osg::Vec3(0, spriteSize, 0)*mat, osgDB::readImageFile(p.imagePath) );
        geode->addDrawable( geometry );

        // Set color
        float coefHiColor = osg::clampBetween(z/height + rand(-p.colorScaleRand, p.colorScaleRand), 0.f, 1.f);
        osg::ref_ptr<osg::Vec4Array> colors = new osg::Vec4Array(1);
        (*colors)[0] = p.lowColor*(1-coefHiColor) + p.hiColor*coefHiColor;
        (*colors)[0].w() = osg::clampBetween((*colors)[0].w() + rand(p.alphaOffsetMin, p.alphaOffsetMax), 0.f, 1.f);
        geometry->setColorArray(colors);
        geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
    }
    osg::StateSet *set = geode->getOrCreateStateSet();

    // Disable lighting
    set->setMode(GL_LIGHTING, osg::StateAttribute::OFF);

    set->setAttributeAndModes(new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA));  // Alpha
    set->setAttributeAndModes(new osg::Depth(osg::Depth::LEQUAL, 0, 1, false));                                     // Draw "Less or equal"
    set->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);                                                          // Draw back to front

    return geode.release();
}

---