bool PointerInfo::projectWindowXYIntoObject(const osg::Vec2& windowCoord, osg::Vec3& nearPoint, osg::Vec3& farPoint) const
{
nearPoint = osg::Vec3(windowCoord.x(),windowCoord.y(),0.0f)*_inverseMVPW;
farPoint = osg::Vec3(windowCoord.x(),windowCoord.y(),1.0f)*_inverseMVPW;
return true;
}
void Selector::operator ()(osg::Vec2 start, osg::Vec2 stop, bool select) {
if (!this->m_viewer || !this->m_model) return;
osg::ref_ptr<osgUtil::PolytopeIntersector> picker = new osgUtil::PolytopeIntersector(
osgUtil::Intersector::CoordinateFrame::WINDOW, start.x(), start.y(), stop.x(), stop.y());
picker->setDimensionMask(this->m_selection->mask());
osgUtil::IntersectionVisitor visitor(picker);
visitor.setTraversalMask(Role::Node::Pickable);
this->m_viewer->getCamera()->accept(visitor);
OcclusionTester tester(this->m_model);
if (this->m_model->kdTree().valid()) {
osg::Vec3 position(0.0f, 0.0f, 0.0f);
this->m_viewer->getCamera()->getViewMatrixAsLookAt(position, osg::Vec3(), osg::Vec3());
tester.setMask(this->m_selection->mask());
tester.setPosition(algo::Util::toPoint(position));
}
if (picker->containsIntersections()) {
const osgUtil::PolytopeIntersector::Intersections &intersections(picker->getIntersections());
if (select) {
for (osgUtil::PolytopeIntersector::Intersections::const_iterator iter = intersections.begin(); iter != intersections.end(); ++iter) {
if (tester.occluded(iter->primitiveIndex)) continue;
this->m_selection->indices().insert(iter->primitiveIndex);
}
} else {
for (osgUtil::PolytopeIntersector::Intersections::const_iterator iter = intersections.begin(); iter != intersections.end(); ++iter) {
if (tester.occluded(iter->primitiveIndex)) continue;
this->m_selection->indices().remove(iter->primitiveIndex);
}
}
}
this->m_selection->update();
}
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;
}
/**
* \fn void MenuButton::setPosition(osg::Vec2 pos)
*
* \brief Sets a position of button.
*
* \param pos The position.
*/
void MenuButton::setPosition(osg::Vec2 pos)
{
osg::Vec3Array* verts = new osg::Vec3Array(4);
(*verts)[0] = osg::Vec3( pos.x() - 0.5, 0, pos.y() - 0.5);
(*verts)[1] = osg::Vec3( pos.x() + 0.5, 0, pos.y() - 0.5);
(*verts)[2] = osg::Vec3( pos.x() + 0.5, 0, pos.y() + 0.5);
(*verts)[3] = osg::Vec3( pos.x() - 0.5, 0, pos.y() + 0.5);
this->setVertexArray(verts);
}
osg::Matrix vpb::MyDataSet::getImageSection(vips::VImage &in,const osg::Vec2 minT, const osg::Vec2 maxT,int origX,int origY,osg::Vec4 &texsize,const osg::Matrix &toTex,osg::ref_ptr<osg::Image> &image,osg::Vec4 &ratio,int level){
double downsampleFactor=pow(2,level);
double downsampleRatio=1.0/downsampleFactor;
// std::cout<< minT << " " << maxT<<std::endl;
// printf("%f %f\n",downsampleRatio,downsampleRatio);
int x=(int)std::max((int)floor(minT.x()),0);
int y=(int)std::max((int)floor(minT.y()),0);
int xMax=(int)std::min((int)ceil(maxT.x()),origX);
int yMax=(int)std::min((int)ceil(maxT.y()),origY);
int xRange=(xMax-x);
int yRange=(yMax-y);
//printf("X:%d -- %d Y:%d -- %d ",x,xMax,y,yMax);
//Need bias of 1.0 or will round down
double maxSide=std::max(osg::Image::computeNearestPowerOfTwo(xRange,1.0),osg::Image::computeNearestPowerOfTwo(yRange,1.0));
osg::Vec2 subSize=osg::Vec2(maxSide,maxSide);
if(downsampleRatio*maxSide < 1.0){
printf("Clipping %f %f to",downsampleRatio,downsampleFactor);
downsampleRatio=1.0/maxSide;
downsampleFactor=maxSide;
printf("%f %f\n",downsampleRatio,downsampleFactor);
}
texsize[0]=origX;
texsize[1]=origY;
texsize[2]=subSize.x();
texsize[3]=subSize.y();
osg::Vec2 downsampleSize(subSize.x(),subSize.y());
downsampleSize.x()*=downsampleRatio;
downsampleSize.y()*=downsampleRatio;
// printf("Range %d %d\n",xRange,yRange);
// printf("%f %f %f %f\n",subSize.x(),subSize.y(),downsampleSize.x(),downsampleSize.y());
image = new osg::Image;
image->allocateImage(downsampleSize.x(),downsampleSize.y(), 1, GL_RGB,GL_UNSIGNED_BYTE);
if(image->data() == 0 ){
fprintf(stderr,"Failed to allocate\n");
exit(-1);
}
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_imageMutex);
vips::VImage osgImage(image->data(),downsampleSize.x(),downsampleSize.y(),3,vips::VImage::FMTUCHAR);
in.extract_area(x,y,xRange,yRange).embed(1,0,0,subSize.x(),subSize.y()).shrink(downsampleFactor,downsampleFactor).write(osgImage);
}
ratio=osg::Vec4(x,y,subSize.x(),subSize.y());
//osg::Vec2 f(xRange-subSize.x(),yRange-subSize.y());
//std::cout << f<<std::endl;
return toTex;
}
void moveTo(const osg::Vec2& pos)
{
completeCurrentPrimitiveSet();
addVertex( osg::Vec3(pos.x(),pos.y(),0) );
}
void HUDView::updateRandomNumber(std::string number, osg::Vec2 normalizedPosition)
{
if (number == "")
{
m_randomNumberText->setText("");
m_backgroundGeode->setNodeMask(0); //invisible
return;
}
float offset = m_width / 15;
float halfextent = m_backgroundGeode->getBound().radius();
float max_x = m_width - offset - halfextent;
float max_y = m_height - offset;
float p_x = clamp(halfextent, max_x, (normalizedPosition.x() * m_width));
float p_y = clamp(halfextent + offset, max_y, (normalizedPosition.y() * m_height));
osg::Vec2 position(p_x, p_y);
m_backgroundGeode->setNodeMask(0xffffffff); //visible
m_backgroundTransform->setMatrix(osg::Matrix::translate(osg::Vec3(position, 0)));
m_randomNumberText->setPosition(osg::Vec3(position,0.0));
m_randomNumberText->setText(number);
}
bool Uniform::getElement( unsigned int index, osg::Vec2& v2 ) const
{
if( index>=getNumElements() || !isCompatibleType(FLOAT_VEC2) ) return false;
unsigned int j = index * getTypeNumComponents(getType());
v2.x() = (*_floatArray)[j];
v2.y() = (*_floatArray)[j+1];
return true;
}
osg::Vec2 CityModel::pixelToWorld(osg::Vec2 pixel)
{
osg::Vec2 levelSize = pairToVec2(getLevelSize());
osg::Vec2 picSize = osg::Vec2(m_collisionImage.width(), m_collisionImage.height());
double x = ((pixel.x() / picSize.x()) * levelSize.x()) - levelSize.x() / 2;
double y = ((pixel.y() / picSize.y()) * levelSize.y()) - levelSize.y() / 2;
return osg::Vec2(x, y);
}
void conicTo(const osg::Vec2& control, const osg::Vec2& pos)
{
osg::Vec3 p0 = _previous;
osg::Vec3 p1 = osg::Vec3(control.x(),control.y(),0);
osg::Vec3 p2 = osg::Vec3(pos.x(),pos.y(),0);
double dt = 1.0/_numSteps;
double u=0;
for (int i=0; i<=_numSteps; ++i)
{
double w = 1;
double bs = 1.0/( (1-u)*(1-u)+2*(1-u)*u*w +u*u );
osg::Vec3 p = (p0*((1-u)*(1-u)) + p1*(2*(1-u)*u*w) + p2*(u*u))*bs;
addVertex( p );
u += dt;
}
}
void Utility::SelectBox::Show(osg::Vec2 point1,osg::Vec2 point2 )
{
if(!m_initialized) return;
osg::Geometry* geom = m_selectbox->getDrawable(0)->asGeometry();
if(geom)
{
osg::Vec3Array* vertices = dynamic_cast<osg::Vec3Array*>(geom->getVertexArray());
vertices->at(0) = osg::Vec3(point1.x(),point1.y(),0.0);
vertices->at(1) = osg::Vec3(point2.x(),point1.y(),0.0);
vertices->at(2) = osg::Vec3(point2.x(),point2.y(),0.0);
vertices->at(3) = osg::Vec3(point1.x(),point2.y(),0.0);
m_selectbox->setNodeMask(CLASSCODE::PseudMouseDrawBox);
geom->dirtyBound();
geom->dirtyDisplayList();
}
}
bool ContourLayer::getValue(unsigned int i, unsigned int j, osg::Vec2& value) const
{
if (!_tf) return false;
const osg::Vec4& v = _tf->getPixelValue(i);
value.x() = v.x();
value.y() = v.y();
return true;
}
osg::Vec2 EnMapView::calcPosition( const std::string& align, const osg::Vec2& mapsize, const osg::Vec2& screenSize )
{
osg::Vec2 pos;
if ( align == ALIGN_TOPLEFT )
{
pos._v[ 0 ] = 0.0f;
pos._v[ 1 ] = 0.0f;
}
else if ( align == ALIGN_TOPMIDDLE )
{
pos._v[ 0 ] = screenSize.x() / 2.0f - mapsize.x() / 2.0f;
pos._v[ 1 ] = 0.0f;
}
else if ( align == ALIGN_TOPRIGHT )
{
pos._v[ 0 ] = screenSize.x() - mapsize.x();
pos._v[ 1 ] = 0.0f;
}
else if ( align == ALIGN_BOTTOMLEFT )
{
pos._v[ 0 ] = 0.0f;
pos._v[ 1 ] = screenSize.y() - mapsize.y();
}
else if ( align == ALIGN_BOTTOMMIDDLE )
{
pos._v[ 0 ] = screenSize.x() / 2.0f - mapsize.x() / 2.0f;
pos._v[ 1 ] = screenSize.y() - mapsize.y();
}
else if ( align == ALIGN_BOTTOMRIGHT )
{
pos._v[ 0 ] = screenSize.x() - mapsize.x();
pos._v[ 1 ] = screenSize.y() - mapsize.y();
}
else
{
log_error << "EnMapView: invalid aligning '" << align << "'" << std::endl;
log_out << " valid values are: " <<
ALIGN_TOPLEFT << ", " <<
ALIGN_TOPMIDDLE << ", " <<
ALIGN_TOPRIGHT << ", " <<
ALIGN_BOTTOMLEFT << ", " <<
ALIGN_BOTTOMMIDDLE << ", " <<
ALIGN_BOTTOMRIGHT << std::endl;
log_out << " set to default '" << ALIGN_TOPLEFT << "'" << std::endl;
}
return pos;
}
void MinimalShadowMap::ViewData::extendProjection
( osg::Matrixd & projection, osg::Viewport * viewport, const osg::Vec2& margin )
{
double l,r,b,t,n,f;
//osg::Matrix projection = camera.getProjectionMatrix();
bool frustum = projection.getFrustum( l,r,b,t,n,f );
if( !frustum && !projection.getOrtho( l,r,b,t,n,f ) ) {
osg::notify( osg::WARN )
<< " Awkward projection matrix. ComputeExtendedProjection failed"
<< std::endl;
return;
}
osg::Matrix window = viewport->computeWindowMatrix();
osg::Vec3 vMin( viewport->x() - margin.x(),
viewport->y() - margin.y(),
0.0 );
osg::Vec3 vMax( viewport->width() + margin.x() * 2 + vMin.x(),
viewport->height() + margin.y() * 2 + vMin.y(),
0.0 );
osg::Matrix inversePW = osg::Matrix::inverse( projection * window );
vMin = vMin * inversePW;
vMax = vMax * inversePW;
l = vMin.x();
r = vMax.x();
b = vMin.y();
t = vMax.y();
if( frustum )
projection.makeFrustum( l,r,b,t,n,f );
else
projection.makeOrtho( l,r,b,t,n,f );
}
void cubicTo(const osg::Vec2& control1, const osg::Vec2& control2, const osg::Vec2& pos)
{
osg::Vec3 p0 = _previous;
osg::Vec3 p1 = osg::Vec3(control1.x(),control1.y(),0);
osg::Vec3 p2 = osg::Vec3(control2.x(),control2.y(),0);
osg::Vec3 p3 = osg::Vec3(pos.x(),pos.y(),0);
double cx = 3*(p1.x() - p0.x());
double bx = 3*(p2.x() - p1.x()) - cx;
double ax = p3.x() - p0.x() - cx - bx;
double cy = 3*(p1.y() - p0.y());
double by = 3*(p2.y() - p1.y()) - cy;
double ay = p3.y() - p0.y() - cy - by;
double dt = 1.0/_numSteps;
double u=0;
for (int i=0; i<=_numSteps; ++i)
{
osg::Vec3 p = osg::Vec3( ax*u*u*u + bx*u*u + cx*u + p0.x(),ay*u*u*u + by*u*u + cy*u + p0.y(),0 );
addVertex( p );
u += dt;
}
}
void dtAnim::MapCelestialToScreen(float azimuth,
float elevation,
float maxDistance,
float windowWidth,
float windowHeight,
const osg::Vec2 &screenOrigin,
osg::Vec2 &outScreenPos)
{
// Transform az/el values to values ranging from 0 to 1
float normalizedAzimuth = azimuth / maxDistance;
float normalizedElevation = elevation / maxDistance;
// Calculate the final screen position
outScreenPos[0] = screenOrigin.x() + (windowWidth * normalizedAzimuth);
outScreenPos[1] = screenOrigin.y() + (windowHeight * normalizedElevation);
}
//overload SetSize so we can set the texts pixelheight independantly
void TextRegion::SetSize(const osg::Vec2& size)
{
StrokeRegion::SetSize(size);
//set the texts max sizes to the new size
_text->setMaximumHeight(size.y());
_text->setMaximumWidth(size.x());
float scaler = 1.0f / _scaleHeightRef;
float sizeScale = size.y()*scaler;
_textScale->setMatrix(osg::Matrix::scale(osg::Vec3(sizeScale,sizeScale,sizeScale)));
//set new centered position
this->SetAlignment(_alignmentMode);
}
// <length是宽高，先宽后高>
//QuadPrimitive::QuadPrimitive(const osg::Vec3& center, const osg::Vec2& length, const osg::Vec3& localX, const osg::Vec3& localY):
//QuadPrimitive::QuadPrimitive()
void QuadPrimitive::updateQuad(const osg::Vec3& center, const osg::Vec2& length, const osg::Vec3& localX, const osg::Vec3& localY)
{
m_center = center;
m_width = length.x();
m_height = length.y();
m_unitLength = length / 2.0f;
m_localX = localX;
m_localY = localY;
(*m_vertexArray)[0].set(center - localX * m_unitLength.x() - localY * m_unitLength.y());
(*m_vertexArray)[1].set(center + localX * m_unitLength.x() - localY * m_unitLength.y());
(*m_vertexArray)[2].set(center + localX * m_unitLength.x() + localY * m_unitLength.y());
(*m_vertexArray)[3].set(center - localX * m_unitLength.x() + localY * m_unitLength.y());
if (!m_geoEffect.empty())
{
m_geoEffect.get()(_geometry);
applyGeoShader(_geometry->getOrCreateStateSet());
_geometry->getOrCreateStateSet()->setAttributeAndModes(new osg::PolygonOffset(1.0f, 1.0f));
}
if (!m_lineEffect.empty())
{
m_lineEffect.get()(_outLine);
osg::ref_ptr <osg::LineWidth> lineWidth = new osg::LineWidth;
lineWidth->setWidth(1);
_outLine->getOrCreateStateSet()->setAttributeAndModes(lineWidth.get(), osg::StateAttribute::ON);
applyLineShader(_outLine->getOrCreateStateSet());
}
m_vertexArray->dirty();
//_geometry->dirtyBound();
if (m_drawOutLine)
{
_outLine->setNodeMask((unsigned int)-1);
}
else
{
_outLine->setNodeMask(0);
}
//_outLine->dirtyBound();
_root->dirtyBound();
}
std::vector< CEGUI::Point > EnMapView::calcSnapPoints( const osg::Vec2& mapsize, const osg::Vec2& screenSize )
{
CEGUI::Point snap;
std::vector< CEGUI::Point > points;
// top left
snap.d_x = 0.0f;
snap.d_y = 0.0f;
points.push_back( snap );
// top middle
snap.d_x = screenSize.x() / 2.0f - mapsize.x() / 2.0f;
snap.d_y = 0.0f;
points.push_back( snap );
// top right
snap.d_x = screenSize.x() - mapsize.x();
snap.d_y = 0.0f;
points.push_back( snap );
// bottom left
snap.d_x = 0.0f;
snap.d_y = screenSize.y() - mapsize.y();
points.push_back( snap );
// bottom middle
snap.d_x = screenSize.x() / 2.0f - mapsize.x() / 2.0f;
snap.d_y = screenSize.y() - mapsize.y();
points.push_back( snap );
// bottom right
snap.d_x = screenSize.x() - mapsize.x();
snap.d_y = screenSize.y() - mapsize.y();
points.push_back( snap );
return points;
}
/* ....................................................................... */
void
Text::drawImplementation(osg::RenderInfo& info) const
{
(void) info ;
GLboolean depth_test ;
glGetBooleanv( GL_DEPTH_TEST, &depth_test ) ;
glDisable( GL_DEPTH_TEST ) ;
glColor4f( 1.0, 1.0, 1.0, 1.0 ) ;
glNormal3f( 0.0, 0.0, 1.0 ) ;
const unsigned int size = m_text.size() ;
const float xskip = 1.0 / 16.0 ;
const float yskip = 1.0 / 4.0 ;
glBegin( GL_QUADS ) ;
for( unsigned int i=0; i<size; i++ ) {
const osg::Vec2 TL = _findCoord( m_text[i] ) ;
const osg::Vec2 BL ( TL.x(), TL.y() - yskip ) ;
const osg::Vec2 BR ( TL.x() + xskip, TL.y() - yskip ) ;
const osg::Vec2 TR ( TL.x() + xskip, TL.y() ) ;
const float x0 = m_position.x() + i * m_scale ;
const float x1 = m_position.x() + (i+1) * m_scale ;
const float y0 = m_position.y() ;
const float y1 = m_position.y() + m_scale ;
glTexCoord2f ( TL.x(), TL.y() ) ;
glVertex2f ( x0, y1 ) ;
glTexCoord2f ( BL.x(), BL.y() ) ;
glVertex2f ( x0, y0 ) ;
glTexCoord2f ( BR.x(), BR.y() ) ;
glVertex2f ( x1, y0 ) ;
glTexCoord2f ( TR.x(), TR.y() ) ;
glVertex2f ( x1, y1 ) ;
}
glEnd() ;
if( depth_test ) {
glEnable( GL_DEPTH_TEST ) ;
}
}
bool HeightFieldLayer::getValue(unsigned int i, unsigned int j, osg::Vec2& value) const
{
value.x() = _heightField->getHeight(i,j);
value.y() = _defaultValue.y();
return true;
}
//
//set the fonts glyph res in pixels
//
void TextRegion::SetFontResolution(const osg::Vec2& fontRes)
{
_text->setFontResolution((int)fontRes.x(), (int)fontRes.y());
_dirtyRenderState = true;
}
//------------------------------------------------------------------------------
// compute the z value at point p using plane coefficients c.
//------------------------------------------------------------------------------
LCreal Polygon::calcZ(const osg::Vec2& p, const osg::Vec4& cc)
{
LCreal zz = 0.0;
zz = (-cc._v[D] - (cc._v[A] * p.x()) - (cc._v[B] * p.y()) )/cc._v[C];
return zz;
}
void DataOutputStream::writeVec2(const osg::Vec2& v){
writeFloat(v.x());
writeFloat(v.y());
if (_verboseOutput) std::cout<<"read/writeVec2() ["<<v<<"]"<<std::endl;
}
void lineTo(const osg::Vec2& pos)
{
addVertex( osg::Vec3(pos.x(),pos.y(),0) );
}
Eigen::Vector2f toE(const osg::Vec2 &v) const {
return Eigen::Vector2f(v.x(), v.y());
}
void TextBase::positionCursor(const osg::Vec2 & endOfLine_coords, osg::Vec2 & cursor, unsigned int linelength)
{
switch(_layout)
{
case LEFT_TO_RIGHT:
{
switch (_alignment)
{
// nothing to be done for these
//case LEFT_TOP:
//case LEFT_CENTER:
//case LEFT_BOTTOM:
//case LEFT_BASE_LINE:
//case LEFT_BOTTOM_BASE_LINE:
// break;
case CENTER_TOP:
case CENTER_CENTER:
case CENTER_BOTTOM:
case CENTER_BASE_LINE:
case CENTER_BOTTOM_BASE_LINE:
cursor.x() = (cursor.x() - endOfLine_coords.x()) * 0.5f;
break;
case RIGHT_TOP:
case RIGHT_CENTER:
case RIGHT_BOTTOM:
case RIGHT_BASE_LINE:
case RIGHT_BOTTOM_BASE_LINE:
cursor.x() = cursor.x() - endOfLine_coords.x();
break;
default:
break;
}
break;
}
case RIGHT_TO_LEFT:
{
switch (_alignment)
{
case LEFT_TOP:
case LEFT_CENTER:
case LEFT_BOTTOM:
case LEFT_BASE_LINE:
case LEFT_BOTTOM_BASE_LINE:
cursor.x() = 2*cursor.x() - endOfLine_coords.x();
break;
case CENTER_TOP:
case CENTER_CENTER:
case CENTER_BOTTOM:
case CENTER_BASE_LINE:
case CENTER_BOTTOM_BASE_LINE:
cursor.x() = cursor.x() + (cursor.x() - endOfLine_coords.x()) * 0.5f;
break;
// nothing to be done for these
//case RIGHT_TOP:
//case RIGHT_CENTER:
//case RIGHT_BOTTOM:
//case RIGHT_BASE_LINE:
//case RIGHT_BOTTOM_BASE_LINE:
// break;
default:
break;
}
break;
}
case VERTICAL:
{
switch (_alignment)
{
// TODO: current behaviour top baselines lined up in both cases - need to implement
// top of characters aligment - Question is this neccesary?
// ... otherwise, nothing to be done for these 6 cases
//case LEFT_TOP:
//case CENTER_TOP:
//case RIGHT_TOP:
// break;
//case LEFT_BASE_LINE:
//case CENTER_BASE_LINE:
//case RIGHT_BASE_LINE:
// break;
case LEFT_CENTER:
case CENTER_CENTER:
case RIGHT_CENTER:
cursor.y() = cursor.y() + (cursor.y() - endOfLine_coords.y()) * 0.5f;
break;
case LEFT_BOTTOM_BASE_LINE:
case CENTER_BOTTOM_BASE_LINE:
case RIGHT_BOTTOM_BASE_LINE:
cursor.y() = cursor.y() - (linelength * _characterHeight);
break;
case LEFT_BOTTOM:
case CENTER_BOTTOM:
case RIGHT_BOTTOM:
cursor.y() = 2*cursor.y() - endOfLine_coords.y();
break;
default:
break;
}
break;
}
}
}
/* virtual */ void
av::utils::Trackball::evaluate()
{
av::FieldContainer::evaluate();
if(!Enable.getValue())
return;
if(mReset)
reset();
const bool newDragging =
(RotateTrigger.getValue() || ZoomTrigger.getValue() || PanTrigger.getValue());
const ::osg::Vec3 projected = projectToSphere(Direction.getValue());
if (mDragging && newDragging)
{
if (RotateTrigger.getValue())
{
::osg::Matrix rotMat = ::osg::Matrix::rotate(projected, mLastProjected);
float fac = SpinningWeightingCoefficient.getValue();
mRotation = rotMat * ::osg::Matrix::scale(fac,fac,fac) * mRotation;
Matrix.setValue(mCenterTransInv * rotMat *
CenterTransform.getValue() * Matrix.getValue());
}
else if (ZoomTrigger.getValue())
{
const ::osg::Vec2 offset = mLastDirection - Direction.getValue();
float zoomFactor = offset.y();
zoomFactor *= BoundingSphere.getValue()->Radius.getValue()*ZoomPanFactor.getValue();
if(AutoAdjustCenterTransform.getValue())
{
::osg::Matrix mat = CenterTransform.getValue() * ::osg::Matrix::translate(0.0, 0.0, zoomFactor);
CenterTransform.setValue(mat);
}
Matrix.setValue(mCenterTransInv * ::osg::Matrix::translate(0.0, 0.0, -zoomFactor) *
CenterTransform.getValue() * Matrix.getValue());
}
else if (PanTrigger.getValue())
{
const ::osg::Vec2 offset = mLastDirection - Direction.getValue();
float xPanFactor = offset.x() * BoundingSphere.getValue()->Radius.getValue()*ZoomPanFactor.getValue();
float yPanFactor = offset.y() * BoundingSphere.getValue()->Radius.getValue()*ZoomPanFactor.getValue();
Matrix.setValue(mCenterTransInv * ::osg::Matrix::translate(xPanFactor, yPanFactor, 0.0) *
CenterTransform.getValue() * Matrix.getValue());
}
mSpinning = false;
}
else if (!mDragging && newDragging)
{
mRotation = ::osg::Matrix::identity();
mTimeLastMovement = TimeIn.getValue();
}
else if (mDragging && !newDragging)
{
float timeSinceLastRecordEvent = TimeIn.getValue() - mTimeLastMovement;
if (timeSinceLastRecordEvent < SpinningTimeThreshold.getValue())
{
mSpinning = true;
}
}
if (mSpinning)
{
::osg::Quat rot = mRotation.getRotate();
Matrix.setValue(mCenterTransInv * ::osg::Matrix::rotate(rot) *
CenterTransform.getValue() * Matrix.getValue());
}
if (ResetTrigger.getValue())
{
reset();
mSpinning = false;
}
mDragging = newDragging;
mLastDirection = Direction.getValue();
mLastProjected = projected;
}
osg::Vec2 CityModel::findCollisionEdge(std::vector<osg::Vec2> &points, std::vector<osg::Vec2> &checks, osg::Vec2 &resultVector)
{
osg::Vec2 direction1, direction2;
if (points.size() == 1)
{
int i=0;
for (; i < 4; i++)
{
if (points.front() == checks[i])
break;
}
direction1 = checks[(i + 1) % 4] - checks[i];
direction2 = checks[posMod(i - 1,4)] - checks[i];
// insert same again, to apply 2nd direction later
points.push_back(points.front());
}
else if (points.size() == 2)
for (int i = 0; i < 4; i++)
if (contains(points, checks[i]) && contains(points, checks[(i + 1) % 4]))
{
direction1 = checks[posMod(i - 1, 4)] - checks[i];
direction2 = checks[(i + 2) % 4] - checks[(i + 1) % 4];
break;
}
else if (points.size() == 3)
for (int i = 0; i < 4; i++)
if (!contains(points, checks[i]))
{
direction1 = checks[posMod(i - 1, 4)] - checks[i];
direction2 = checks[(i + 2) % 4] - checks[(i + 1) % 4];
break;
}
direction1.normalize();
direction2.normalize();
osg::Vec2 pix1 = worldToPixelIndex(points[0]);
osg::Vec2 pix2 = worldToPixelIndex(points[1]);
osg::Vec2 p1 = pixelToWorld( findBorder(pix1, direction1) );
osg::Vec2 p2 = pixelToWorld( findBorder(pix2, direction2) );
if (debugging)
{
std::vector<osg::Vec2> redPoints{ findBorder(pix1, direction1), findBorder(pix2, direction2) };
std::vector<osg::Vec2> markPoints2{ worldToPixelIndex(checks[0]),
worldToPixelIndex(checks[1]),
worldToPixelIndex(checks[2]),
worldToPixelIndex(checks[3])
};
writeDebugImage(pix1.x(), pix1.y(), &redPoints, &markPoints2);
resultVector.set((p2 - p1).x(), (p2 - p1).y());
std::cout << "[CityModel] resultVector" << resultVector.x() << " " << resultVector.y() << std::endl;
while (1);
}
//resultNormal.set(osg::Vec3(p2-p1,0)^osg::Vec3(0,0,1));
resultVector.set((p2 - p1).x(),(p2-p1).y());
//center
return (p2 + p1) / 2;
}
String::iterator Text3D::computeLastCharacterOnLine(osg::Vec2& cursor, String::iterator first,String::iterator last)
{
if (_font.valid() == false) return last;
bool kerning = true;
unsigned int previous_charcode = 0;
String::iterator lastChar = first;
std::set<unsigned int> deliminatorSet;
deliminatorSet.insert(' ');
deliminatorSet.insert('\n');
deliminatorSet.insert(':');
deliminatorSet.insert('/');
deliminatorSet.insert(',');
deliminatorSet.insert(';');
deliminatorSet.insert(':');
deliminatorSet.insert('.');
float maximumHeight = _maximumHeight / _font->getScale();
float maximumWidth = _maximumWidth / _font->getScale();
for(bool outOfSpace=false;lastChar!=last;++lastChar)
{
unsigned int charcode = *lastChar;
if (charcode=='\n')
{
return lastChar;
}
Font3D::Glyph3D* glyph = _font->getGlyph(charcode);
if (glyph)
{
const osg::BoundingBox & bb = glyph->getBoundingBox();
// adjust cursor position w.r.t any kerning.
if (previous_charcode)
{
if (_layout == RIGHT_TO_LEFT)
{
cursor.x() -= glyph->getHorizontalAdvance();
}
if (kerning)
{
switch (_layout)
{
case LEFT_TO_RIGHT:
{
cursor += _font->getKerning(previous_charcode, charcode, _kerningType);
break;
}
case RIGHT_TO_LEFT:
{
cursor -= _font->getKerning(charcode, previous_charcode, _kerningType);
break;
}
case VERTICAL:
break; // no kerning when vertical.
}
}
}
else
{
switch (_layout)
{
case LEFT_TO_RIGHT:
{
cursor.x() -= glyph->getHorizontalBearing().x();
break;
}
case RIGHT_TO_LEFT:
{
cursor.x() -= bb.xMax();
break;
}
case VERTICAL:
break;
}
}
switch(_layout)
{
case LEFT_TO_RIGHT:
{
if (maximumWidth>0.0f && cursor.x()+bb.xMax()>maximumWidth) outOfSpace=true;
if(maximumHeight>0.0f && cursor.y()<-maximumHeight) outOfSpace=true;
break;
}
case RIGHT_TO_LEFT:
{
if (maximumWidth>0.0f && cursor.x()+bb.xMin()<-maximumWidth) outOfSpace=true;
if(maximumHeight>0.0f && cursor.y()<-maximumHeight) outOfSpace=true;
break;
}
case VERTICAL:
if (maximumHeight>0.0f && cursor.y()<-maximumHeight) outOfSpace=true;
break;
}
// => word boundary detection & wrapping
if (outOfSpace) break;
// move the cursor onto the next character.
switch(_layout)
{
case LEFT_TO_RIGHT: cursor.x() += glyph->getHorizontalAdvance(); break;
case RIGHT_TO_LEFT: break;
case VERTICAL: cursor.y() -= glyph->getVerticalAdvance(); break;
}
previous_charcode = charcode;
}
}
// word boundary detection & wrapping
if (lastChar!=last)
{
if (deliminatorSet.count(*lastChar)==0)
{
String::iterator lastValidChar = lastChar;
while (lastValidChar!=first && deliminatorSet.count(*lastValidChar)==0)
{
--lastValidChar;
//Substract off glyphs from the cursor position (to correctly center text)
Font3D::Glyph3D* glyph = _font->getGlyph(*lastValidChar);
if (glyph)
{
switch(_layout)
{
case LEFT_TO_RIGHT: cursor.x() -= glyph->getHorizontalAdvance(); break;
case RIGHT_TO_LEFT: cursor.x() += glyph->getHorizontalAdvance(); break;
case VERTICAL: cursor.y() += glyph->getVerticalAdvance(); break;
}
}
}
if (first!=lastValidChar)
{
++lastValidChar;
lastChar = lastValidChar;
}
}
}
return lastChar;
}