Utility3D.h

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.
//
//-----------------------------------------------------------------------------------


#ifndef _3D_UTILITY_H
#define _3D_UTILITY_H

#include <PVLE/Export.h>
#include <osg/Node>
#include <osg/NodeCallback>

#include <osg/Vec3f>
#include <osg/Vec4f>
#include <osg/Vec3d>
#include <osg/Vec4d>
#include <osg/Quat>

namespace osg {
    class Image;
    class HeightField;

    inline Vec3f operator* (const Vec3f & v, const Quat & q) { return q*v; }
    inline Vec3d operator* (const Vec3d & v, const Quat & q) { return q*v; }
    inline Vec4f operator* (const Vec4f & v, const Quat & q) { return v*Matrixf(q); }
    inline Vec4d operator* (const Vec4d & v, const Quat & q) { return v*Matrixd(q); }
}

inline osg::Vec3f invertY(const osg::Vec3f & v) { return osg::Vec3f(v.x(), -v.y(), v.z()); }
inline osg::Vec3d invertY(const osg::Vec3d & v) { return osg::Vec3d(v.x(), -v.y(), v.z()); }
inline osg::Vec4f invertY(const osg::Vec4f & v) { return osg::Vec4f(v.x(), -v.y(), v.z(), v.w()); }
inline osg::Vec4d invertY(const osg::Vec4d & v) { return osg::Vec4d(v.x(), -v.y(), v.z(), v.w()); }

inline osg::Vec3f multX(const osg::Vec3f & v, float r)  { return osg::Vec3f(v.x()*r, v.y(), v.z()); }
inline osg::Vec3d multX(const osg::Vec3d & v, double r) { return osg::Vec3d(v.x()*r, v.y(), v.z()); }
inline osg::Vec4f multX(const osg::Vec4f & v, float r)  { return osg::Vec4f(v.x()*r, v.y(), v.z(), v.w()); }
inline osg::Vec4d multX(const osg::Vec4d & v, double r) { return osg::Vec4d(v.x()*r, v.y(), v.z(), v.w()); }

inline osg::Vec3f multY(const osg::Vec3f & v, float r)  { return osg::Vec3f(v.x(), v.y()*r, v.z()); }
inline osg::Vec3d multY(const osg::Vec3d & v, double r) { return osg::Vec3d(v.x(), v.y()*r, v.z()); }
inline osg::Vec4f multY(const osg::Vec4f & v, float r)  { return osg::Vec4f(v.x(), v.y()*r, v.z(), v.w()); }
inline osg::Vec4d multY(const osg::Vec4d & v, double r) { return osg::Vec4d(v.x(), v.y()*r, v.z(), v.w()); }

inline osg::Vec3f multZ(const osg::Vec3f & v, float r)  { return osg::Vec3f(v.x(), v.y(), v.z()*r); }
inline osg::Vec3d multZ(const osg::Vec3d & v, double r) { return osg::Vec3d(v.x(), v.y(), v.z()*r); }
inline osg::Vec4f multZ(const osg::Vec4f & v, float r)  { return osg::Vec4f(v.x(), v.y(), v.z()*r, v.w()); }
inline osg::Vec4d multZ(const osg::Vec4d & v, double r) { return osg::Vec4d(v.x(), v.y(), v.z()*r, v.w()); }

inline osg::Vec4f multW(const osg::Vec4f & v, float r)  { return osg::Vec4f(v.x(), v.y(), v.z(), v.w()*r); }
inline osg::Vec4d multW(const osg::Vec4d & v, double r) { return osg::Vec4d(v.x(), v.y(), v.z(), v.w()*r); }


inline osg::Vec3f toVec3(const osg::Vec4f & v) { return osg::Vec3f(v.x(), v.y(), v.z()); }
inline osg::Vec3d toVec3(const osg::Vec4d & v) { return osg::Vec3d(v.x(), v.y(), v.z()); }


PVLE_EXPORT float  computeAngle(const osg::Vec3f & v1, const osg::Vec3f & v2, const osg::Vec3f reference);
PVLE_EXPORT double computeAngle(const osg::Vec3d & v1, const osg::Vec3d & v2, const osg::Vec3d reference);

//PVLE_EXPORT void removeUpdateCallback(osg::Node & node, osg::NodeCallback * pCB) { node.removeUpdateCallback(pCB); }
//PVLE_EXPORT void addUpdateCallback(osg::Node & node, osg::NodeCallback * pCB) { node.addUpdateCallback(pCB); }

PVLE_EXPORT bool hasUpdateCallbackType(const osg::Node & node, const std::type_info & type);

PVLE_EXPORT osg::Image * createNormalMap(const osg::Image* image);

PVLE_EXPORT osg::Image * createHeightColorization(const osg::HeightField * pHF);

PVLE_EXPORT osg::StateSet* create1DTextureHeightColorization(const osg::HeightField * pHF);

PVLE_EXPORT void spotLightProcessing(osg::Image * pImage, float cutoff, float exponent, float constantAttenuation, float linearAttenuation, float quadraticAttenuation, float distFactor);

inline osg::Vec4::value_type luminance(const osg::Vec4 & color) { return (color.x() + color.y() + color.z()) / 3.f * color.w(); }


#include <osg/GraphicsContext>

PVLE_EXPORT osg::GraphicsContext::ScreenSettings getClosestFullscreenResolution(const osg::GraphicsContext::ScreenIdentifier & si, const osg::GraphicsContext::ScreenSettings & resolution);
PVLE_EXPORT std::ostream& operator<<(std::ostream& stream, const osg::GraphicsContext::ScreenSettings& settings);


#include <boost/filesystem/path.hpp>
#include <osgDB/ReaderWriter>

namespace osgDB {
    PVLE_EXPORT osg::Image * readImageFile(const boost::filesystem::path & path, const osgDB::ReaderWriter::Options* options);
    PVLE_EXPORT osg::Image * readImageFile(const boost::filesystem::path & path);
    PVLE_EXPORT void writeImageFile(const osg::Image & image, const boost::filesystem::path & path);

    PVLE_EXPORT osg::Node * readNodeFile(const boost::filesystem::path & path, const osgDB::ReaderWriter::Options* options);
    PVLE_EXPORT osg::Node * readNodeFile(const boost::filesystem::path & path);
    PVLE_EXPORT void writeNodeFile(const osg::Node & node, const boost::filesystem::path & path);
}


#endif  // _3D_UTILITY_H

---