Exemplo n.º 1
0
void Context::appendPath( const cinder::Path2d &path )
{
	size_t point = 0;
	if( path.empty() )
		return;
	moveTo( path.getPoint( point++ ) );
	for( size_t seg = 0; seg < path.getNumSegments(); ++seg ) {
		switch( path.getSegmentType( seg ) ) {
			case Path2d::LINETO:
				lineTo( path.getPoint( point++ ) );
			break;
			case Path2d::QUADTO: {
				const Vec2f &spl0( path.getPoint( point - 1 ) ); const Vec2f &spl1( path.getPoint( point + 0 ) ); const Vec2f &spl2( path.getPoint( point + 1 ) );
				curveTo( spl0 + (spl1 - spl0) / 3.0f * 2.0f, spl1 + (spl2 - spl1) / 3.0f, spl2 );
				point += 2;
			}
			break;
			case Path2d::CUBICTO:
				curveTo( path.getPoint( point ), path.getPoint( point + 1 ), path.getPoint( point + 2 ) );
				point += 3;
			break;
			case Path2d::CLOSE:
				closePath();
			break;
		}
	}
}
void Path2DSamplesApp::drawPath( const cinder::Path2d &path )
{
	gl::color( Color( 1, 0 ,0 ) );
	
	// draw path
	gl::draw( path );
	
	
	//draw points
	gl::color( 1, 1, 0 );
	for( int i = 0; i < path.getPoints().size(); i++ ) {
		vec2 point = path.getPoint( i );
		gl::drawSolidRect( Rectf( -2.0, -2.0, 2.0, 2.0 ) + point );
		
//		gl::drawLine( path.getPosition( t ), mPath.getPosition( t ) + normalize( mPath.getTangent( t ) ) * 80.0f );
		
	}
	
	// draw point along the curve
	gl::color( 1, 0, 1 );
	float pos = ( getElapsedSeconds() * 0.25f );
	pos -= floor( pos );
	
	vec2 pt = path.getPosition( pos );
	gl::drawSolidCircle( pt, 4.0 );
	

	gl::drawLine( pt, pt + normalize(path.getTangent( pos )) * 25.0f );
	gl::drawLine( pt, pt - normalize(path.getTangent( pos )) * 25.0f );
	
	//
//	gl::color( 0, 1, 1 );
//	pt = path.getTangent( pos );
//	gl::drawSolidCircle( pt, 4.0 );
	
	
	//draw lines between points depending on their segment type
	gl::color( 1, 0, 1 );
	int ptCount = 0;
	for( int i = 0; i < path.getSegments().size(); i++ ) {
		auto segment = path.getSegments()[i];
		
//		console() << " --- " << segment << " --- "<< endl;
		
		auto points = path.getPoints();
		
		// if segment type == Path2d::SegmentType::CUBICTO
		// draw lines between
		if( segment == Path2d::SegmentType::QUADTO ) {
			vec2 pt1 = path.getPoints()[ptCount];
			vec2 pt2 = path.getPoints()[ptCount + 1];
			vec2 pt3 = path.getPoints()[ptCount + 2];
			if( segment == Path2d::SegmentType::QUADTO ) {
				gl::drawLine( pt1, pt2 );
				gl::drawLine( pt2, pt3 );
			}
		}
		
		if( segment == Path2d::SegmentType::CUBICTO ) {
			vec2 pt1 = path.getPoints()[ptCount + 0];
			vec2 pt2 = path.getPoints()[ptCount + 1];
			vec2 pt3 = path.getPoints()[ptCount + 2];
			vec2 pt4 = path.getPoints()[ptCount + 3];
			gl::drawLine( pt1, pt2 );
			gl::drawLine( pt3, pt4 );
		}
		
		
//		path.getSegmentTangent(size_t segment, float t)
//		console() << segment << endl;
//		vec2 point = path.getPoint( i );
//		gl::drawSolidRect( Rectf( -2.0, -2.0, 2.0, 2.0 ) + point );
		
		/*if( segment == Path2d::SegmentType::MOVETO || segment == Path2d::SegmentType::LINETO )
			ptCount += 1;
		if( segment == Path2d::SegmentType::CUBICTO )
			ptCount += 3;
		if( segment == Path2d::SegmentType::QUADTO )
			ptCount += 2;*/
		
		ptCount += path.sSegmentTypePointCounts[segment];
	}
	
	
	gl::color( 1, 1, 1, 0.2 );
//	gl::drawSolidRect( path.calcBoundingBox() );			// box around everything (including points)
	gl::drawSolidRect( path.calcPreciseBoundingBox() );		// box around just the path itself
//	gl::drawStrokedRect(path.calcPreciseBoundingBox());
	
	// calculate length of path
	gl::drawString( "length: " + to_string( path.calcLength() ), vec2( 0.0, -10.0 ) );
	
	// not sure what these do
	/*static int		calcQuadraticBezierMonotoneRegions( const vec2 p[3], float resultT[2] );
	static vec2	calcQuadraticBezierPos( const vec2 p[3], float t );
	static vec2	calcQuadraticBezierDerivative( const vec2 p[3], float t );
	static int		calcCubicBezierMonotoneRegions( const vec2 p[4], float resultT[4] );
	static vec2	calcCubicBezierPos( const vec2 p[4], float t );
	static vec2	calcCubicBezierDerivative( const vec2 p[4], float t );*/
	

	{
		gl::color( 0, 0, 0 );
//		float time = path.calcNormalizedTime( getElapsedSeconds() * 0.25 );		// should this be used when getting position based on time?
		float time = path.calcTimeForDistance( getElapsedSeconds() * 20.0 );		// distance based. so 100 is 100 pixels along the path. It loops. Returns a time
//		console() << getElapsedSeconds() * 20.0 << " " << time << endl;
		vec2 pos = path.getPosition( time );
		gl::drawSolidCircle( pos, 2.0 );
	}
	
	
	// subdivides curves into points. You can construct a simplified curve that way
	auto subdivided = path.subdivide( 0.1 );
	for( auto d : subdivided ) {
		gl::color( 0, 1, 1 );
		gl::drawStrokedCircle( d, 3.0 );
	}
	
	
	// move over a bit and dot affine matric copies and rotate
	{
		gl::ScopedMatrices mtrx;
		gl::translate( path.calcBoundingBox().getWidth(), 0 );
		
		for( int i = 0; i < 8; i++ ){
			MatrixAffine2<float> affineMtrx;
			affineMtrx.scale( 0.25 );
			affineMtrx.rotate( ( ( M_PI * 2) / 8 ) * i );
			auto pathCopy = path.transformCopy( affineMtrx );
			gl::draw( pathCopy );
		}
	}
	
	
	//
	//path.calcSegmentLength( segment number, min, max )
	// highlight  0.25 - 0.75 or each segment
	
//	path.getSegmentRelativeT(float t, size_t *segment, float *relativeT) // used internally when getting positions. tangents, etx
	
	//path.segmentSolveTimeForDistance(size_t segment, float segmentLength, float segmentRelativeDistance, float tolerance, int maxIterations) // should use calcNormalizedTime or calcTimeForDistance
	

	
	
	// Path2d article
	
	// simple drawing
	
	// drawing and adding points after
	
	// drawing and then moving handles
	
	
	
	// idea: draw path that then controls sound - pitch, volume, and other stuff - using the curve
}