예제 #1
0
void VehicleManagerDemo::buildLandscape()
{

	if (1)
	{
		//
		// Create the ground we'll drive on.
		//
		{
			hkpRigidBodyCinfo groundInfo;

			//
			//	Set the if condition to 0 if you want to test the heightfield
			//
			if ( 1 )
			{
				FlatLand* fl = new FlatLand();
				m_track = fl;
				groundInfo.m_shape = fl->createMoppShapeForSpu();
				groundInfo.m_position.set(5.0f, -2.0f, 5.0f);
				groundInfo.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo( GROUND_LAYER, 0 );
			}

			{
				groundInfo.m_motionType = hkpMotion::MOTION_FIXED;
				groundInfo.m_friction = 0.5f;
				hkpRigidBody* groundbody = new hkpRigidBody(groundInfo);
				m_world->addEntity(groundbody);
				groundbody->removeReference();
			}

			groundInfo.m_shape->removeReference();
		}
	}

	if (1)
	{
		hkVector4 halfExtents(10.0f, 0.1f, 10.0f);
		hkVector4 startPos(-240.0f, -7.8f, 0.0f);
		hkVector4 diffPos (30.0f, 0.0f, 0.0f);
		createDodgeBoxes(5, halfExtents, startPos, diffPos);
	}

	if (1)
	{
		hkVector4 halfExtents(10.0f, 0.05f, 10.0f);
		hkVector4 startPos(-240.0f, -7.85f, 30.0f);
		hkVector4 diffPos (30.0f, 0.0f, 0.0f);
		createDodgeBoxes(5, halfExtents, startPos, diffPos);
	}

	if (1)
	{
		int gridSize = 1 + int(hkMath::sqrt( hkReal(m_env->m_cpuMhz/100) ));
		createRagdollGrid( m_world, gridSize, gridSize, 4.0f, 4.0f, m_ragdolls );
	}
}
QList<QPointF> QLogicCircuitShapeConnector::defaultConnector() const
{
    QList<QPointF> points;
    QList<QPointF> sections;
    QLineF line(startPos(), endPos());
    QLineF lineEnd;
    QLineF lineStart;

    line = QLineF(startPos(), endPos());

    lineStart.setP1(startPos());
    lineEnd.setP1(endPos());

    switch(orientationAtStart()){
    case QDiagramToolkit::East:
        if (line.dx() < 20){
            lineStart.setP2(startPos() + QPointF(20, 0));

            lineEnd.setP2(lineEnd.p1() - QPointF(20, 0));
            sections << QPointF(lineStart.p2().x(), lineStart.p1().y() + line.dy() / 2)
                          << QPointF(lineEnd.p2().x(), lineEnd.p2().y() - line.dy() / 2);
        } else {
            lineStart.setP2(lineStart.p1() + QPointF(line.dx() / 2 , 0));

            lineEnd.setP2(QPointF(lineStart.p2().x(), lineEnd.p1().y()));
        }
        break;
    case QDiagramToolkit::West:
        if (line.dx() > -20){
            lineStart.setP2(startPos() - QPointF(20, 0));

            lineEnd.setP2(lineEnd.p1() + QPointF(20, 0));
            sections << QPointF(lineStart.p2().x(), lineStart.p1().y() + line.dy() / 2)
                          << QPointF(lineEnd.p2().x(), lineEnd.p2().y() - line.dy() / 2);
        } else {
            lineStart.setP2(lineStart.p1() + QPointF(line.dx() / 2 , 0));

            lineEnd.setP2(QPointF(lineStart.p2().x(), lineEnd.p1().y()));
        }
        break;
    default:
        break;
    }


    points.append(lineStart.p1());
    points.append(lineStart.p2());
    QListIterator<QPointF> it(sections);
    while(it.hasNext()){
        points.append(it.next());
    }
    points.append(lineEnd.p2());
    points.append(lineEnd.p1());
    return points;
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Split several parts of a string
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
void dataHandlerDateTimeBase::split(const std::wstring& timeString, const std::wstring& separators, std::vector<std::wstring> *pComponents) const
{
	PUNTOEXE_FUNCTION_START(L"dataHandlerDateTimeBase::split");

        if(timeString.empty())
        {
            return;
        }

	for(size_t startPos(0), sepPos(timeString.find_first_of(separators)); /* empty */; sepPos = timeString.find_first_of(separators, startPos))
	{
                if(sepPos == timeString.npos)
                {
                    pComponents->push_back(timeString.substr(startPos));
                    break;
                }
		pComponents->push_back(timeString.substr(startPos, sepPos - startPos));
		startPos = ++sepPos;
                if(startPos == timeString.size())
                {
                    pComponents->push_back(L"");
                    break;
                }
	}

	PUNTOEXE_FUNCTION_END();
}
예제 #4
0
bool NavGrid::FindPath(const CU::Vector3f& aStartPoint, const CU::Vector3f& aEndPoint, CU::GrowingArray<CU::Vector2f>& aOutPath)
{
	CU::Vector2i startPos(static_cast<int>(aStartPoint.x), static_cast<int>(aStartPoint.z));
	CU::Vector2i endPos(static_cast<int>(aEndPoint.x), static_cast<int>(aEndPoint.z));

	return FindPath(startPos, endPos, aOutPath);
}
예제 #5
0
void GridEmitter::update( double relative_time, ParticleArray *particles )
{
    // Saving up particles until there are enough saved up to emit in the grid:
    const double possible_particles = (relative_time - last_emit_time) * p_rate + left_over;

    if ( possible_particles >= p_N
         && (particles->getMaxLength() - particles->getLength()) >= p_N )
    {
        // Set the last emit time, and compensate for the "residue particle(s)".
        last_emit_time = relative_time - ( possible_particles - p_N ) / p_rate;
        left_over = 0;

        // Emit:
        for ( int p = 0; p < p_N; p++ )
        {
            const Vector2d pos = startPos( p );
            const Vector2d vel = startVel( p );

            if ( channel->outsideBox( pos ) == P_INSIDE )
                particles->add( Particle( pos, vel ) );
            else
                left_over++;
        }
    }
}
예제 #6
0
QPainterPath Connection::path(bool only_bezier) const
{
    QPointF start = startPos();
    QPointF end = endPos();

    float length = 50;
    if (end.x() <= start.x())
    {
        length += (start.x() - end.x()) / 2;
    }

    QPainterPath p;
    p.moveTo(start);
    if (only_bezier)
        p.moveTo(start + QPointF(15, 0));
    else
        p.lineTo(start + QPointF(15, 0));

    p.cubicTo(QPointF(start.x() + length, start.y()),
              QPointF(end.x() - length, end.y()),
              QPointF(end.x() - 15, end.y()));

    if (!only_bezier)
        p.lineTo(end);

   return p;
}
예제 #7
0
/*
-------------------------------------------------------------------------------

    Class: CStifSectionParser

    Method: GetNextItemLineL

    Description: Parses a next line for items parsing with a tag.

    If start tag is empty the parsing starts beging of the section.

    Parameters: const TDesC& aTag: in: Indicates parsing start point
                TTagToReturnValue aTagIndicator: in: Will aTag included to the
                returned object(For default the tag will be added)

    Return Values:  CStifItemParser* : pointer to CStifItemParser object
                    NULL will return if iLineIndicator is false
                    NULL will return if ParseStartAndEndPos() method returns -1
                    NULL will return if length is 0 or negative
                    NULL will return if iStartPos is 0

    Errors/Exceptions: Leaves if called CStifItemParser::NewL method fails

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C CStifItemParser* CStifSectionParser::GetNextItemLineL(
                                            const TDesC& aTag,
                                            TTagToReturnValue aTagIndicator )
    {
    // GetLine() or GetItemLineL() method is not called
    if ( !iLineIndicator )
        {
        __TRACE( KInfo, 
            ( _L( "STIFPARSER: GetNextItemLineL method returns a NULL" ) ) );
        return NULL;
        }

    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );

    TInt ret = ParseStartAndEndPos( iSection, aTag, aTagIndicator,
                                    startPos, endPos, length );
    // No parsing found
    if ( KErrNone != ret || length <= 0 || startPos < 0 )
        {
        __TRACE( KInfo, 
            ( _L( "STIFPARSER: GetNextItemLineL method returns a NULL" )  ) );
        return NULL;
        }

    CStifItemParser* line = CStifItemParser::NewL(
                                            iSection, startPos, length );

    return line;

    }
예제 #8
0
void KexiAnimatedLayout::Private::animateTo(QWidget* destination)
{
    QWidget *from = q->currentWidget();
    Q_ASSERT(destination && from);
    destinationWidget = destination;
    if (from == destinationWidget)
        return;
    if (!(KexiUtils::graphicEffectsLevel() & KexiUtils::SimpleAnimationEffects))
    {
        // animations not allowed: switch to destination widget immediately
        animationFinished();
        return;
    }
    bool toRight = q->currentIndex() < q->indexOf(destinationWidget);
    hide();
    setParent(from);
    QSize s(from->parentWidget()->size());
    QPoint startPos(toRight ? QPoint(0, 0) : QPoint(s.width(), 0));
    QPoint endPos(toRight ? QPoint(s.width(), 0) : QPoint(0, 0));
    animation.setStartValue(-startPos);
    animation.setEndValue(-endPos);
    buffer = QPixmap(s.width() * 2, s.height());
    buffer.fill(Qt::white);
    from->render(&buffer, startPos);
    //qDebug() << s << from->geometry() << destinationWidget->geometry();
    destinationWidget->resize(from->size()); // needed because destination could
                                               // have been never displayed
    destinationWidget->render(&buffer, endPos);
    resize(buffer.size());
    move(animation.startValue().toPoint().x(), animation.startValue().toPoint().y());
    show();
    animation.start();
}
예제 #9
0
/*
-------------------------------------------------------------------------------

    Class: CStifSectionParser

    Method: GetNextLine

    Description: Get a line

    Search an item from the section and return rest of the line.

    Parameters: TPtr& aLine: inout: Parsed line

    Return Values: TInt: Error code

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C TInt CStifSectionParser::GetNextLine( TPtrC& aLine )
    {
    TInt ret( KErrNone );

    // GetLine() or GetItemLineL() method is not called
    if ( !iLineIndicator )
        {
        return KErrNotReady;
        }

    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );

    // tagIndicator has no meaning in this method
    TTagToReturnValue tagIndicator( ETag );

    ret = ParseStartAndEndPos( iSection, KNullDesC, tagIndicator,
                                startPos, endPos, length );
    if ( KErrNone != ret )
        {
        // Nothing to parse
        return ret;
        }

    aLine.Set( &iSection[startPos], length );

    return KErrNone;

    }
예제 #10
0
void AbstractClipItem::resizeEnd(int posx, bool /*emitChange*/)
{
    GenTime durationDiff = GenTime(posx, m_fps) - endPos();
    if (durationDiff == GenTime()) return;
    if (cropDuration() + durationDiff <= GenTime()) {
        durationDiff = GenTime() - (cropDuration() - GenTime(3, m_fps));
    }

    m_info.cropDuration += durationDiff;
    m_info.endPos += durationDiff;

    setRect(0, 0, cropDuration().frames(m_fps) - 0.02, rect().height());
    if (durationDiff > GenTime()) {
        QList <QGraphicsItem *> collisionList = collidingItems(Qt::IntersectsItemBoundingRect);
        bool fixItem = false;
        for (int i = 0; i < collisionList.size(); ++i) {
            if (!collisionList.at(i)->isEnabled()) continue;
            QGraphicsItem *item = collisionList.at(i);
            if (item->type() == type() && item->pos().x() > pos().x()) {
                GenTime diff = static_cast<AbstractClipItem*>(item)->startPos() - startPos();
                if (fixItem == false || diff < m_info.cropDuration) {
                    fixItem = true;
                    m_info.cropDuration = diff;
                }
            }
        }
        if (fixItem) setRect(0, 0, cropDuration().frames(m_fps) - 0.02, rect().height());
    }
}
예제 #11
0
/*
-------------------------------------------------------------------------------

    Class: CStifSectionParser

    Method: GetLine

    Description: Get a line.

    Search an item from the section and return rest of the line. If start tag 
    is empty the parsing starts beging of the section.

    Parameters: const TDesC& aTag: in: Indicates parsing start point
                TPtr& aLine: inout: Parsed line
                TTagToReturnValue aTagIndicator: in: Will aTag included to the
                returned value(For default the tag will be added)

    Return Values: TInt: Error code

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C TInt CStifSectionParser::GetLine( const TDesC& aTag,
                                            TPtrC& aLine,
                                            TTagToReturnValue aTagIndicator )
    {
    TInt ret( KErrNone );

    if ( 0 == iSection.Length() )
        {
        return KErrNotFound;
        }

    // Indicator that GetLine has been used
    iLineIndicator = ETrue;

    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );

    iSkipAndMarkPos = 0;

    ret = ParseStartAndEndPos( iSection, aTag, aTagIndicator,
                                startPos, endPos, length );

    if ( KErrNone != ret )
        {
        // Nothing to parse
        return ret;
        }

    aLine.Set( &iSection[startPos], length );

    return KErrNone;

    }
예제 #12
0
EmpirePricesWindow::EmpirePricesWindow(Widget *parent, int id, const Rect &rectangle, PlayerCityPtr city)
  : Window( parent, rectangle, "", id )
{
  setupUI( ":/gui/empireprices.gui" );

  city::TradeOptions& ctrade = city->tradeOptions();
  Font font = Font::create( FONT_1 );
  Point startPos( 140, 50 );
  for( int i=Good::wheat; i < Good::prettyWine; i++ )
    {
      if( i == Good::fish || i == Good::denaries)
        {
          continue;
        }

      Good::Type gtype = (Good::Type)i;
      Picture goodIcon = GoodHelper::picture( gtype );
      new Image( this, startPos, goodIcon );

      std::string priceStr = StringHelper::format( 0xff, "%d", ctrade.buyPrice( gtype ) );
      Label* lb = new Label( this, Rect( startPos + Point( 0, 34 ), Size( 24, 24 ) ), priceStr );
      lb->setFont( font );

      priceStr = StringHelper::format( 0xff, "%d", ctrade.sellPrice( gtype ) );
      lb = new Label( this, Rect( startPos + Point( 0, 58 ), Size( 24, 24 ) ), priceStr );
      lb->setFont( font );

      startPos += Point( 30, 0 );
    }
}
예제 #13
0
/*
-------------------------------------------------------------------------------

    Class: CStifSectionParser

    Method: GetItemLineL

    Description: Parses a line for items parsing.

    If start tag is empty the parsing starts beging of the section.

    Parameters: const TDesC& aTag: in: Indicates parsing start point.
                TTagToReturnValue aTagIndicator: in: Will aTag included to the
                returned object(For default the tag will be added)

    Return Values:  CStifItemParser* : pointer to CStifItemParser object
                    NULL will return if ParseStartAndEndPos() method returns -1
                    NULL will return if length is 0 or negative
                    NULL will return if iStartPos is 0

    Errors/Exceptions: Leaves if called CStifItemParser::NewL method fails

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C CStifItemParser* CStifSectionParser::GetItemLineL( const TDesC& aTag,
                                            TTagToReturnValue aTagIndicator )
    {
    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );

    // Indicator that GetItemLineL has been used
    iLineIndicator = ETrue;

    iSkipAndMarkPos = 0;

    TInt ret = ParseStartAndEndPos( iSection, aTag, aTagIndicator,
                                    startPos, endPos, length );

    // No parsing found
    if ( KErrNone != ret || length <= 0 || startPos < 0 )
        {
        __TRACE( 
            KInfo, ( _L( "STIFPARSER: GetItemLineL method returns a NULL" ) ) );
        return NULL;
        }

    CStifItemParser* line = CStifItemParser::NewL(
                                            iSection, startPos, length );

    return line;

    }
예제 #14
0
float SCurveData::GetCurveValue(float fProgress, float fStartTime, float fEndTime, const SCurveKey* pStartKey, const SCurveKey* pEndKey) const
{
    BEATS_ASSERT(BEATS_FLOAT_GREATER_EQUAL_EPSILON(fProgress, fStartTime, 0.001f) && BEATS_FLOAT_LESS_EQUAL_EPSILON(fProgress, fEndTime, 0.001f));
    BEATS_ASSERT(BEATS_FLOAT_GREATER_EQUAL_EPSILON(fStartTime, 0, 0.001f) && BEATS_FLOAT_LESS_EQUAL_EPSILON(fEndTime, 1.0f, 0.001f));
    static const float UNITY_YX_RATE = 0.625f; // The curve value depends on the coordinate rate: height / width
    CVec2 startPos(fStartTime, pStartKey->m_fValue * UNITY_YX_RATE);
    CVec2 endPos(fEndTime, pEndKey->m_fValue * UNITY_YX_RATE);
    static const float UNITY_MAGIC_FACTOR = 0.333333f;
    float tangLengthX = fabs(fStartTime - fEndTime) * UNITY_MAGIC_FACTOR;
    float tangLengthY = tangLengthX;
    float tgOut = pStartKey->m_fOutSlope * UNITY_YX_RATE;
    float tgIn = pEndKey->m_fInSlope * UNITY_YX_RATE;
    CVec2 startCtrlPos = startPos;
    CVec2 endCtrlPos = endPos;
    startCtrlPos.X() += tangLengthX;
    startCtrlPos.Y() += tangLengthY * tgOut;
    endCtrlPos.X() -= tangLengthX;
    endCtrlPos.Y() -= tangLengthY * tgIn;
    float s = (fProgress - fStartTime) / (fEndTime - fStartTime);
    float s2 = s * s;
    float s3 = s2 * s;
    float h1 = -s3 + 3 * s2 - 3 * s + 1;
    float h2 = s3;
    float h3 = 3 * s3 - 6 * s2 + 3 * s;
    float h4 = -3 * s3 + 3 * s2;
    CVec2 ret = startPos * h1 + endPos * h2 + startCtrlPos * h3 + endCtrlPos * h4;

    BEATS_ASSERT(fabs(fProgress - ret.X()) < 0.0001f);
    return ret.Y() / UNITY_YX_RATE;
}
예제 #15
0
void MainWindow::expand()
{
    //    qDebug() << "expand";
    const QPoint finishPos(0, 0);

    if (m_mainPanel->pos() == finishPos && m_mainPanel->size() == this->size())
        return;

    resetPanelEnvironment(true);

    if (m_panelShowAni->state() == QPropertyAnimation::Running)
        return m_panelShowAni->setEndValue(finishPos);

    const QSize size = m_settings->windowSize();

    QPoint startPos(0, 0);
    switch (m_settings->position())
    {
    case Top:       startPos.setY(-size.height());     break;
    case Bottom:    startPos.setY(size.height());      break;
    case Left:      startPos.setX(-size.width());      break;
    case Right:     startPos.setX(size.width());       break;
    }

    m_panelHideAni->stop();
    m_panelShowAni->setStartValue(startPos);
    m_panelShowAni->setEndValue(finishPos);
    m_panelShowAni->start();
}
예제 #16
0
void AbstractClipItem::resizeEnd(int posx, bool /*emitChange*/)
{
    GenTime durationDiff = GenTime(posx, m_fps) - endPos();
    if (durationDiff == GenTime()) return;
    if (cropDuration() + durationDiff <= GenTime()) {
        durationDiff = GenTime() - (cropDuration() - GenTime(3, m_fps));
    }

    m_info.cropDuration += durationDiff;
    m_info.endPos += durationDiff;

    setRect(0, 0, cropDuration().frames(m_fps) - 0.02, rect().height());
    if (durationDiff > GenTime()) {
        QList <QGraphicsItem *> collisionList = collidingItems(Qt::IntersectsItemBoundingRect);
        bool fixItem = false;
        for (int i = 0; i < collisionList.size(); ++i) {
            if (!collisionList.at(i)->isEnabled()) continue;
            QGraphicsItem *item = collisionList.at(i);
            if (item->type() == type() && item->pos().x() > pos().x()) {
                //kDebug() << "/////////  COLLISION DETECTED!!!!!!!!!";
                //kDebug() << "/////////  CURRENT: " << startPos().frames(25) << "x" << endPos().frames(25) << ", RECT: " << rect() << "-" << pos();
                //kDebug() << "/////////  COLLISION: " << ((AbstractClipItem *)item)->startPos().frames(25) << "x" << ((AbstractClipItem *)item)->endPos().frames(25) << ", RECT: " << ((AbstractClipItem *)item)->rect() << "-" << item->pos();
                GenTime diff = ((AbstractClipItem *)item)->startPos() - startPos();
                if (fixItem == false || diff < m_info.cropDuration) {
                    fixItem = true;
                    m_info.cropDuration = diff;
                }
            }
        }
        if (fixItem) setRect(0, 0, cropDuration().frames(m_fps) - 0.02, rect().height());
    }
}
예제 #17
0
/*
-------------------------------------------------------------------------------

    Class: CStifSectionParser

    Method: GetNextLine

    Description: Get a line with tag

    Search a next line with the required tag from the section. If start tag
    is empty the parsing starts beging of the section.

    Parameters: const TDesC& aTag: in: Indicates parsing start point
                TPtr& aLine: inout: Parsed line
                TTagToReturnValue aTagIndicator: in: Will aTag included to the
                returned value(For default the tag will be added)

    Return Values: TInt: Error code

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------
*/
EXPORT_C TInt CStifSectionParser::GetNextLine( const TDesC& aTag, TPtrC& aLine,
                                            TTagToReturnValue aTagIndicator )
    {
    TInt ret( KErrNone );

    // GetLine() or GetItemLineL() method is not called
    if ( !iLineIndicator )
        {
        return KErrNotReady;
        }

    TInt startPos( 0 );
    TInt endPos( 0 );
    TInt length( 0 );

    ret = ParseStartAndEndPos( iSection, aTag, aTagIndicator,
                                startPos, endPos, length );
    if ( KErrNone != ret )
        {
        // Nothing to parse
        return ret;
        }

    aLine.Set( &iSection[startPos], length );

    return KErrNone;

    }
예제 #18
0
void TCellKeyframeSelection::copyCellsKeyframes() {
  TCellKeyframeData *data = new TCellKeyframeData();
  // Copy cells
  int r0, c0, r1, c1;
  m_cellSelection->getSelectedCells(r0, c0, r1, c1);
  if (!isEmpty()) {
    int colCount = c1 - c0 + 1;
    int rowCount = r1 - r0 + 1;
    if (colCount <= 0 || rowCount <= 0) return;
    TXsheet *xsh        = m_xsheetHandle->getXsheet();
    TCellData *cellData = new TCellData();
    cellData->setCells(xsh, r0, c0, r1, c1);
    data->setCellData(cellData);
  }
  // Copy keyframes
  if (!isEmpty()) {
    QClipboard *clipboard       = QApplication::clipboard();
    TXsheet *xsh                = m_xsheetHandle->getXsheet();
    TKeyframeData *keyframeData = new TKeyframeData();
    TKeyframeData::Position startPos(r0, c0);
    keyframeData->setKeyframes(m_keyframeSelection->getSelection(), xsh,
                               startPos);
    data->setKeyframeData(keyframeData);
  }
  // Set the cliboard
  QClipboard *clipboard = QApplication::clipboard();
  clipboard->setMimeData(data, QClipboard::Clipboard);
}
예제 #19
0
  QRectF TOPPASEdge::boundingRect() const
  {
    qreal min_x = startPos().x() < endPos().x() ? startPos().x() : endPos().x();
    qreal min_y = startPos().y() < endPos().y() ? startPos().y() : endPos().y();
    qreal max_x = startPos().x() > endPos().x() ? startPos().x() : endPos().x();
    qreal max_y = startPos().y() > endPos().y() ? startPos().y() : endPos().y();

    return QRectF(QPointF(min_x - 11.0, min_y - 11.0), QPointF(max_x + 11.0, max_y + 11.0));
  }
예제 #20
0
/****************************************************************
 * Generate Maze
 ****************************************************************/
void PhotoMaze :: huntAndKill(){
    Vec2D<int> startPos((int)(ofRandom(1)*rw), (int)(ofRandom(1)*rh));
    while (startPos.x != -1) {
        rWalk(startPos);
        startPos = hunt();
    }
    fillImage();
}
예제 #21
0
파일: gkRecast.cpp 프로젝트: Ali-il/gamekit
bool gkRecast::findPath(PDT_NAV_MESH navMesh, const gkVector3& from, const gkVector3& to, const gkVector3& polyPickExt, int maxPathPolys, PATH_POINTS& path, unsigned short includeFlags, unsigned short excludeFlags)
{
	GK_ASSERT(!(includeFlags & excludeFlags) && "includeFlags with excludeFlags cannot overlap");

	if (navMesh.get() && navMesh->m_p)
	{
		gkVector3 startPos(from);
		gkVector3 endPos(to);

		std::swap(startPos.y, startPos.z);
		std::swap(endPos.y, endPos.z);

		dtQueryFilter filter;
		filter.includeFlags = includeFlags;
		filter.excludeFlags = excludeFlags;

		dtPolyRef startRef = navMesh->m_p->findNearestPoly(startPos.ptr(), polyPickExt.ptr(), &filter, 0);

		dtPolyRef endRef = navMesh->m_p->findNearestPoly(endPos.ptr(), polyPickExt.ptr(), &filter, 0);

		if (startRef && endRef)
		{
			utArray<dtPolyRef> polys;
			polys.resize(maxPathPolys);

			int npolys = navMesh->m_p->findPath(startRef, endRef, startPos.ptr(), endPos.ptr(), &filter, polys.ptr(), maxPathPolys);

			if (npolys > 1)
			{
				path.clear();

				utArray<gkScalar> straightPath;
				straightPath.resize(maxPathPolys * 3);

				int nstraightPath = navMesh->m_p->findStraightPath(startPos.ptr(), endPos.ptr(), polys.ptr(), npolys, straightPath.ptr(), 0, 0, maxPathPolys);

				std::swap(startPos.y, startPos.z);
				std::swap(endPos.y, endPos.z);

				gkVector3 point;

				for (int i = 0; i < nstraightPath * 3; i += 3)
				{
					point.x = straightPath[i];
					point.y = straightPath[i+2];
					point.z = straightPath[i+1];

					path.push_back(point);
				}

				return true;
			}
		}
	}

	return false;
}
예제 #22
0
  QPainterPath TOPPASEdge::shape() const
  {
    QPainterPath shape_1;
    shape_1.moveTo(startPos() + QPointF(-10, -10));
    shape_1.lineTo(endPos() + QPointF(-10, -10));
    shape_1.lineTo(endPos() + QPointF(10, 10));
    shape_1.lineTo(startPos() + QPointF(10, 10));
    shape_1.closeSubpath();

    QPainterPath shape_2;
    shape_2.moveTo(startPos() + QPointF(-10, 10));
    shape_2.lineTo(endPos() + QPointF(-10, 10));
    shape_2.lineTo(endPos() + QPointF(10, -10));
    shape_2.lineTo(startPos() + QPointF(10, -10));
    shape_2.closeSubpath();

    return shape_1.united(shape_2);
  }
예제 #23
0
 float
 POVRayParser::ParseFloat(std::string& token)
 {
    std::string startChars("-.0123456789");
    std::string endChars("0123456789");
    std::string::size_type startPos(token.find_first_of(startChars));
    std::string::size_type stopPos(token.find_last_of(endChars)+1);
    token = token.substr(startPos, stopPos - startPos);
    return boost::lexical_cast<float>(token);
 }
void RefactorerWindow::setSelectionInfo()
{
    QString sel = "Inter: ";
    sel += QString::number( startPos());
    sel += " - ";
    sel += QString::number( endPos() );
    sel += " Impl: ";
    sel += QString::number( ui->implementationText->textCursor().selectionStart());
    sel += " - ";
    sel += QString::number( ui->implementationText->textCursor().selectionEnd() );
     statusBar()->showMessage(sel);
}
예제 #25
0
QDomElement Transition::toXML()
{
    m_parameters.setAttribute(QStringLiteral("type"), transitionTag());
    //m_transitionParameters.setAttribute("inverted", invertTransition());
    m_parameters.setAttribute(QStringLiteral("transition_atrack"), track());
    m_parameters.setAttribute(QStringLiteral("transition_btrack"), m_transitionTrack);
    m_parameters.setAttribute(QStringLiteral("start"), startPos().frames(m_fps));
    m_parameters.setAttribute(QStringLiteral("end"), endPos().frames(m_fps));
    m_parameters.setAttribute(QStringLiteral("force_track"), m_forceTransitionTrack);
    m_parameters.setAttribute(QStringLiteral("automatic"), m_automaticTransition);
    return m_parameters.cloneNode().toElement();
}
예제 #26
0
bool IdSpecParser::parse(vespalib::stringref s)
{
    bool retval(false);
    size_t pos(eatWhite(s.data(), s.size()));
    if (pos+1 < s.size()) {
        if (icmp(s[pos], 'i') && icmp(s[pos+1],'d')) {
            pos += 2;
            if (pos < s.size()) {
                switch (s[pos]) {
                case '.':
                    {
                        int widthBits(-1);
                        int divisionBits(-1);
                        size_t startPos(++pos);
                        for (;(pos < s.size()) && (tolower(s[pos]) >= 'a') && (tolower(s[pos]) <= 'z'); pos++);
                        size_t len(pos - startPos);
                        if (((len == 4) && (strncasecmp(&s[startPos], "user", 4) == 0 ||
                                            strncasecmp(&s[startPos], "type", 4) == 0)) ||
                            ((len == 5) && (strncasecmp(&s[startPos], "group", 5) == 0)) ||
                            ((len == 6) && (strncasecmp(&s[startPos], "scheme", 6) == 0)) ||
                            ((len == 8) && (strncasecmp(&s[startPos], "specific", 8) == 0)) ||
                            ((len == 9) && (strncasecmp(&s[startPos], "namespace", 9) == 0)))
                        {
                            retval = true;
                            setValue(ValueNode::UP(new IdValueNode(_bucketIdFactory, "id", s.substr(startPos, len), widthBits, divisionBits)));
                        } else {
                            pos = startPos;
                        }
                    }
                    break;
                case '!':
                case '<':
                case '>':
                case '=':
                case '\t':
                case '\n':
                case '\r':
                case ' ':
                    {
                        retval = true;
                        setValue(ValueNode::UP(new IdValueNode(_bucketIdFactory, "id", "")));
                    }
                    break;
                default:
                    break;
                }
            }
        }
    }
    setRemaining(s.substr(pos));
    return retval;
}
예제 #27
0
size_t CNode::endPos()
{
	switch(mpNode->type)
	{
	  case GUMBO_NODE_ELEMENT:
		  return mpNode->v.element.end_pos.offset;
	  case GUMBO_NODE_TEXT:
		  return mpNode->v.text.original_text.length + startPos();
	  default:
		  return 0;
  }

}
예제 #28
0
void GridEmitter::init( ParticleArray *particles )
{
    for ( int p = 0; p < p_N; p++ )
    {
        const Vector2d pos = startPos( p );
        const Vector2d vel = startVel( p );

        if ( channel->outsideBox( pos ) == P_INSIDE )
            particles->add( Particle( pos, vel ) );
        else
            left_over++;
    }
}
예제 #29
0
void TargetDirectionHypothesis::saveResults() {
	Hypothesis::saveResults();

	osg::Vec2 startPos(mStartPos.x(), mStartPos.y());

	for (unsigned int i=0; i < mCommands.size(); i++) {
		HypothesisResult* r = mResults[i]->getResult();
		r->setLabel(getName() + "TargetDir" + boost::lexical_cast<std::string>(i));
		r->addTarget(mBlueUnits[i]);
		std::vector<osg::Vec2> path;
		path.push_back(startPos);
		path.push_back(osg::Vec2(mEndPos[i].x(), mEndPos[i].y()));
		r->addPoints(path, HypothesisResult::WORLD);
	}
}
예제 #30
0
void plAnimatedMovementStrategy::IRecalcLinearVelocity(float elapsed, hsMatrix44 &prevMat, hsMatrix44 &curMat)
{
    hsPoint3 startPos(0.0f, 0.0f, 0.0f);                    // default position (at start of anim)
    hsPoint3 prevPos = prevMat.GetTranslate();              // position previous frame
    hsPoint3 nowPos = curMat.GetTranslate();                // position current frame

    hsVector3 prev2Now = (hsVector3)(nowPos - prevPos);     // frame-to-frame delta

    if (fabs(prev2Now.fX) < 0.0001f && fabs(prev2Now.fY) < 0.0001f && fabs(prev2Now.fZ) < 0.0001f)
    {
        fAnimLinearVel.Set(0.f, 0.f, 0.f);
    }
    else
    {
        hsVector3 start2Now = (hsVector3)(nowPos - startPos);    // start-to-frame delta

        float prev2NowMagSqr = prev2Now.MagnitudeSquared();
        float start2NowMagSqr = start2Now.MagnitudeSquared();

        float dot = prev2Now.InnerProduct(start2Now);

        // HANDLING ANIMATION WRAPPING:
        // the vector from the animation origin to the current frame should point in roughly
        // the same direction as the vector from the previous animation position to the
        // current animation position.
        //
        // If they don't agree (dot < 0,) then we probably mpst wrapped around.
        // The right answer would be to compare the current frame to the start of
        // the anim loop, but it's cheaper to cheat and use the previous frame's velocity.
        if (dot > 0.0f)
        {
            prev2Now /= elapsed;

            float xfabs = fabs(prev2Now.fX);
            float yfabs = fabs(prev2Now.fY);
            float zfabs = fabs(prev2Now.fZ);
            static const float maxVel = 20.0f;
            bool valid = xfabs < maxVel && yfabs < maxVel && zfabs < maxVel;

            if (valid)
            {
                fAnimLinearVel = prev2Now;
            }
        }
    }
}