osg::Vec3 ConfigManager::getVec3(std::string attributeX, std::string attributeY,
std::string attributeZ, std::string path, osg::Vec3 def, bool * found)
{
bool hasEntry = false;
bool isFound;
osg::Vec3 result;
result.x() = getFloat(attributeX,path,def.x(),&isFound);
if(isFound)
{
hasEntry = true;
}
result.y() = getFloat(attributeY,path,def.y(),&isFound);
if(isFound)
{
hasEntry = true;
}
result.z() = getFloat(attributeZ,path,def.z(),&isFound);
if(isFound)
{
hasEntry = true;
}
if(found)
{
*found = hasEntry;
}
return result;
}
void PanoDrawableLOD::setZoom(osg::Vec3 dir, float k)
{
for(std::map<int,sph_model*>::iterator it = _pdi->modelMap.begin(); it!= _pdi->modelMap.end(); it++)
{
it->second->set_zoom(dir.x(),dir.y(),dir.z(),k);
}
}
osg::Vec2 calcCoordReprojTrans(const osg::Vec3 &vert,const osg::Matrix &trans,const osg::Matrix &viewProj,const osg::Vec2 &size,const osg::Vec4 &ratio){
osg::Vec4 v(vert.x(),vert.y(),vert.z(),1.0);
v=v*trans;
v=v*viewProj;
v.x() /= v.w();
v.y() /= v.w();
v.z() /= v.w();
v.w() /= v.w();
//std::cout << "Pre shift " << v << std::endl;
v.x() /= size.x();;
v.y() /= size.y();
v.x() -= (ratio.x()/size.x());
v.y() -= (ratio.y()/size.y());
//std::cout << "Post shift " << v << std::endl;
// std::cout << "PP shift " << v << std::endl;
osg::Vec2 tc(v.x(),v.y());
tc.x() *= ratio.z();
tc.y() *=ratio.w();
//tc.x()*=ratio.x();
//tc.y()*=ratio.y();
tc.x()/=(ratio.z());
tc.y()/=(ratio.w());
return tc;
}
bool HeightFieldLayer::getValue(unsigned int i, unsigned int j, osg::Vec3& value) const
{
value.x() = _heightField->getHeight(i,j);
value.y() = _defaultValue.y();
value.z() = _defaultValue.z();
return true;
}
void addEdgePlane(const osg::Vec3& corner, const osg::Vec3& edge)
{
osg::Vec3 normal( edge.y(), -edge.x(), 0.0f);
normal.normalize();
add(osg::Plane(normal, corner));
}
void setMinMax(const osg::Vec3& pos)
{
_maxY = std::max(_maxY, (double) pos.y());
_minY = std::min(_minY, (double) pos.y());
_maxX = std::max(_maxX, (double) pos.x());
_minX = std::min(_minX, (double) pos.x());
}
double MultitouchNavigation::angleBetween3DVectors(osg::Vec3 v1, osg::Vec3 v2)
{
// http://codered.sat.qc.ca/redmine/projects/spinframework/repository/revisions/b6245189c19a7c6ba4fdb126940321c41c44e228/raw/src/spin/osgUtil.cpp
// normalize vectors (note: this must be done alone, not within any vector arithmetic. why?!)
v1.normalize();
v2.normalize();
// Get the dot product of the vectors
double dotProduct = v1 * v2;
// for acos, the value has to be between -1.0 and 1.0, but due to numerical imprecisions it sometimes comes outside this range
if (dotProduct > 1.0)
dotProduct = 1.0;
if (dotProduct < -1.0)
dotProduct = -1.0;
// Get the angle in radians between the 2 vectors (should this be -acos ? ie, negative?)
double angle = acos(dotProduct);
// Here we make sure that the angle is not a -1.#IND0000000 number, which means indefinite
if (std::isnan(angle)) //__isnand(x)
return 0;
// Return the angle in radians
return (angle);
}
osg::Quat makeQuat(const osg::Vec3& radians, ERotationOrder fbxRotOrder)
{
fbxDouble3 degrees(
osg::RadiansToDegrees(radians.x()),
osg::RadiansToDegrees(radians.y()),
osg::RadiansToDegrees(radians.z()));
return makeQuat(degrees, fbxRotOrder);
}
osg::Vec3 Particle_Viewer::fixPosition(osg::Vec3 position)
{
osg::Vec3 fixPosition;
fixPosition.x()=position.x();
fixPosition.y()=position.z();
fixPosition.z()=position.y();
return fixPosition;
}
float HfT_osg_Plugin01_ParametricSurface::abstand(osg::Vec3 startPickPos, int i)
{
float x = (*mp_Points_Geom)[i].x() - startPickPos.x();
float y = (*mp_Points_Geom)[i].y() - startPickPos.y();
float z = (*mp_Points_Geom)[i].z() - startPickPos.z();
float abst = (float)sqrt(x * x + y * y + z * z);
return abst;
}
bool Uniform::getElement( unsigned int index, osg::Vec3& v3 ) const
{
if( index>=getNumElements() || !isCompatibleType(FLOAT_VEC3) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
v3.x() = (*_floatArray)[j];
v3.y() = (*_floatArray)[j+1];
v3.z() = (*_floatArray)[j+2];
return true;
}
void DataOutputStream::writeVec3(const osg::Vec3& v){
// std::cout << "write " << _ostream->tellp() << std::endl;
writeFloat(v.x());
writeFloat(v.y());
writeFloat(v.z());
if (_verboseOutput) std::cout<<"read/writeVec3() ["<<v<<"]"<<std::endl;
}
void osgParticle::Particle::render(osg::RenderInfo& renderInfo, const osg::Vec3& xpos, const osg::Vec3& xrot) const
{
#if defined(OSG_GL_MATRICES_AVAILABLE)
if (_drawable.valid())
{
bool requiresRotation = (xrot.x()!=0.0f || xrot.y()!=0.0f || xrot.z()!=0.0f);
glColor4f(_current_color.x(),
_current_color.y(),
_current_color.z(),
_current_color.w() * _current_alpha);
glPushMatrix();
glTranslatef(xpos.x(), xpos.y(), xpos.z());
if (requiresRotation)
{
osg::Quat rotation(xrot.x(), osg::X_AXIS, xrot.y(), osg::Y_AXIS, xrot.z(), osg::Z_AXIS);
#if defined(OSG_GLES1_AVAILABLE)
glMultMatrixf(osg::Matrixf(rotation).ptr());
#else
glMultMatrixd(osg::Matrixd(rotation).ptr());
#endif
}
_drawable->draw(renderInfo);
glPopMatrix();
}
#else
OSG_NOTICE<<"Warning: Particle::render(..) not supported for user-defined shape."<<std::endl;
#endif
}
void VELOModel::addHit(osg::Vec3& coords){
osg::ref_ptr<osg::MatrixTransform> t1 = new osg::MatrixTransform;
t1->setMatrix( osg::Matrix::translate(
coords.x() - HIT_RADIUS,
coords.y(),
coords.z()) );
t1->addChild( _hitGeode.get() );
hits->addChild( t1.get() );
}
inline osg::Vec3 ReaderWriterOBJ::transformNormal(const osg::Vec3& vec, const bool rotate) const
{
if(rotate==true)
{
return osg::Vec3(vec.x(),-vec.z(),vec.y());
}
else
{
return vec;
}
}
bool ContourLayer::getValue(unsigned int i, unsigned int j, osg::Vec3& value) const
{
if (!_tf) return false;
const osg::Vec4& v = _tf->getPixelValue(i);
value.x() = v.x();
value.y() = v.y();
value.z() = v.z();
return true;
}
void ComputeBoundingBoxByRotation(osg::BoundingBox & InOut,osg::Vec3 BBCenter,float BBSize,osg::Matrixd Rotation)
{
osg::BoundingBox bb;
bb.set(BBCenter.x()-BBSize,BBCenter.y()-BBSize,BBCenter.z()-BBSize,BBCenter.x()+BBSize,BBCenter.y()+BBSize,BBCenter.z()+BBSize);
osg::BoundingBox Tbb;
for(unsigned int i=0;i<8;i++)
{
Tbb.expandBy(Rotation.preMult(bb.corner(i)));
}
InOut.set(Tbb.xMin(),Tbb.yMin(),Tbb.zMin(),Tbb.xMax(),Tbb.yMax(),Tbb.zMax());
}
void PanoManipulator::JumpTo(osg::Vec3 NewSpatialPos)
{
PartialVertexDEM JumpLoc;
JumpLoc.Lat = NewSpatialPos.y();
JumpLoc.Lon = NewSpatialPos.x();
JumpLoc.Elev = NewSpatialPos.z();
MasterScene.DegToCart(JumpLoc);
_eye[0] = JumpLoc.XYZ[0];
_eye[1] = JumpLoc.XYZ[1];
_eye[2] = JumpLoc.XYZ[2];
} // PanoManipulator::JumpTo
double Frustum::getAngleBetween(const osg::Vec3 &a, const osg::Vec3 &b) {
float dot = a * b;
float mag = a.length() * b.length();
double angle = acos(dot/mag);
if (osg::isNaN(angle))
return 0;
else
return angle;
}
void VertexCollectionVisitor::addVertex(osg::Vec3 vertex)
{
if (_geocentric)
{
double lat, lon, height;
_ellipsoidModel->convertXYZToLatLongHeight(vertex.x(), vertex.y(), vertex.z(), lat, lon, height);
_vertices->push_back(osg::Vec3d(osg::RadiansToDegrees(lon), osg::RadiansToDegrees(lat), height));
}
else
{
_vertices->push_back(vertex);
}
}
void CameraFlight::navigate(osg::Matrix destMat, osg::Vec3 destVec)
{
osg::Matrix objMat = SceneManager::instance()->getObjectTransform()->getMatrix();
switch(_flightMode)
{
case INSTANT:{
cout<<"USING INSTANT"<<endl;
SceneManager::instance()->setObjectMatrix(destMat);
break;
}
case SATELLITE:
cout<<"USING SATELLITE"<<endl;
t = 0.0;
total = 0.0;
objMat.decompose(trans2, rot2, scale2, so2);
a = (maxHeight - trans2[1])/25.0;
map->getProfile()->getSRS()->getEllipsoid()->convertLatLongHeightToXYZ(
destVec.x(),destVec.y(),destVec.z(),toVec.x(),toVec.y(),toVec.z());
fromVec = origPlanetPoint;
fromVec.normalize();
toVec.normalize();
origAngle = acos((fromVec * toVec)/((fromVec.length() * toVec.length())));
origAngle = RadiansToDegrees(origAngle);
angle = origAngle;
if(origAngle <= 10) {
maxHeight = 6.5e+9;
}
else {
maxHeight = 2.0e+10;
}
flagRot = true;
break;
case AIRPLANE:
cout<<"USING AIRPLANE"<<endl;
break;
default:
cout<<"PICK THE ALGORYTHM!!!!"<<endl;
break;
}
}
// -------------------------------------------------------------------------
void Hermite::getTangentOnSegment(osg::Vec3& tangent, double distance, unsigned int segment)
{
float fH1 = ( 6.0f * distance - 6.0f) * distance;
float fH2 = ( 3.0f * distance - 4.0f) * distance + 1.0f;
float fH3 = ( 3.0f * distance - 2.0f) * distance;
float fH4 = (-6.0f * distance + 6.0f) * distance;
const ControlPoint& begin = (*_segments)[segment].getBegin();
const ControlPoint& end = (*_segments)[segment].getEnd();
tangent = begin.position * fH1 + begin.tangent * fH2 + end.tangent * fH3 + end.position * fH4;
tangent.normalize();
/*
tangent[0] = begin->position.x * fH1 +
begin->tangent.x * fH2 +
end->tangent.x * fH3 +
end->position.x * fH4;
tangent[1] = begin->position.y * fH1 +
begin->tangent.y * fH2 +
end->tangent.y * fH3 +
end->position.y * fH4;
tangent[2] = begin->position.z * fH1 +
begin->tangent.z * fH2 +
end->tangent.z * fH3 +
end->position.z * fH4;
Math::normalize(tangent);
*/
}
bool
HeightFieldUtils::getNormalAtNormalizedLocation(const osg::HeightField* input,
double nx, double ny,
osg::Vec3& output,
ElevationInterpolation interp)
{
double xcells = (double)(input->getNumColumns()-1);
double ycells = (double)(input->getNumRows()-1);
double w = input->getXInterval() * xcells * 111000.0;
double h = input->getYInterval() * ycells * 111000.0;
double ndx = 1.0/xcells;
double ndy = 1.0/ycells;
double xmin = osg::clampAbove( nx-ndx, 0.0 );
double xmax = osg::clampBelow( nx+ndx, 1.0 );
double ymin = osg::clampAbove( ny-ndy, 0.0 );
double ymax = osg::clampBelow( ny+ndy, 1.0 );
osg::Vec3 west (xmin*w, ny*h, getHeightAtNormalizedLocation(input, xmin, ny, interp));
osg::Vec3 east (xmax*w, ny*h, getHeightAtNormalizedLocation(input, xmax, ny, interp));
osg::Vec3 south(nx*w, ymin*h, getHeightAtNormalizedLocation(input, nx, ymin, interp));
osg::Vec3 north(nx*w, ymax*h, getHeightAtNormalizedLocation(input, nx, ymax, interp));
output = (west-east) ^ (north-south);
output.normalize();
return true;
}
bool
TileModel::ElevationData::getNormal(const osg::Vec3d& ndc,
const GeoLocator* ndcLocator,
osg::Vec3& output,
ElevationInterpolation interp ) const
{
if ( !_locator.valid() || !ndcLocator )
{
output.set(0,0,1);
return false;
}
double xcells = (double)(_hf->getNumColumns()-1);
double ycells = (double)(_hf->getNumRows()-1);
double xres = 1.0/xcells;
double yres = 1.0/ycells;
osg::Vec3d hf_ndc;
GeoLocator::convertLocalCoordBetween( *ndcLocator, ndc, *_locator.get(), hf_ndc );
float centerHeight = HeightFieldUtils::getHeightAtNormalizedLocation(_hf.get(), hf_ndc.x(), hf_ndc.y(), interp);
osg::Vec3d west ( hf_ndc.x()-xres, hf_ndc.y(), 0.0 );
osg::Vec3d east ( hf_ndc.x()+xres, hf_ndc.y(), 0.0 );
osg::Vec3d south( hf_ndc.x(), hf_ndc.y()-yres, 0.0 );
osg::Vec3d north( hf_ndc.x(), hf_ndc.y()+yres, 0.0 );
if (!HeightFieldUtils::getHeightAtNormalizedLocation(_neighbors, west.x(), west.y(), west.z(), interp))
west.z() = centerHeight;
if (!HeightFieldUtils::getHeightAtNormalizedLocation(_neighbors, east.x(), east.y(), east.z(), interp))
east.z() = centerHeight;
if (!HeightFieldUtils::getHeightAtNormalizedLocation(_neighbors, south.x(), south.y(), south.z(), interp))
south.z() = centerHeight;
if (!HeightFieldUtils::getHeightAtNormalizedLocation(_neighbors, north.x(), north.y(), north.z(), interp))
north.z() = centerHeight;
osg::Vec3d westWorld, eastWorld, southWorld, northWorld;
_locator->unitToModel(west, westWorld);
_locator->unitToModel(east, eastWorld);
_locator->unitToModel(south, southWorld);
_locator->unitToModel(north, northWorld);
output = (eastWorld-westWorld) ^ (northWorld-southWorld);
output.normalize();
return true;
}
float ConeSector::operator() (const osg::Vec3& eyeLocal) const
{
float dotproduct = eyeLocal*_axis;
float length = eyeLocal.length();
if (dotproduct>_cosAngle*length) return 1.0f; // fully in sector
if (dotproduct<_cosAngleFade*length) return 0.0f; // out of sector
return (dotproduct-_cosAngleFade*length)/((_cosAngle-_cosAngleFade)*length);
}
void LightSource::init(const osg::Vec3& position, const osg::Vec4& ambient,
const osg::Vec4& diffuse, const osg::Vec4& specular)
{
if (initialized_)
return;
light_source_->getLight()->setPosition(osg::Vec4(position.x(), position.y(), position.z(), 1.0f));
light_source_->getLight()->setAmbient(ambient);
light_source_->getLight()->setDiffuse(diffuse);
light_source_->getLight()->setSpecular(specular);
addChild(light_source_.get());
initialized_ = true;
return;
}
osg::Vec3 CVehicle::calIntersectionPoint(const osg::Vec3& pa1,const osg::Vec3& pa2,const osg::Vec3& pb1,const osg::Vec3& pb2)
{
osg::Vec3 intersectionPoint,pa12,pb12;
double t;
pa12 = pa2 - pa1;
pb12 = pb2 - pb1;
double temp = (pa12.y() * pb12.x()) - (pb12.y() * pa12.x());
if(temp < 0.001)
return pa2;
else
t =( (pb1.y() - pa1.y()) * pb12.x() + (pa1.x() - pb1.x()) * pb12.y() ) / temp;
double x,y,z;
x = pa1.x() + pa12.x() * t;
y = pa1.y() + pa12.y() * t;
z = pa1.z() + pa12.z() * t;
intersectionPoint.set(x,y,z);
return intersectionPoint;
}
void dtAnim::GetCelestialCoordinates(osg::Vec3 target,
const osg::Vec3 &lookForward,
float &azimuth,
float &elevation)
{
target.normalize();
// Derive the reference frame for the "look" pose
osg::Vec3 frameRight = lookForward ^ osg::Z_AXIS;
osg::Vec3 frameUp = frameRight ^ lookForward;
osg::Matrix frameMatrix(frameRight.x(), frameRight.y(), frameRight.z(), 0.0f,
lookForward.x(), lookForward.y(), lookForward.z(), 0.0f,
frameUp.x(), frameUp.y(), frameUp.z(), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f);
// Transform the target into the proper coordinate frame
target = frameMatrix * target;
// Project our target vector onto the xy plane
// in order to calculate azimuth
osg::Vec3f targetRight = target ^ osg::Z_AXIS;
targetRight.normalize();
osg::Vec3f targetForward = osg::Z_AXIS ^ targetRight;
targetForward.normalize();
// Use the projected vector to calculate the azimuth
// between the projection and the character forward
float lookDotTargetForward = targetForward * osg::Y_AXIS;
float targetDotTargetForward = targetForward * target;
// acos needs it's parameter between -1 and 1
dtUtil::Clamp(lookDotTargetForward, -1.0f, 1.0f);
dtUtil::Clamp(targetDotTargetForward, -1.0f, 1.0f);
// We need to manually determine the sign
float azimuthSign = ((target * osg::X_AXIS) > 0.0f) ? -1.0f: 1.0f;
float elevationSign = ((target * osg::Z_AXIS) > 0.0f) ? 1.0f: -1.0f;
// We can use the angle between the projection
// and the original target to determine elevation
elevation = acos(targetDotTargetForward) * elevationSign;
azimuth = acos(lookDotTargetForward) * azimuthSign;
}
CSulScreenAlignedQuad::CSulScreenAlignedQuad( float fViewW, float fViewH, osg::Texture2D* tex, const osg::Vec3& pos, sigma::uint32 w, sigma::uint32 h )
{
float x = pos.x();
float y = pos.y();
float z = pos.z();
// create geometry quad
m_rGeomQuad = new CSulGeomQuad( osg::Vec3( x + w/2.0f, fViewH - (y+h/2.0f) , z ), w, h, CSulGeomQuad::PLANE_XY );
m_rGeomQuad->setTexture( tex );
m_geodeQuad = new CSulGeode;
m_geodeQuad->addDrawable( m_rGeomQuad );
osg::Matrixd mOrtho = osg::Matrix::ortho2D( 0, fViewW, 0, fViewH );
setMatrix( mOrtho );
initConstructor();
}
void SoundUpdateCallback::operator()(osg::Node *node, osg::NodeVisitor *nodeVisitor)
{
const osg::FrameStamp *frameStamp = nodeVisitor->getFrameStamp();
if ( !_sound || !_sound->isValid() || (frameStamp == NULL))
{
traverse(node, nodeVisitor);
return;
}
const double currTime = frameStamp->getReferenceTime();
const double diffTime = currTime - _prevTime;
if (diffTime >= _updateIntervalInSeconds)
{
const osg::Vec3 currPosition = osg::computeLocalToWorld(nodeVisitor->getNodePath()).getTrans();
osg::Vec3 velocity(0, 0, 0);
// Update the position and compute the velocity only if the position changed
if (currPosition != _prevPosition)
{
_sound->setPosition(currPosition.x(), currPosition.y(), currPosition.z());
// Automatically compute the velocity, based on movement
if (_firstRun)
{
_firstRun = false;
}
else
{
velocity = currPosition - _prevPosition;
velocity /= diffTime;
}
}
_sound->setVelocity(velocity.x(), velocity.y(), velocity.z());
_prevTime = currTime;
_prevPosition = currPosition;
// Compute the direction of the sound source, if it is directional
}
traverse(node, nodeVisitor);
}