C++ (Cpp) Vector2D::lengthSquared Examples

Example #1

File: gestureeventfilter.cpp Project: adrianomelo/libgestures

void PinchEventFilter::filter(GestureTouchEvent *ev)
{
    if (!ev)
        return;

    if (ev->numTouchPoints != 2) {
        reset();
        return;
    }

    Vector2D p0(ev->touchPoints[0].x, ev->touchPoints[0].y);
    Vector2D p1(ev->touchPoints[1].x, ev->touchPoints[1].y);

    if (m_p0.isNull() && m_p1.isNull()) {
        m_p0 = p0;
        m_p1 = p1;
    }

    Vector2D diffA = (m_p0 - p0);
    Vector2D diffB = (m_p1 - p1);

    if (diffA.lengthSquared() > MIN_MOVEMENT_LENGTH_SQUARED
           && diffB.lengthSquared() > MIN_MOVEMENT_LENGTH_SQUARED)
        ev->flags |= GestureTouchEvent::GESTURE_EVENT_CAN_RECOGNIZE_DIRECTION;
    else
        ev->flags &= ~GestureTouchEvent::GESTURE_EVENT_CAN_RECOGNIZE_DIRECTION;

}

Example #2

File: user.cpp Project: weimingtom/mmomm

double User::score(const PacketValue& value, const Vector2D& reference)
{
	const Actor *actor = value.first;
	const Vector2D actorPosition = actor->getPosition();
	
	// Score based on x and y distance
	const Vector2D ASPECT(20.0 / 25.0, 15.0 / 25.0);
	const double DISTANCE_FACTOR = 20;
	
	Vector2D distance = ASPECT.memberwiseMult(reference - actorPosition);
	double distanceScore = DISTANCE_FACTOR * distance.lengthSquared();
	
	const double TIME_FACTOR = 100;
	double time = FrameTimer::current().frameTime() - value.second.time;
	double timeScore = -TIME_FACTOR * (time * time);
	
	const double DISPLACEMENT_FACTOR = 5;
	const double VELOCITY_FACTOR = 10;

	Vector2D displacement = ASPECT.memberwiseMult(actorPosition - value.second.position);
	Vector2D velocity = ASPECT.memberwiseMult(actor->getVelocity() - value.second.velocity);
	
	double displacementScore = -DISPLACEMENT_FACTOR * displacement.lengthSquared();
	double velocityScore = -VELOCITY_FACTOR * velocity.lengthSquared();
	
	return distanceScore + timeScore + displacementScore + velocityScore;
}

Example #3

File: flip_solver2_tests.cpp Project: sumitneup/fluid-engine-dev

JET_END_TEST_F

JET_BEGIN_TEST_F(FlipSolver2, Rotation) {
    // Build solver
    auto solver = FlipSolver2::builder()
        .withResolution({10, 10})
        .withDomainSizeX(1.0)
        .makeShared();

    solver->setGravity({0, 0});
    solver->setPressureSolver(nullptr);

    // Build emitter
    auto box = Sphere2::builder()
        .withCenter({0.5, 0.5})
        .withRadius(0.4)
        .makeShared();

    auto emitter = VolumeParticleEmitter2::builder()
        .withSurface(box)
        .withSpacing(1.0 / 20.0)
        .withIsOneShot(true)
        .makeShared();

    solver->setParticleEmitter(emitter);

    Array1<double> r;

    for (Frame frame; frame.index < 360; ++frame) {
        auto x = solver->particleSystemData()->positions();
        auto v = solver->particleSystemData()->velocities();
        r.resize(x.size());
        for (size_t i = 0; i < x.size(); ++i) {
            r[i] = (x[i] - Vector2D(0.5, 0.5)).length();
        }

        solver->update(frame);

        if (frame.index == 0) {
            x = solver->particleSystemData()->positions();
            v = solver->particleSystemData()->velocities();
            for (size_t i = 0; i < x.size(); ++i) {
                Vector2D rp = x[i] - Vector2D(0.5, 0.5);
                v[i].x = rp.y;
                v[i].y = -rp.x;
            }
        } else {
            for (size_t i = 0; i < x.size(); ++i) {
                Vector2D rp = x[i] - Vector2D(0.5, 0.5);
                if (rp.lengthSquared() > 0.0) {
                    double scale = r[i] / rp.length();
                    x[i] = scale * rp + Vector2D(0.5, 0.5);
                }
            }
        }

        saveParticleDataXy(solver->particleSystemData(), frame.index);
    }
}

Example #4

File: custom_implicit_surface2.cpp Project: doyubkim/fluid-engine-dev

Vector2D CustomImplicitSurface2::closestNormalLocal(
    const Vector2D& otherPoint) const {
    Vector2D pt = closestPointLocal(otherPoint);
    Vector2D g = gradientLocal(pt);
    if (g.lengthSquared() > 0.0) {
        return g.normalized();
    } else {
        return g;
    }
}