Example #1
0
void Camera::dolly(float _px, float _py, float _x, float _y)
{
	float dx = _px - _x;
	float dy = _py - _y;

	ofxVec3f offset = convertToLocal(0, 0, -dx - dy);

	eye += offset;
}
Example #2
0
void Camera::track(float _px, float _py, float _x, float _y)
{
	float dx = _px - _x;
	float dy = _py - _y;

	ofxVec3f offset = convertToLocal(dx, dy, 0);
	eye += offset;
	center += offset;
}
Example #3
0
Curve& Curve::add(const Curve& curve)
{
    size_t offset = getVerticesCount();

    for( auto& vertex : curve.m_vertices )
        addVertex(convertToLocal(curve.convertToGlobal(vertex->getCoords())));

    return *this;
}
Example #4
0
void Camera::tumble(float _px, float _py, float _x, float _y)
{
	float tolerance = 0.01;

	if (fabs(_x - _px) < tolerance && fabs(_y - _py) < tolerance)
		return; // Not enough change to have an action.

	/* 
	The arcball works by pretending that a ball encloses the 3D view.  
	You roll this pretend ball with the mouse.  For example, if you click on 
	the center of the ball and move the mouse straight to the right, you 
	roll the ball around its Y-axis.  This produces a Y-axis rotation.  
	You can click on the "edge" of the ball and roll it around in a circle 
	to get a Z-axis rotation.

	The math behind the trackball is simple: start with a vector from the first
	mouse-click on the ball to the center of the 3D view.  At the same time, set 
	the radius of the ball to be the smaller dimension of the 3D view.  
	As you drag the mouse around in the 3D view, a second vector is computed from 
	the surface of the ball to the center.  The axis of rotation is the cross 
	product of these two vectors, and the angle of rotation is the angle between 
	the two vectors.
	*/

	ofxVec3f arcBallStart = compArcBallVector(_px, _py);
	ofxVec3f arcBallEnd = compArcBallVector(_x, _y);

	// Convert from screen position to world position
	arcBallStart = convertToLocal(arcBallStart);
	arcBallEnd = convertToLocal(arcBallEnd);

	//-------------------------------------------
	// Figure the axis and angle of rotation between the start and end point.

	float cosAng, sinAng, angle;
	float ls, le;

	// Take the cross product of the two vectors. r = s X e
	ofxVec3f axis = arcBallStart.getCrossed(arcBallEnd);

	// Use atan for a better angle.  If you use only cos or sin, you only get
	// half the possible angles, and you can end up with rotations that flip 
	// around near the poles.

	// cos(a) = (s . e) / (||s|| ||e||)
	cosAng = arcBallStart.dot(arcBallEnd); // (s . e)
	ls = arcBallStart.length();
	ls = 1.0 / ls; // 1 / ||s||
	le = arcBallEnd.length();
	le = 1.0 / le; // 1 / ||e||
	cosAng = cosAng * ls * le;

	// sin(a) = ||(s X e)|| / (||s|| ||e||)
	sinAng = axis.length(); // ||(s X e)||
	sinAng = sinAng * ls * le;

	angle = atan2f(sinAng, cosAng);

	// Normalize the rotation axis.
	axis.normalize();

	//-------------------------------------------
	// Apply the rotation to the eye.

	ofxQuaternion rotation, point, rotated;

	ofxVec3f p = eye - center; // eye moved to rotate around 0, 0, 0.
	point.set(p.x, p.y, p.z, 0);

	rotation.makeRotate(angle, axis);

	rotated = (rotation*point)*rotation.conj();

	eye = center + rotated.asVec3();


	// Apply the rotation to the up vector.

	point.set(up.x, up.y, up.z, 0);

	rotated = (rotation*point)*rotation.conj();

	up = rotated.asVec3();

}
Example #5
0
ofxVec3f Camera::convertToLocal(ofxVec3f _v)
{
	return convertToLocal(_v.x, _v.y, _v.z);
}
Example #6
0
bool View::containsPoint(SkPoint point, View * reference)
{
    SkPoint p = convertToLocal(point, reference);
    return localRect().intersects(p.x(), p.y(), p.x() + 1, p.y() + 1);
}
Example #7
0
void Light::addTriangle(Point p1, Point p2, Uint32 begin, const std::vector<Segment>& segments)
{
    if( p1 == p2 )
        return;

    for( size_t k(begin); k < segments.size(); k++ )
    {
        Segment s = convertToLocal(segments[k]);
        double a = Vector2d::angle(s.p1, s.p2);

        if( a == 0 )
            continue;

        Point p0, w1, w2;

        if( a > 0 )
        {
            w1 = s.p1;
            w2 = s.p2;
        }

        else
        {
            w1 = s.p2;
            w2 = s.p1;
        }

        if( Triangle::contains(p0, p1, p2, w1) )
        {
            Point i;
            Line::intersects(p0, w1, p1, p2, i);
            addTriangle(p1, i, k + 1, segments);
            p1 = i;
        }
            
        if( Triangle::contains(p0, p1, p2, w2) )
        {
            Point i;
            Line::intersects(p0, w2, p1, p2, i);
            addTriangle(i, p2, k + 1, segments);
            p2 = i;
        }

        Point i1, i2, i3;

        bool int1 = s.intersects(Segment(p0, p1), i1),
             int2 = s.intersects(Segment(p0, p2), i2),
             int3 = s.intersects(Segment(p1, p2), i3);

        if( (int1 && i1 == p0) || (int2 && i2 == p0) || (int3 && i3 == p0) )
            continue;

        if( int1 && int2 )
        {
            p1 = i1;
            p2 = i2;
        }

        else
        {
            if( int1 && int3 )
            {
                addTriangle(i1, i3, begin, segments);
                p1 = i3;
            }

            if( int2 && int3 )
            {
                addTriangle(i2, i3, begin, segments);
                p2 = i3;
            }
        }
    }

    m_colors.push_back({m_color.r, m_color.g, m_color.b, char(255*(m_radius - p2.length()) / m_radius)});
    m_colors.push_back({m_color.r, m_color.g, m_color.b, char(255*(m_radius - p1.length()) / m_radius)});

    addFace(getVertex(0), addVertex(p1), addVertex(p2));
}