コード例 #1
0
ファイル: Material.cpp プロジェクト: john1995/raytracer
void Material::fresnelDielectric(const QVector3D &d, const QVector3D &normal, float ni, float nt, QVector<QPair<float, QVector3D> > &rays)
{
    QVector3D n = normal;
    float ndd = QVector3D::dotProduct(n, d);
    if (ndd > -Config::Epsilon && ndd < Config::Epsilon) {
        return ;
    }
    if (ndd > 0) {
        n *= -1;
        ndd *= -1;
    }
    QVector3D r = d - 2.0f * ndd * n;
    r.normalize();

    QVector3D z = (d - ndd * n) * ni / nt;
    float z2 = z.lengthSquared();

    if (z2 >= 1.0f) {
        rays.append(QPair<float, QVector3D>(1.0f, r));
        return ;
    }

    QVector3D t = z - qSqrt(1.0f - z2) * n;
    t.normalize();

    float ndt = QVector3D::dotProduct(n, t);
    float rPar = (nt * ndd - ni * ndt) / (nt * ndd + ni * ndt);
    float rPerp = (ni * ndd - nt * ndt) / (ni * ndd + nt * ndt);
    float fr = 0.5f * (rPar * rPar + rPerp * rPerp);

    rays.append(QPair<float, QVector3D>(fr, r));
    rays.append(QPair<float, QVector3D>(1.0f - fr, t));
}
コード例 #2
0
ファイル: window.cpp プロジェクト: giucam/trainsplanet
void Window::mouseMoveEvent(QMouseEvent *event)
{
    if (!m_mouseDown) {
        m_terrain->pick(QPointF(event->localPos().x() / 1024, event->localPos().y() / 768), m_projection, m_view);
        return;
    }

    QPointF delta = event->localPos() - m_mousePos;

    QMatrix4x4 mat;
    mat.rotate(m_camera.orientation);

    QVector3D pitchAxis = QVector3D(mat(0, 0), mat(0, 1), mat(0, 2));
    pitchAxis.normalize();

    m_camera.orientation *= QQuaternion::fromAxisAndAngle(pitchAxis, perSecond(delta.y() / 200));
    m_camera.orientation.normalize();

    QVector3D yawAxis = QVector3D(mat(1, 0), mat(1, 1), mat(1, 2));
    yawAxis.normalize();

    m_camera.orientation *= QQuaternion::fromAxisAndAngle(yawAxis, perSecond(delta.x() / 200));
    m_camera.orientation.normalize();


    m_needsUpdate = true;

    m_mousePos = event->localPos();
}
コード例 #3
0
void QAudioEngine::updateListenerOrientation()
{
    QVector3D dir = m_listenerDirection;
    QVector3D up = m_listenerUp;
    dir.normalize();
    up.normalize();
    QVector3D u = up - dir * QVector3D::dotProduct(dir, up);
    u.normalize();
    d->setListenerOrientation(dir, u);
}
コード例 #4
0
ファイル: camera.cpp プロジェクト: asmolen/simulator-1
void Camera::moveXY(QPoint p)
{
	QVector3D v = step_;
	v.setZ(0.0);
	v.normalize();
	pos_ += v*(p.ry()*0.003f);
	v[0] = step_[1];
	v[1] = -step_[0];
	v.normalize();
	pos_ -= v*(p.rx()*0.003f);
}
コード例 #5
0
ファイル: quiddiards.cpp プロジェクト: silencious/Quiddiards
void Quiddiards::keyPressEvent(QKeyEvent *event){
	switch (event->key()) {
	case Qt::Key_F2:
		actStart();
		break;
	case Qt::Key_P:
		actPause();
		break;
	case Qt::Key_Escape:
	case Qt::Key_Q:
		close();
		break;
	case Qt::Key_Space:
	case Qt::Key_Enter:
	case Qt::Key_Return:
		break;
	case Qt::Key_W:{
		/* forward cueball */
		QVector3D n = -eye;
		n.setZ(0);
		n.normalize();
		n += cueball.getVelocity();
		if (n.length() > cueball.getSpeed()){
			n = cueball.getSpeed()*n.normalized();
		}
		cueball.setVelocity(n);
		break;
	}
	case Qt::Key_A:
		phi += 10;
		break;
	case Qt::Key_S:{
		QVector3D n = eye;
		n.setZ(0);
		n.normalize();
		n += cueball.getVelocity();
		if (n.length() > cueball.getSpeed()){
			n = cueball.getSpeed()*n.normalized();
		}
		cueball.setVelocity(n);
		break;
	}
	case Qt::Key_D:
		phi -= 10;
		break;
	case Qt::Key_Tab:
		//camera = CAMERA((camera + 1) % 2);
		break;
	default:
		return;
	}
	update();
}
コード例 #6
0
ファイル: MyGLWidget.cpp プロジェクト: velox1992/ARProject
void MyGLWidget::keyPressEvent(QKeyEvent *event)
{

    GLfloat   cameraSpeed = 1.0f ;
    QVector3D cross ;

    bool      changedFront = false ;
    switch ( event->key()) {
        case Qt::Key_W     : cameraPos += cameraSpeed * cameraFront ;
             break ;
        case Qt:: Key_S    : cameraPos -= cameraSpeed * cameraFront ;
             break ;
        case Qt::Key_A     : cross = cross.crossProduct(cameraFront , cameraUp) ;
                             cross.normalize();
                             cameraPos -= cross * cameraSpeed ;
             break ;
        case Qt::Key_D     : cross = cross.crossProduct(cameraFront , cameraUp) ;
                             cross.normalize();
                             cameraPos += cross * cameraSpeed ;
             break ;
        case Qt::Key_Up    : pitch += 1 ;
                             changedFront = true ;
             break ;
        case Qt::Key_Down  : pitch -= 1 ;
                             changedFront = true ;
             break ;
        case Qt::Key_Left  : yaw -= 1 ;
                             changedFront = true ;
             break ;
        case Qt::Key_Right : yaw += 1 ;
                             changedFront = true ;
             break ;
        case Qt::Key_P     : paused = !paused ;
             break ;
        case Qt::Key_R     : cameraPos = QVector3D(0.0f, 0.0f, 3.0f);
                             cameraFront = QVector3D(0.0f, 0.0f, -1.0f);
                             cameraUp = QVector3D(0.0f, 1.0f, 0.0f);
             break ;
        default : QGLWidget::keyPressEvent(event) ;
    }

    if (changedFront)
    {
    QVector3D front;
        front.setX ( cos(pitch*(M_PI/180)) * cos(yaw*(M_PI/180)) );
        front.setY ( sin(pitch*(M_PI/180) )  );
        front.setZ ( cos(pitch*(M_PI/180)) * sin(yaw*(M_PI/180)) );
        front.normalize();
        cameraFront = front ;
    }

}
コード例 #7
0
ファイル: camera.cpp プロジェクト: Calinou/AwesomeBump
void AwesomeCamera::rotateView(float z_angle,float x_angle){

//    rotM.setToIdentity();


    double cosPhi = cos(mouse_sens*(-z_angle)/180*M_PI);
    double sinPhi = sin(mouse_sens*(-z_angle)/180*M_PI);


    direction      = QVector3D(cosPhi*direction.x()+sinPhi*direction.z(),direction.y(),
                               cosPhi*direction.z()-sinPhi*direction.x());

    QMatrix4x4 rotMat;
    rotMat.setToIdentity();
    rotMat.rotate(mouse_sens*(-x_angle),QVector3D::crossProduct(direction,QVector3D(0,1,0)));
    QVector3D tmpVec = (rotMat*QVector4D(direction)).toVector3D();
    tmpVec.normalize();
    double angleTheta = QVector3D::dotProduct(tmpVec,QVector3D(0,1,0));
    if(qAbs(angleTheta) < 0.9){
        rotMat.setToIdentity();
        rotMat.rotate(mouse_sens*(-x_angle)*(1-qAbs(angleTheta)),QVector3D::crossProduct(direction,QVector3D(0,1,0)));
        QVector3D tmpVec = (rotMat*QVector4D(direction)).toVector3D();
        tmpVec.normalize();
        direction = tmpVec;
    }

    side_direction = QVector3D(cosPhi*side_direction.x()+sinPhi*side_direction.z(),0,
                               cosPhi*side_direction.z()-sinPhi*side_direction.x());

    updown_direction = QVector3D::crossProduct(direction,side_direction);



/*
    rot_angles[0] += mouse_sens*(z_angle);//przesuniecie X
    rot_angles[1] -= mouse_sens*(x_angle);//przesuniecie Y
    if(rot_angles[1] > 90) rot_angles[1] = 90;
    if(rot_angles[1] <-90) rot_angles[1] = -90;
//    przesuniecie do przodu
    direction = QVector3D(-sin(rot_angles[0]/180*M_PI),sin(rot_angles[1]/180*M_PI),cos(rot_angles[0]/180*M_PI));
//    przesuniece na boki
    side_direction = QVector3D(sin((rot_angles[0]+90)/180*M_PI),0,-cos((rot_angles[0]+90)/180*M_PI));
//    przesuwanie gora dol
    updown_direction = QVector3D::crossProduct(direction,side_direction);
*/

    direction.normalize();
    side_direction.normalize();
    updown_direction.normalize();

}
コード例 #8
0
ファイル: blinnmaterial.cpp プロジェクト: gidoca/renderer
cv::Vec3f BlinnMaterial::brdf(const HitRecord &hit, QVector3D direction) const
{
    QVector3D normal = hit.getSurfaceNormal();
    normal.normalize();
    QVector3D wo = -hit.getRay().getDirection().normalized();
    QVector3D wi = -direction.normalized();
    if(signum(QVector3D::dotProduct(normal, wo)) != signum(QVector3D::dotProduct(normal, wi)))
    {
        return cv::Vec3f();
    }
    if(QVector3D::dotProduct(normal, wo) < 0) normal *= -1;
    QVector3D wh = wi + wo;
    wh.normalize();
    return kd * (1 / M_PI) + ks * D(wh, normal) * G(wi, wo, normal) / (4 * QVector3D::dotProduct(wo, normal) * QVector3D::dotProduct(wi, normal));
}
コード例 #9
0
ファイル: abgabe3b.cpp プロジェクト: marvatom/GDV
void LightRendererFlat::meshChanged(const QVector<MeshLoader::Face> &faces){
    storedFaces.clear();

    for (MeshLoader::Face f : faces){
        Face newFace;
        for (int i = 0; i < 3; i++){
            newFace[i].position.setX(f[i].x);
            newFace[i].position.setY(f[i].y);
            newFace[i].position.setZ(f[i].z);
            newFace[i].position.setW(1.0);
            newFace[i].color.setX(f[i].r);
            newFace[i].color.setY(f[i].g);
            newFace[i].color.setZ(f[i].b);
        }

        QVector3D a = newFace[0].position.toVector3D();
        QVector3D b= newFace[1].position.toVector3D();
        QVector3D c = newFace[2].position.toVector3D();
        QVector3D normal = QVector3D::crossProduct(b - a, c - a);
        normal.normalize();
        newFace[0].normal = normal;
        newFace[1].normal = normal;
        newFace[2].normal = normal;

        storedFaces.append(newFace);
    }
}
コード例 #10
0
void SimpleRoadGraph::_generateMeshVertices(ucore::TextureManager* textureManager) {
	ucore::RenderableQuadList* renderable = new ucore::RenderableQuadList(textureManager->get("data/textures/street.jpg"));

	roadGraphEdgeIter ei, eend;
	for (boost::tie(ei, eend) = boost::edges(myRoadGraph); ei != eend; ++ei) {
		SimpleRoadGraphEdge* edge = &myRoadGraph[*ei];

		QVector3D pt1 = myRoadGraph[boost::source(*ei, myRoadGraph)].getPt();
		QVector3D pt2 = myRoadGraph[boost::target(*ei, myRoadGraph)].getPt();

		QVector3D vec = pt2 - pt1;
		vec = QVector3D(-vec.y(), vec.x(), 0.0f);
		vec.normalize();

		QVector3D p0 = pt1 + vec * edge->getWidth() / 2.0f + QVector3D(0, 0, heightAboveGround);
		QVector3D p1 = pt1 - vec * edge->getWidth() / 2.0f + QVector3D(0, 0, heightAboveGround);
		QVector3D p2 = pt2 - vec * edge->getWidth() / 2.0f + QVector3D(0, 0, heightAboveGround);
		QVector3D p3 = pt2 + vec * edge->getWidth() / 2.0f + QVector3D(0, 0, heightAboveGround);
		QVector3D normal = ucore::Util::calculateNormal(p0, p1, p2);

		//renderable2->addQuad(p0, p1, p2, p3, normal, color);
		renderable->addQuad(p0, p1, p2, p3, normal, 0, 1, 0, 1);
	}

	renderables.push_back(renderable);
}
コード例 #11
0
/*!
    \since 5.5

    Returns the shortest arc quaternion to rotate from the direction described by the vector \a from
    to the direction described by the vector \a to.

    \sa fromDirection()
*/
QQuaternion QQuaternion::rotationTo(const QVector3D &from, const QVector3D &to)
{
    // Based on Stan Melax's article in Game Programming Gems

    const QVector3D v0(from.normalized());
    const QVector3D v1(to.normalized());

    float d = QVector3D::dotProduct(v0, v1) + 1.0f;

    // if dest vector is close to the inverse of source vector, ANY axis of rotation is valid
    if (qFuzzyIsNull(d)) {
        QVector3D axis = QVector3D::crossProduct(QVector3D(1.0f, 0.0f, 0.0f), v0);
        if (qFuzzyIsNull(axis.lengthSquared()))
            axis = QVector3D::crossProduct(QVector3D(0.0f, 1.0f, 0.0f), v0);
        axis.normalize();

        // same as QQuaternion::fromAxisAndAngle(axis, 180.0f)
        return QQuaternion(0.0f, axis.x(), axis.y(), axis.z());
    }

    d = std::sqrt(2.0f * d);
    const QVector3D axis(QVector3D::crossProduct(v0, v1) / d);

    return QQuaternion(d * 0.5f, axis).normalized();
}
コード例 #12
0
ファイル: utils.cpp プロジェクト: Imarion/NormalMapTest
void utils::CalcNormals(const unsigned int* pIndices, unsigned int IndexCount,
                        VertexTex *pVertices, unsigned int VertexCount)
{
    unsigned int Index0;
    unsigned int Index1;
    unsigned int Index2;

    // Accumulate each triangle normal into each of the triangle vertices
    for (unsigned int i = 0; i < IndexCount; i += 3)
    {
        Index0 = pIndices[i];
        Index1 = pIndices[i+1];
        Index2 = pIndices[i+2];
        QVector3D v1 = pVertices[Index1].getPos() - pVertices[Index0].getPos();
        QVector3D v2 = pVertices[Index2].getPos() - pVertices[Index0].getPos();
        QVector3D Normal = QVector3D::crossProduct(v1, v2);
        Normal.normalize();

        pVertices[Index0].setNormal(pVertices[Index0].getNormal()+Normal);
        pVertices[Index1].setNormal(pVertices[Index1].getNormal()+Normal);
        pVertices[Index2].setNormal(pVertices[Index2].getNormal()+Normal);
    }

    // Normalize all the vertex normals
    for (unsigned int i = 0; i < VertexCount; i++) {
        pVertices[i].setNormal(pVertices[i].getNormal().normalized());
        qDebug() << "normal " << pVertices[i].getNormal();
    }
}
コード例 #13
0
vector<QVector3D> LayeredHairMesh::internalForces(const vector<QVector3D> &state) const
{
	vector<QVector3D> ifs(state.size(), QVector3D());
	float ks(5), kd(2), ko(1);
	int compSize = state.size() / 2;
	float lenSeg = compSize / seg;
	for (int i = 4; i < compSize; i ++)
	{
		// Spring restriction
		QVector3D dir = state[i - 4] - state[i];
		float deltaLen = dir.length() - restLen[i];
		dir.normalize();// *deltaLen;
		QVector3D fs = ks * dir * deltaLen;
		QVector3D fd = kd *
			QVector3D::dotProduct(
			state[i - 4 + compSize] - state[i + compSize], dir) * dir;

		// Constrant to original mesh
		float segU = (1 - (float)(i / seg) / lenSeg);
		QVector3D distDir = (points[i] - state[i]) * ko;

		ifs[i] = state[i + compSize];
		ifs[i + compSize] += fs + fd - state[i + compSize] * 0.1 + distDir;
		ifs[i - 4 + compSize] -= fs + fd;
	}
	for (int i = 0; i < 4; i++)
	{
		ifs[i] = QVector3D();
		ifs[i + compSize] = QVector3D();
	}
	return ifs;
}
コード例 #14
0
void BulletComponent::update(float delta)
{
    EnemyComponent *enemy = target->getComponent<EnemyComponent>();

    if(enemy != nullptr) {
        destination = target->getPosition();
    }
    QVector3D dir = -(this->getEntity()->getPosition() - destination);
    if(dir.length() < 10) {
        if(enemy != nullptr) {
            enemy->takeDamage(damage);
            QVector3D v = getEntity()->getPosition();
            v.setX(v.x() / 768);
            v.setY(v.y() / 624);
            v.setZ(0);

            FMODManager::getInstance()->setCurrentEvent("event:/hit");
            FMODManager::getInstance()->setEventInstancePosition(v);
            FMODManager::getInstance()->setEventInstanceVolume(0.4);
            FMODManager::getInstance()->setParameterValue("pitch", 0.3 + (qrand() % 200) * 0.001);
            FMODManager::getInstance()->startEventInstance();
        }

        this->getEntity()->release();
    } else {
        dir.normalize();
        this->getEntity()->setPosition(this->getEntity()->getPosition() + dir * speed * delta);
    }
}
コード例 #15
0
ファイル: bird.cpp プロジェクト: GriffinLedingham/Picking
QVector3D Bird::align(QVector<Bird> birds)
{
    float neighbordist = 50;
    QVector3D sum = QVector3D(0,0,0);
    int count = 0;
    QVector<Bird>::iterator bird;
    for(bird = birds.begin(); bird != birds.end(); bird++)
    {
        float d = (position - (*bird).position).length();
        if ((d > 0) && (d < neighbordist)) {
            sum+= (*bird).velocity;
            count++;
        }
    }
    if (count > 0)
    {
        sum /= (float)count;
        sum.normalize();
        sum *= maxvelocity;
        QVector3D steer = sum-velocity;
        limit(steer,maxforce);
        return steer;
    }
    else
    {
        return QVector3D(0,0,0);
    }
}
コード例 #16
0
void SphericalCalculator::addFace(std::vector<Face> &faces,const Point &a,const Point &b,const Point &c)
{
    Face f;
    f.x[0][0]=a.x[0];
    f.x[0][1]=a.x[1];
    f.x[0][2]=a.x[2];

    f.x[1][0]=b.x[0];
    f.x[1][1]=b.x[1];
    f.x[1][2]=b.x[2];

    f.x[2][0]=c.x[0];
    f.x[2][1]=c.x[1];
    f.x[2][2]=c.x[2];

    QVector3D aa(f.x[0][0],f.x[0][1],f.x[0][2]);
    QVector3D bb(f.x[1][0],f.x[1][1],f.x[1][2]);
    QVector3D cc(f.x[2][0],f.x[2][1],f.x[2][2]);

    QVector3D nv;
    nv=-QVector3D::crossProduct(bb-aa,cc-aa);
    nv.normalize();
    f.n[0]=nv.x();
    f.n[1]=nv.y();
    f.n[2]=nv.z();
    
     faces.push_back(f);
    
}
コード例 #17
0
ファイル: trackball.cpp プロジェクト: zhangk430/MeshViewer
void TrackBall::move(const QPointF& p)
{
	if (!m_pressed)
		return;
	QVector3D lastPos3D = QVector3D(m_lastPos.x(), m_lastPos.y(), 0.0f);
	float sqrZ = 1 - QVector3D::dotProduct(lastPos3D, lastPos3D);
	if (sqrZ > 0)
		lastPos3D.setZ(sqrt(sqrZ));
	else
		lastPos3D.normalize();

	QVector3D currentPos3D = QVector3D(p.x(), p.y(), 0.0f);
	sqrZ = 1 - QVector3D::dotProduct(currentPos3D, currentPos3D);
	if (sqrZ > 0)
		currentPos3D.setZ(sqrt(sqrZ));
	else
		currentPos3D.normalize();

	QVector3D axis = QVector3D::crossProduct(lastPos3D, currentPos3D);
	float angle = 360 / PI * asin(sqrt(QVector3D::dotProduct(axis, axis)));

	axis.normalize();
	m_rotation = QQuaternion::fromAxisAndAngle(axis, angle) * m_rotation;

	m_lastPos = p;
}
コード例 #18
0
ファイル: blinnmaterial.cpp プロジェクト: gidoca/renderer
float G(const QVector3D& wi, const QVector3D& wo, const QVector3D& normal)
{
    using std::min;
    QVector3D wh = wi + wo;
    wh.normalize();
    return min(1.f, 2 * QVector3D::dotProduct(normal, wh) * min(QVector3D::dotProduct(normal, wo), QVector3D::dotProduct(normal, wi)) / QVector3D::dotProduct(wo, wh));
}
コード例 #19
0
ファイル: mathutil.cpp プロジェクト: jaxzin/firebox
QVector3D MathUtil::Slerp(QVector3D p1, QVector3D p2, float i)
{

    p1.normalize();
    p2.normalize();

    QVector3D c = QVector3D::crossProduct(p1, p2);
    if (c.length() < 0.001f)
        c = QVector3D(0, 1, 0);
    c.normalize();

    float angle = acosf(QVector3D::dotProduct(p1, p2));

    return GetRotatedAxis(i * angle, p1, c);

}
コード例 #20
0
ファイル: sathorizon.cpp プロジェクト: hvanruys/EUMETCastView
void SatHorizon::render(QMatrix4x4 projection, float distance, QQuaternion quat, QVector3D posnorm, float alt, QColor rendercolor)
{

    float radius = sqrt( alt * alt - 1 ) / alt;

    float theta = acos(QVector3D::dotProduct(QVector3D(0,0,1), posnorm));
    QVector3D vecnorm = QVector3D::crossProduct(QVector3D(0,0,1), posnorm);
    vecnorm.normalize();

    createCircleBuffer(radius, SEGMENTS);

    QMatrix4x4 modelview;
    modelview.translate(0.0, 0.0, distance);
    modelview.rotate(quat);

    modelview.translate(posnorm * (1/alt) * (alt > 1.5 ? 1.0015 : 1.0001));
    modelview.rotate(theta * 180.0f/ PI, vecnorm );

    posBuf.bind();
    posBuf.write(0, vertexData, SEGMENTS * sizeof(QVector3D));
    posBuf.release();

    program->bind();

    program->setUniformValue("MVP", projection * modelview);
    QMatrix3x3 norm = modelview.normalMatrix();
    program->setUniformValue("NormalMatrix", norm);

    program->setUniformValue("outcolor", QVector4D(rendercolor.redF(), rendercolor.greenF(), rendercolor.blueF(), 1.0f));
    QOpenGLVertexArrayObject::Binder vaoBinder(&vao);
    glDrawArrays(GL_LINE_LOOP, 0, SEGMENTS);

}
コード例 #21
0
ファイル: PlanetElement.cpp プロジェクト: martinruenz/liblub
void PlanetElement::setAtmoUniforms(ShaderProgram * program) {
  updateWaveLength(program);

  QVector3D lightPosition = SceneData::Instance().getLight("sunlight")->position;
  QVector3D lightDirection = lightPosition - planet->position;
  lightDirection.normalize();

  float rayleigh = 0.0025f; // Rayleigh scattering constant
  float rayleigh4Pi = rayleigh * 4.0f * M_PI;
  float mie = 0.0010f; // Mie scattering constant
  float mie4Pi = mie * 4.0f * M_PI;
  float sun = 20.0f; // Sun brightness constant
  float g = -0.990f; // The Mie phase asymmetry factor

  //    float mieScaleDepth = 0.1f;

  program->use();
  program->setUniform("lightPosition", lightDirection);

  program->setUniform("rayleighSun", rayleigh * sun);
  program->setUniform("mieSun", mie * sun);
  program->setUniform("rayleigh4Pi", rayleigh4Pi);
  program->setUniform("mie4Pi", mie4Pi);

  program->setUniform("g", g);
  program->setUniform("g2", g * g);
  program->setUniform("useRayleigh", planet->useRayleigh);
  program->setUniform("useMie", planet->useMie);
  program->setUniform("attenuation", planet->useAttenuation);
}
コード例 #22
0
ファイル: ReferenceWidget.cpp プロジェクト: KrystianD/YAS3D
void ReferenceWidget::draw ()
{
	QPainter p (this);

	const int MOTOR_RADIUS = 20 / 2 * 3;
	const int MOTOR_DISTANCE = 17.5 * 3;

	p.fillRect (rect (), Qt::white);

	p.setPen (QPen (QColor (0, 0, 0, 255)));
	p.drawLine (20, 20, 180, 20);

	//p.setPen (QPen (QColor (0, 0, 0, 255)));
	//p.drawEllipse (QPoint (width () / 2 + px * MOTOR_DISTANCE, height () / 2 - py * MOTOR_DISTANCE), 3, 3);

	QVector3D quadroMagn (-my, mx, -mz);
	quadroMagn.normalize ();

	QVector3D quadroAccel (ax, ay, az);
	quadroAccel.normalize ();

	p.setPen (QPen (QColor (0, 0, 255, 255), 2));
	p.drawLine (100, 20, 50 + quadroMagn.y (), 20 + quadroMagn.z ());

	/*p.setPen (QPen (QColor (0, 0, 0, 255)));

	p.setBrush (QBrush (QColor (255, 0, 0, m1)));
	p.drawEllipse (QPoint (width () / 2 - MOTOR_DISTANCE, height () / 2), MOTOR_RADIUS, MOTOR_RADIUS);
	p.setBrush (QBrush (QColor (255, 0, 0, m3)));
	p.drawEllipse (QPoint (width () / 2 + MOTOR_DISTANCE, height () / 2), MOTOR_RADIUS, MOTOR_RADIUS);
	p.setBrush (QBrush (QColor (255, 0, 0, m2)));
	p.drawEllipse (QPoint (width () / 2, height () / 2 - MOTOR_DISTANCE), MOTOR_RADIUS, MOTOR_RADIUS);
	p.setBrush (QBrush (QColor (255, 0, 0, m4)));
	p.drawEllipse (QPoint (width () / 2, height () / 2 + MOTOR_DISTANCE), MOTOR_RADIUS, MOTOR_RADIUS);

	p.setBrush (QBrush (QColor (255, 0, 0, 255)));
	p.setPen (QPen (QColor (0, 0, 0, 255)));
	p.drawEllipse (QPoint (width () / 2, height () / 2), 3, 3);

	p.setBrush (QBrush (QColor (255, 0, 0, 255)));
	p.setPen (QPen (QColor (0, 0, 0, 255)));
	p.drawEllipse (QPoint (width () / 2 + px * MOTOR_DISTANCE, height () / 2 - py * MOTOR_DISTANCE), 3, 3);

	p.setBrush (QBrush (QColor (0, 255, 0, 255)));
	p.setPen (QPen (QColor (0, 0, 0, 255)));
	p.drawEllipse (QPoint (width () / 2 + px2 * MOTOR_DISTANCE, height () / 2 - py2 * MOTOR_DISTANCE), 3, 3);*/
}
コード例 #23
0
ファイル: modelrenderer.cpp プロジェクト: osamu-k/QtStudy
QVector3D ModelRenderer::createPolygonNormal( QVector3D a, QVector3D b, QVector3D c ) {

    QVector3D ab( b - a );
    QVector3D bc( c - b );
    QVector3D normal = QVector3D::crossProduct( ab, bc );	//AB BCの外積
    normal.normalize();//単位ベクトルにする
    return normal;
}
コード例 #24
0
ファイル: cam.cpp プロジェクト: ragemcmad/CGBillard
void myCam::aktivatePlaymode(QVector3D kugelWhite, int abstand)
{
    this->activePlaymode = true;
    this->distanz = abstand;
    this->kugelWhite = kugelWhite;

    QVector3D position;
    position.setX(kugelWhite.x());
    position.setY(kugelWhite.y());
    position.setZ(kugelWhite.z());
    if(position.x()==0 && position.y()==0 && position.z() == 0)
    {
        position.setZ(-1);
    }
    position.normalize();
    position.setX(position.x()*abstand + kugelWhite.x());
    position.setY(8);
    position.setZ(position.z()*abstand + kugelWhite.z());
    //this->viewMatrix.setToIdentity();
    //this->viewMatrix.lookAt(position,kugelWhite,QVector3D(0,1,0));
    this->queueAnimation(position,kugelWhite,100);
    position = position-kugelWhite;

    if(position.x()>0 && position.z()>0)
    {
        this->angleY = atan(position.z()/position.x())*180/3.1415926-90;
    }
    else if(position.x()<0 && position.z()>0)
    {
        this->angleY = atan(-position.x()/position.z())*180/3.1415926;
    }
    else if(position.x()<0 && position.z()<0)
    {
        this->angleY = atan(position.z()/position.x())*180/3.1415926+90;
    }
    else if(position.x()>0 && position.z()<0)
    {
        this->angleY = atan(position.x()/-position.z())*180/3.1415926+180;
    }
    else if(position.x() == 0)
    {
        if(position.z()>0)
            this->angleY = 0;
        else
            this->angleY = 180;
    }
    else if(position.z() == 0)
    {
        if(position.x()>0)
            this->angleY = 270;
        else
            this->angleY = 90;
    }
    this->angleX = 15;
    this->camRotate(0,0);
    this->freeCameramode = false;
}
コード例 #25
0
ファイル: cube.cpp プロジェクト: heroboec/cube2
QVector3D cube::getCameraVector(PointDDD& polyPoint)
{
    PointDDD cameraPos;
    cameraPos.setX(SCREENDIST * sin(m_omega) * cos(m_phi));
    cameraPos.setY(SCREENDIST * sin(m_omega) * sin(m_phi));
    cameraPos.setZ(SCREENDIST * cos(m_omega));
    QVector3D res = createVectorByPoint(polyPoint,cameraPos);
    res.normalize();
    return res;
}
コード例 #26
0
ファイル: glwidget.cpp プロジェクト: tv/cg
void GLWidget::checkClick(QMouseEvent *event)
{

    QMatrix4x4 view = this->camera->getMatrix();
    QMatrix4x4 perspective = this->camera->projection;

    GLfloat zNear = 0.0f,
            zFar  = 50.0f;

    qreal w = this->_screenWidth,
          h = this->_screenHeight,
          X = (event->x()-w/2)/(w/2),
          Y = -(event->y()-h/2)/(h/2);


    QVector3D rayVector;
    QVector4D nearPoint, farPoint;


    QMatrix4x4 invPV = (view*perspective).inverted();
    QVector4D  out = QVector4D(X, Y, zNear, 1.0);

    nearPoint = invPV * out;

    out = QVector4D(X, Y, zFar, 1.0);

    farPoint = invPV * out;

    rayVector = farPoint.toVector3D() - nearPoint.toVector3D();

    rayVector.normalize();

    qreal minZ = 100.0f, z;

    for (int i = 0, length = this->_objects.size(); i < length; i++) {
        QLObject* object = this->_objects.at(i);
        z = object->isHit(rayVector, minZ);
        if (z < minZ) {

            qDebug() << z << i;
            minZ = z;
            this->selectedIndex = i;

        }
    }

    if (minZ < 100.0f &&event->buttons() & Qt::LeftButton) {
        this->_objects.at(this->selectedIndex)->clicked();
    } else {
        qDebug() << "NO HIT :/!!" << nearPoint;
    }


    return;
}
コード例 #27
0
ファイル: maths.cpp プロジェクト: jhud/abtsynth
/*
    multLookAt -- Create a matrix to make an object, such as
        a camera, "look at" another object or location, from
        a specified position.

    Algorithm:
        The desired transformation is obtained with this 4x4 matrix:
            |  [xaxis] 0  |
            |    [up]  0  |
            |   [-at]  0  |
            |   [eye]  1  |
        Where 'xaxis', 'up' and 'at' are the new X, Y, and Z axes of
        the transforned object, respectively, and 'eye' is the input
        new location of the transformed object.

    Assumptions:
        The camera geometry is defined to be facing
        the negative Z axis.

    Usage:
        multLookAt creates a matrix and multiplies it onto the
        current matrix stack. Typical usage would be as follows:

            glMatrixMode (GL_MODELVIEW);
            // Define the usual view transformation here using
            //   gluLookAt or whatever.
            glPushMatrix();
            multLookAt (orig[0], orig[1], orig[2],
                at[0], at[1], at[2],
                up[0], up[1], up[2]);
            // Define "camera" object geometry here
            glPopMatrix();

    Warning: Results become undefined as (at-eye) approaches
        coincidence with (up).
*/
void multLookAt (float m[],
                 const QVector3D & ieye,
                 const QVector3D & iat,
                 const QVector3D & iup)
{
    // Compute our new look at vector, which will be
    //   the new negative Z axis of our transformed object.
    QVector3D atVec;
    atVec = ieye-iat;
    atVec.normalize();

    QVector3D xVec = QVector3D::crossProduct(atVec, iup);
    xVec.normalize();

    // Calculate the new up vector, which will be the
    //   positive Y axis of our transformed object. Note
    //   that it will lie in the same plane as the new
    //   look at vector and the old up vector.
    QVector3D upVec = QVector3D::crossProduct(xVec, atVec);

    // Account for the fact that the geometry will be defined to
    //   point along the negative Z axis.
    atVec *=  -1.f;

    // Fill out the rest of the 4x4 matrix
    m[0] = xVec.x();
    m[1] = xVec.y();
    m[2] = xVec.z();
    m[3] = 0.f;     // xaxis is m[0..2]
    m[4] = upVec.x();
    m[5] = upVec.y();
    m[6] = upVec.z();
    m[7] = 0.f;     // up is m[4..6]
    m[8] = atVec.x();
    m[9] = atVec.y();
    m[10] = atVec.z();
    m[11] = 0.f;    // -at is m[8..10]
    m[12] = ieye.x();
    m[13] = ieye.y();
    m[14] = ieye.z();
    m[15] = 1.f;
}
コード例 #28
0
ファイル: bird.cpp プロジェクト: GriffinLedingham/Picking
QVector3D Bird::seek(QVector3D target)
{
    //might be backwards
    QVector3D desired = target - position;
    desired.normalize();
    desired*= maxvelocity;
    //might be backwards
    QVector3D steer = desired - velocity;
    limit(steer,maxforce);

    return steer;
}
コード例 #29
0
void Camera::mouseMoveEvent(int dX, int dY)
{
    QVector3D rightVector = lookAtDirection.crossProduct(lookAtDirection, up);
    rightVector.normalize();

    rotationMatrix.setToIdentity();
    rotationMatrix.rotate(pitchSpeed*dY*mouseSensitivity, rightVector);
    rotationMatrix.rotate(yawSpeed*dX*mouseSensitivity, up);
    lookAtDirection = rotationMatrix*lookAtDirection;
    up = rotationMatrix*up;
    lookAtPoint = position + lookAtDirection;

    updateLookAt();
}
コード例 #30
0
ファイル: bird.cpp プロジェクト: GriffinLedingham/Picking
QVector3D Bird::separate(QVector<Bird> birds)
{
    float desiredSeparation = 25.0f;
    QVector3D steer = QVector3D(0,0,0);
    int count = 0;

    QVector<Bird>::iterator bird;
    for(bird = birds.begin(); bird != birds.end(); bird++)
    {
        float d = (position-(*bird).position).length();//QVector3D::distanceToLine(this->position,(*bird).position);
        //QVector3D::
        if(d>0 && d < desiredSeparation)
        {
            QVector3D diff = position - (*bird).position;
            diff.normalize();
            diff /= d;
            steer += diff;
            count++;
        }
    }
    if(count > 0)
    {
        steer /= (float)count;
    }
    if(steer.length() > 0)
    {
        steer.normalize();
        steer *= maxvelocity;
        steer -= velocity;
    }

    steer = limit(steer, maxforce);


    return steer;
}