void millionParticlesApp::drawText()
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    TextLayout layout;
    layout.setFont( Font( "Arial-BoldMT", 14 ) );
    layout.setColor( Color( 1.0f, 1.0f, 1.0f ) );
    layout.addLine( "1 Million Particles" );
    layout.addLine( " " );

    layout.setColor( Color( 0.9f, 0.9f, 0.9f ) );
    layout.setFont( Font( "ArialMT", 12 ) );

    layout.addLine("F - switch to fullscreen");
    layout.addLine("t - draw textures");

    char fps[50];
    sprintf(fps, "FPS: %.2f", getAverageFps());

    char particleCount[50];
    sprintf(particleCount, "Particles: %d", PARTICLES*PARTICLES);

    layout.addLine(fps);
    layout.addLine(particleCount);

    glEnable( GL_TEXTURE_2D );
    gl::draw(layout.render(true), Vec2f(getWindowWidth() - 150,25));
    glDisable( GL_TEXTURE_2D );
}
Exemple #2
0
Item::Item( int index, vec2 pos, const string &title, const string &desc, Surface palette )
	: mIndex(index), mTitle( title ), mDesc( desc ), mPalette(palette)
{
	// TODO: can you reuse layouts? If so, how do you clear the text?
	// textures
	TextLayout layout;
	layout.clear( ColorA( 1, 1, 1, 0 ) );
	layout.setFont( sSmallFont );
	layout.setColor( Color::white() );
	layout.addLine( mTitle );
	mTitleTex = gl::Texture::create( layout.render( true ) );
	
	TextLayout bigLayout;
	bigLayout.clear( ColorA( 1, 1, 1, 0 ) );
	bigLayout.setFont( sBigFont );
	bigLayout.setColor( Color::white() );
	bigLayout.addLine( mTitle );
	mTitleBigTex = gl::Texture::create( bigLayout.render( true ) );
	
	// title
	mTitleStart		= pos;
	mTitleDest1		= vec2( pos.x - 25.0f, pos.y );
	mTitleFinish	= vec2( pos.x - 4.0f, 120.0f );
	mTitleDest2		= vec2( mTitleFinish.x - 25.0f, mTitleFinish.y );
	mMouseOverDest	= mTitleStart + vec2( 7.0f, 0.0f );
	mTitlePos		= mTitleStart;
	mTitleColor		= Color( 0.7f, 0.7f, 0.7f );
	mTitleAlpha		= 1.0f;
	mTitleWidth		= mTitleTex->getWidth();
	mTitleHeight	= mTitleTex->getHeight();
	
	// desc
	mDescStart		= vec2( mTitleStart.x + 25.0f, mTitleFinish.y + mTitleBigTex->getHeight() + 5.0f );
	mDescDest		= vec2( mTitleStart.x + 35.0f, mDescStart.y );
	mDescPos		= mDescStart;
	mDescAlpha		= 0.0f;
	TextBox tbox	= TextBox().alignment( TextBox::LEFT ).font( sSmallFont ).size( ivec2( 650.0f, TextBox::GROW ) ).text( mDesc );
	mDescTex		= gl::Texture::create( tbox.render() );
	
	// bar
	mBarPos			= pos - vec2( 4.0f, 1.0f );
	mBarWidth		= 0.0f;
	mBarHeight		= mTitleHeight + 2.0f;
	mMaxBarWidth	= mTitleWidth + 22.0f;
	mBarColor		= Color::white();
	mBarAlpha		= 0.3f;
	
	mFadeFloat		= 1.0f;
	mIsSelected		= false;
	mIsBeingSelected = false;

	setColors();
}
void QuickTimeSampleApp::loadMovieFile( const fs::path& moviePath )
{
	try {
		// load up the movie, set it to loop, and begin playing
		mMovie = qtime::MovieGl( moviePath );
		mMovie.setLoop();
		mMovie.play();
		
		// create a texture for showing some info about the movie
		TextLayout infoText;
		infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
		infoText.setColor( Color::white() );
		infoText.addCenteredLine( getPathFileName( moviePath.string() ) );
		infoText.addLine( toString( mMovie.getWidth() ) + " x " + toString( mMovie.getHeight() ) + " pixels" );
		infoText.addLine( toString( mMovie.getDuration() ) + " seconds" );
		infoText.addLine( toString( mMovie.getNumFrames() ) + " frames" );
		infoText.addLine( toString( mMovie.getFramerate() ) + " fps" );
		infoText.setBorder( 4, 2 );
		mInfoTexture = gl::Texture( infoText.render( true ) );
	}
	catch( ... ) {
		console() << "Unable to load the movie." << std::endl;
		mMovie.reset();
		mInfoTexture.reset();
	}

	mFrameTexture.reset();
}
AccordionItem::AccordionItem( Timeline &timeline, float x, float y, float height, float contractedWidth, float expandedWidth, gl::Texture image, string title, string subtitle ) 
	: mTimeline(timeline), mX(x), mY(y), mWidth(contractedWidth), mHeight(height), mExpandedWidth(expandedWidth), mImage(image), mTitle(title), mSubtitle(subtitle)
{
#if defined( CINDER_COCOA )
	std::string normalFont( "Arial" );
	std::string boldFont( "Arial-BoldMT" );
#else
	std::string normalFont( "Arial" );
	std::string boldFont( "ArialBold" );
#endif
	
	mAnimEase = EaseOutAtan(25);
	mAnimDuration = 0.7f;
	
	mTextAlpha = 0.0f;
	
	TextLayout layout;
	layout.clear( ColorA( 0.6f, 0.6f, 0.6f, 0.0f ) );
	layout.setFont( Font( boldFont, 26 ) );
	layout.setColor( Color( 1, 1, 1 ) );
	layout.addLine( mTitle );
	layout.setFont( Font( normalFont, 16 ) );
	layout.addLine( mSubtitle );
	layout.setBorder(11, 6);
	mText = gl::Texture( layout.render( true ) );
	
	update();
}
void SerialCommunicationApp::keyDown(KeyEvent event)
{
    //DEBUG 
    int16_t temp = 0;

    switch (event.getChar()) {
        case '1':
            temp = 49;
            break;
        case '2':
            temp = 50;
            break;
        case '3':
            temp = 51;
            break;
    }
    
    if (temp > 48 && temp < 52) {
        osc::Message message;
        //message.addStringArg(lastString);
        message.addIntArg(temp);
        message.setAddress("coinTrigger");
        message.setRemoteEndpoint(host, port);
        sender.sendMessage(message);
        TextLayout simple;
        simple.setFont( Font( "Arial Black", 54 ) );
        simple.setColor( Color( .7, .7, .2 ) );
        simple.addLine( to_string(event.getChar()) );
        simple.setLeadingOffset( 0 );
        mTexture = gl::Texture( simple.render( true, false ) );
        bTextureComplete = true;
    }
}
Exemple #6
0
void ciApp::draw()
{
	gl::clear();

	gl::ScopedColor white(Color::white());

	auto get_center_rect = [&](Area area) ->Rectf { return Rectf(area).getCenteredFit(getWindowBounds(), true); };

	{	
		//auto tex = filter->getTexture();
		auto tex = vector_blur.getTexture();
		gl::draw(tex, get_center_rect(tex->getBounds()));
	}
	
	{
		gl::ScopedMatrices scpMatrix;
		gl::scale(0.2f, 0.2f);
		gl::draw(mTexture);
	}

	vector_blur.drawDebug(vec2(0, 0), 0.2f);

	mParams->draw();

	{
		TextLayout infoFps;
		infoFps.clear(ColorA(0.2f, 0.2f, 0.2f, 0.5f));
		infoFps.setColor(Color::white());
		infoFps.setFont(Font("Arial", 16));
		infoFps.setBorder(4, 2);
		infoFps.addLine("App Framerate: " + tostr(getAverageFps(), 1));
		auto tex = gl::Texture::create(infoFps.render(true));
		gl::draw(tex, ivec2(20, getWindowHeight() - tex->getHeight() - 20));
	}
}
void SerialCommunicationApp::update()
{
	if (serialInitiallized()){
        if(serial.getNumBytesAvailable() > 0){
            console() << "Bytes available: " << serial.getNumBytesAvailable() << std::endl;
            try{
                lastString = serial.readStringUntil('\n');
            } catch(SerialTimeoutExc e) {
                console() << "timeout" << endl;
            }
            console() << lastString << endl;
            int16_t temp = lastString[0];
            
            //OSC MESSAGE
            osc::Message message;
            message.addIntArg(temp);
            message.setAddress("coinTrigger");
            message.setRemoteEndpoint(host, port);
            sender.sendMessage(message);
           
            TextLayout simple;
            simple.setFont( Font( "Arial Black", 54 ) );
            simple.setColor( Color( .7, .7, .2 ) );
            simple.addLine( lastString );
            simple.setLeadingOffset( 0 );
            mTexture = gl::Texture( simple.render( true, false ) );
            bTextureComplete = true;
            serial.flush();
        }
    }
    serial.flush();
}
void RotatingCubeApp::setup()
{
	try {
		mCapture = Capture( 320, 240 );
		mCapture.start();
	}
	catch( CaptureExc &exc ) {
	    console() << "failed to initialize the webcam, what: " << exc.what() << std::endl;

	    // create a warning texture
		// if we threw in the start, we'll set the Capture to null
		mCapture.reset();
		
		TextLayout layout;
		layout.clear( Color( 0.3f, 0.3f, 0.3f ) );
		layout.setColor( Color( 1, 1, 1 ) );
		layout.setFont( Font( "Arial", 96 ) );
		layout.addCenteredLine( "No Webcam" );
		layout.addCenteredLine( "Detected" );
		mTexture = gl::Texture2d::create( layout.render() );
	}
	
	mCam.lookAt( vec3( 3, 2, -3 ), vec3( 0 ) );
	gl::enableDepthRead();
	gl::enableDepthWrite();
}
void QuickTimeSampleApp::loadMovieFile( const fs::path &moviePath )
{
	try {
		// load up the movie, set it to loop, and begin playing
		mMovie = qtime::MovieGl::create( moviePath );
		mMovie->setLoop();
		mMovie->play();
		
		// create a texture for showing some info about the movie
		TextLayout infoText;
		infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
		infoText.setColor( Color::white() );
		infoText.addCenteredLine( moviePath.filename().string() );
		infoText.addLine( toString( mMovie->getWidth() ) + " x " + toString( mMovie->getHeight() ) + " pixels" );
		infoText.addLine( toString( mMovie->getDuration() ) + " seconds" );
		infoText.addLine( toString( mMovie->getNumFrames() ) + " frames" );
		infoText.addLine( toString( mMovie->getFramerate() ) + " fps" );
		infoText.setBorder( 4, 2 );
		mInfoTexture = gl::Texture::create( infoText.render( true ) );
	}
	catch( ci::Exception &exc ) {
		console() << "Exception caught trying to load the movie from path: " << moviePath << ", what: " << exc.what() << std::endl;
		mMovie.reset();
		mInfoTexture.reset();
	}

	mFrameTexture.reset();
}
void CaptureApp::setup()
{	
	// list out the devices
	vector<Capture::DeviceRef> devices( Capture::getDevices() );
	for( vector<Capture::DeviceRef>::const_iterator deviceIt = devices.begin(); deviceIt != devices.end(); ++deviceIt ) {
		Capture::DeviceRef device = *deviceIt;
		console() << "Found Device " << device->getName() << " ID: " << device->getUniqueId() << std::endl;
		try {
			if( device->checkAvailable() ) {
				mCaptures.push_back( Capture::create( WIDTH, HEIGHT, device ) );
				mCaptures.back()->start();
			
				// placeholder text
				mTextures.push_back( gl::TextureRef() );

				// render the name as a texture
				TextLayout layout;
				layout.setFont( Font( "Arial", 24 ) );
				layout.setColor( Color( 1, 1, 1 ) );
				layout.addLine( device->getName() );
				mNameTextures.push_back( gl::Texture::create( layout.render( true ) ) );
			}
			else
				console() << "device is NOT available" << std::endl;
		}
		catch( CaptureExc & ) {
			console() << "Unable to initialize device: " << device->getName() << endl;
		}
	}
}
void Button::createTextField()
{
	TextLayout simple;
	simple.setFont( *textFont );	
	simple.setColor( Color::black());
	simple.addLine(Utils::cp1251_to_utf8(label.c_str()));		
	textTexture = gl::Texture( simple.render( true, false ) );	
}
Exemple #12
0
void MenuObject::setTitle(string tit){
	title = tit;
	TextLayout layout;
	layout.setFont(Font(loadAsset("ArcadeClassic.ttf"), 60));
	layout.setColor(Color( 1.0f, 1.0f, 1.0f) );
	layout.clear(ColorA(1.0f, 1.0f, 1.0f, 0.0f));
	layout.addCenteredLine(title);
	renderedTitle = gl::Texture(layout.render(true, true));
}
Exemple #13
0
void HW2App::setup()
{
    //create surface
    mySurface_ = new Surface(1024,1024,false);
    // set variable to toggle help; credit for help screen layout to Markus Ernst (https://github.com/cluelesswalnut)
    help = 1;
    //set font of help
    font = Font( "", 14.0 );
    // set up text for the help
    text = new TextLayout();
    text->setFont(font);
    text->setColor( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) );
    text->addLine("Select a shape/layer to modify by using the following keys:");
    text->addLine("	q: Background");
    text->addLine("	w: Red Rectangle");
    text->addLine("	e: Green Rectangle");
    text->addLine("	r: Blue Rectangle");
    text->addLine("	t: Yellow Rectangle");
    text->addLine("	y: Purple Rectangle");
    text->addLine("Once a shape is selected:");
    text->addLine("	a: Moves the shape up in the list");
    text->addLine("	z: Moves the shape back in the list");
    text->addLine("	Arrow Keys: Move the shape around");
    text->addLine("Additional key commands:");
    text->addLine("	?: Toggle help menu");
    text->addLine("	f: Reverses layer list");
    // make a surface out of the text
    tex = text->render(true,true);

    //set initial selected shape
    shape = 'q';

    //create head of shape list
    lst = new node();
    temp = lst;
    //add the shapes in
    insertAfter(new node(pixelArray,0,0,640,480,Color8u(0, 0, 255)),temp,lst);
    background = lst->next;
    temp = temp->next;
    insertAfter(new node(pixelArray,100,100,100,100,Color8u(255, 0, 0)),temp,lst);
    temp = temp->next;
    rec1 = temp;
    insertAfter(new node(pixelArray,1,150,75,75,Color8u(0, 255, 0)),temp,lst);
    temp = temp->next;
    rec2 = temp;
    insertAfter(new node(pixelArray,300,10,80,80,Color8u(0, 125, 255)),temp,lst);
    temp = temp->next;
    rec3 = temp;
    insertAfter(new node(pixelArray,300,150,60,90,Color8u(255, 255, 0)),temp,lst);
    temp = temp->next;
    rec4 = temp;
    insertAfter(new node(pixelArray,500,10,125,125,Color8u(0, 255, 255)),temp,lst);
    rec5 = temp->next;

};
Exemple #14
0
void QRcode::draw()
{
	gl::pushMatrices();					
		gl::translate(startQRCodeHolderXY);
		gl::draw(qrCodeFon);

		if (isError)
		{
			drawError();			
		}
		else
		{
			if (isReady == false)
			{
				gl::pushMatrices();
					gl::translate(220, 650);	
					preloader.draw();			
				gl::popMatrices();
			}
			else
			{
				if(stringQrcode=="") return;
				//if (isRender == false)
				//{
					isRender = true;		
					qrCodeTexture = loadImageFromString(stringQrcode);

					TextLayout simple;
					simple.setFont( qrCodeFont );
					simple.setColor( Color( 1, 1, 1 ) );
					simple.addLine(url);
					qrCodeTextTexture = gl::Texture( simple.render( true, false ) );
				//}

				if(qrCodeTextTexture)
				{
					gl::pushMatrices();			
					gl::translate(33, 885);	
					gl::draw(qrCodeTextTexture);
					gl::popMatrices();
				}	

				if(qrCodeTexture)
				{
					gl::pushMatrices();			
					gl::translate(86, 505);		
					gl::draw(qrCodeTexture);
					gl::popMatrices();
				}

			}
		}

	gl::popMatrices();	
}
void CatMemeMakerApp::draw()
{
	// clear out the window with black
	gl::clear( Color( 0, 0, 0 ) ); 
	gl::enableAlphaBlending();

	//Check that the url fetch was successful
	if (mImage) {
		//Draw the Cat!
		mImage.enableAndBind();
		gl::draw( mImage, getWindowBounds() );
	}

	//If we are on the second line, write what we used to have for the first line up top
	if (mFirstLine) {
		gl::draw(mFirstLine,Vec2f( getWindowSize().x/2 - mFirstLine.getWidth()/2, 10 ));
	}

	//Render the texture with the message
	TextLayout simple;

	std::string normalFont( "Arial" );

	simple.setFont( Font(normalFont,48) );
	simple.setColor( Color( 1, 1, 1 ) );

	//White looked bad on the second line... so change to black if on second line
	if (mFirstLine) {
		simple.setColor( Color( 255, 255, 255 ) );
	}
	simple.addCenteredLine(mMessage.str());

	mTexture = gl::Texture( simple.render( true , false ) );

	//Draw the message, centered!
	if (mFirstLine) {
		gl::draw(mTexture,Vec2f( getWindowSize().x/2 - mTexture.getWidth()/2, getWindowSize().y -50));
	}
	else {
		gl::draw(mTexture,Vec2f( getWindowSize().x/2 - mTexture.getWidth()/2, 10 ));
	}
}
void FrownLogoParticlesApp::setup()
{
    mKeyPressed = false;
    // Lets load a font from the the installed fonts of the OS
    // and set its size to 90

    mFont = Font("Arial",90 );
    
    //Clear the layout to black
    
    mLayout.clear(Color::black() );
    //Set the text color of the layout
    mLayout.setColor(Color(1,1,1));
    
    //Set the font of the layout
    mLayout.setFont(mFont);
    
    //Add the following line to the layout
    mLayout.addLine("FROWN");
    
    //Render the layout into a cinder Surface
    mSurface = mLayout.render();

    //We will now iterate through every pixel in the surface:
    //First get the iterator
    Surface::Iter iter = mSurface.getIter();
    // For every line in the surface
    //
    while ( iter.line() )
    {
        // For every pixel in the line
        while (iter.pixel()) {
            //Check if the color of the current pixel is not black
            if ( ( iter.r() != 0.0f ) && ( iter.g() != 0.0f ) && ( iter.b() != 0.0f ) )
            {
                //If its not black, push the position of the pixel into
                // the initial positions
                mInitialPositions.push_back(ci::Vec2f(iter.x(), iter.y()));
                // Also, lets make the current positions equal to the initial
                // ones
                mCurrentPositions.push_back(ci::Vec2f(iter.x(), iter.y()));
                //lets also keep the color of every pixel
                mPixelColors.push_back(Colorf(iter.r(), iter.g(), iter.b()));
            }
        }
    }
    //Print the size of non-black pixels found in the surface
    console() << "We found " << mInitialPositions.size() <<
    " non black pixels" << endl;
    
    console() << "Spacebar changes: explode /move back" << endl;
    console() << "P or p changes: whether the particles are paused or not" << endl;
}
void  Button::setBtnId(string value)
{
	if (isTextField ) 
	{
		code = value;
		TextLayout simple;
		simple.setFont( *textFont );	
		simple.setColor(Color::black());
		simple.addLine(Utils::cp1251_to_utf8(value.c_str()));		
		textTexture = gl::Texture( simple.render( true, false ) );	
	}
}
void PathSimplificationApp::draw()
{
   	// clear out the window with black
	gl::clear( Color( 0, 0, 0 ) );
    
    cairo::SurfaceImage surface( getWindowWidth(), getWindowHeight());
    cairo::Context ctx( surface );
    
    // draw each path
    for(int i=0; i<mSmPaths.size(); i++){
        // pass the cairo context to draw onto
        drawPath(ctx, mSmPaths[i], drawMode);
    }
    
    // draw the surface
    gl::Texture myTexture = surface.getSurface();
    gl::draw(myTexture);
    
    
    TextLayout layout;
    layout.clear(ColorA(0.1f,0.1f,0.1f,0.7f));
    layout.setColor( Color( 0.9f, 0.9f, 0.9f ) );
    layout.setFont( Font( "Arial", 14 ) );
    
    
    SmoothPath* lastPath;
    if(mSmPaths.size() > 0){
        lastPath = mSmPaths[mSmPaths.size()-1];
    }
    
    if(mSmPaths.size() == 0){
        layout.addCenteredLine("Click and drag to draw a line.");
        layout.addCenteredLine("Press 'R' to clear.");
    }else if(mSmPaths.size() > 0 && lastPath->inProgress){
        int segCount = (lastPath->getPathPoints().size()>0) ? lastPath->getPathPoints().size()-1 : 0;
        layout.addCenteredLine( "Segment Count: " + boost::lexical_cast<std::string>(segCount));
    }else if(mSmPaths.size() > 0 && !lastPath->inProgress){
        int oldSegCount = (lastPath->getPathPoints().size()>0) ? lastPath->getPathPoints().size()-1 : 0;
        int segCount = lastPath->getCurrentPath().getNumSegments();
        int diff = oldSegCount - segCount;
        float per = (float(diff)/float(oldSegCount)) * 100.0f;
        string msg = boost::lexical_cast<std::string>(diff) + " of " + boost::lexical_cast<std::string>(oldSegCount) + " segments were removed. Saving " +boost::lexical_cast<std::string>(per) + "%";
        layout.addCenteredLine(msg);
    }
    
    
    Surface8u rendered = layout.render( true, PREMULT );
    mTextTexture = gl::Texture( rendered );
    
    if( mTextTexture )
		gl::draw( mTextTexture,  Vec2f(10, 10)  );
}
Exemple #19
0
void InfoPanel::createTexture()
{
	TextLayout layout;
	
	layout.setFont( Font( "Arial-BoldMT", 14 ) );
	layout.setColor( Color( 1.0f, 1.0f, 0.0f ) );
	layout.addLine( "OpenGL Lighting" );
	
	layout.setFont( Font( "ArialMT", 10 ) );
	layout.setColor( Color( 1.0f, 0.7f, 0.0f ) );
	layout.addLine( "mouse move	reposition light sources" );
	layout.addLine( "click and hold	intensify light" );
	layout.setColor( Color( 0.5f, 0.2f, 0.0f ) );
	layout.addLine( "A	toggle ambient" );
	layout.addLine( "D	toggle diffuse" );
	layout.addLine( "S	toggle specular" );
	layout.addLine( "E	toggle emissive" );
	layout.addLine( "< >	adjust shininess" );
	layout.addLine( "?	toggle information panel" );
	
	mTexture = gl::Texture( layout.render( true ) );
}
Exemple #20
0
void Utils::textFieldDraw(std::string text,Font font, Vec2f coords, ColorA color)
{
	gl::pushMatrices();
	gl::translate(coords);
	TextLayout simple;
	simple.clear(ColorA(1,1,1,0));
	simple.setFont( font );
	simple.setColor(color );
	simple.addLine(cp1251_to_utf8(text.c_str()));	
	gl::draw(gl::Texture( simple.render( true, false ) ));
	gl::popMatrices();	

}
Exemple #21
0
void InfoPanel::createTexture()
{
	TextLayout layout;
	
	layout.setFont( Font( "Arial-BoldMT", 14 ) );
	layout.setColor( Color( 1.0f, 1.0f, 0.0f ) );
	layout.addLine( "Hodgin Particles Redux" );
	
	layout.setFont( Font( "ArialMT", 10 ) );
	layout.setColor( Color( 1.0f, 0.7f, 0.0f ) );
	layout.addLine( "click and drag to create particles" );
	layout.setColor( Color( 0.5f, 0.2f, 0.0f ) );
	layout.addLine( "C	toggle constraints (floor plane)" );
	layout.addLine( "Q	render particle quads" );
	layout.addLine( "T	render particle trail" );
	layout.addLine( "P	toggle perlin noise force" );
	layout.addLine( "G	toggle gravitational force" );
	layout.addLine( "F	toggle fullscreen" );
	layout.addLine( "?	toggle information panel" );
	
	mTexture = gl::Texture( layout.render( true ) );
}
Exemple #22
0
Quake::Quake( float aLat, float aLong, float aMag, string aTitle )
{
	mLat	= aLat;
	mLong	= aLong;
	mMag	= aMag;
	mTitle	= aTitle;
	
	TextLayout layout;
	ostringstream os;
	os << mMag;
	if( os.str().length() == 1 ){
		os << ".0";
	}
	
	
	
	if( mMag > 5.5 ){
		layout.setFont( Font( "HelveticaNeue-Bold", mMag * mMag + 26.0f ) );
		layout.setColor( Color( 1, 0, 0 ) );
	} else {
		layout.setFont( Font( "HelveticaNeue-Bold", mMag * mMag + 10.0f ) );
		layout.setColor( Color( 1, 1, 1 ) );
	}
	layout.addCenteredLine( os.str() );
	
	
	if( mMag > 5.5 ){
		layout.setLeadingOffset( -10 );
		layout.setFont( Font( "HelveticaNeue", mMag + 16 ) );
		layout.setColor( Color( 1, 1, 1 ) );
		layout.addCenteredLine( mTitle );
	}
	

	mLabel = gl::Texture( layout.render( true ) );
	
	setLoc();
}
gl::TextureRef make_tex(std::string const& line)
{
    TextLayout layout;
    layout.setFont( Font( "Arial", 32 ) );
    layout.setColor( Color( 1, 1, 0 ) );

    layout.addLine( line );
    //if (stat_ == stat::over) {
    //    //layout.addLine( std::string("synths: ") );
    //} else if (stat_ == stat::pause) {
    //    layout.addLine( std::string("Pause") );
    //}
    return gl::Texture::create( layout.render( true ) );
}
void ScrollingLabel::updateTexture()
{
    if (mText == "") {
        mTexture.reset();
    }
    else {
		TextLayout layout;
		layout.setFont( mFont );
		layout.setColor( mColor );			
		layout.addLine( mText );
		bool PREMULT = false;
		mTexture = gl::Texture( layout.render( true, PREMULT ) );        
    }
}
void CatMemeMakerApp::saveFirst()
{
	TextLayout simple;

	std::string normalFont( "Arial" );

	simple.setFont( Font(normalFont,48) );
	simple.setColor( Color( 1, 1, 1 ) );
	simple.addCenteredLine(mMessage.str());

	mFirstLine = gl::Texture( simple.render( true , false ) );

	mMessage.str(" ");
}
void CinderIldaApp::update()
{
    mLaserDac->setPoints(mIldaFrame);
//    mLaserDac->send();
    
    float fps = getFrameRate();
    
    TextLayout simple;
	simple.setFont( mFont );
	simple.setColor( Color( 1, 1, 1 ) );
	simple.addLine( "CinderIlda" );
	simple.addLine( "Framerate: " + toString((int)fps) );
	mTexture = gl::Texture( simple.render( true, PREMULT ) );
    
}
void MovieLoaderApp::movieReady()
{
	mMovie->play();
	
	// create a texture for showing some info about the movie
	TextLayout infoText;
	infoText.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.5f ) );
	infoText.setColor( Color::white() );
	infoText.addLine( toString( mMovie->getWidth() ) + " x " + toString( mMovie->getHeight() ) + " pixels" );
	infoText.addLine( toString( mMovie->getDuration() ) + " seconds" );
	infoText.addLine( toString( mMovie->getNumFrames() ) + " frames" );
	infoText.addLine( toString( mMovie->getFramerate() ) + " fps" );
	infoText.setBorder( 4, 2 );
	mInfoTexture = gl::Texture( infoText.render( true ) );
}
Exemple #28
0
SceneInIsInside::SceneInIsInside()
{
	mmgr = make_shared<MovieManager>();

	mmgr->addMovie("innen.mp4", getWindowWidth()*0.5, getWindowHeight()*0.5, getWindowWidth(), getWindowHeight());


	std::string arial("Arial");

	TextLayout simple;
	simple.setFont(Font(arial, 16));
	simple.setColor(Color(1, 1, 1));
	simple.addLine("SceneInIsInside");
	text = gl::Texture2d::create(simple.render(true, PREMULT));
}
void SerialCommunicationApp::update()
{
//	console() << "Bytes available: " << serial.getNumBytesAvailable() << std::endl;
	
	double now = getElapsedSeconds();
	double deltaTime = now - lastUpdate;
	lastUpdate = now;
	sinceLastRead += deltaTime;
	
	if(sinceLastRead > READ_INTERVAL)
	{
		bSendSerialMessage = true;
		sinceLastRead = 0.0;
	}
		
	
	if (bSendSerialMessage)
	{
		// request next chunk
		serial.writeByte(ctr);
		
		try{
			// read until newline, to a maximum of BUFSIZE bytes
			lastString = serial.readStringUntil('\n', BUFSIZE );

		} catch(SerialTimeoutExc e) {
			console() << "timeout" << endl;
		}
		
		
		bSendSerialMessage = false;
		
		ctr+=8;
		console() << lastString << endl;
		
		
		TextLayout simple;
		simple.setFont( Font( "Arial Black", 24 ) );
		simple.setColor( Color( .7, .7, .2 ) );
		simple.addLine( lastString );
		simple.setLeadingOffset( 0 );
		mTexture = gl::Texture( simple.render( true, false ) );
		bTextureComplete = true;
		
		serial.flush();
	}
}
Exemple #30
0
void TextTestApp::setup()
{
    printFontNames();

#if defined( CINDER_COCOA_TOUCH )
    std::string normalFont( "Arial" );
    std::string boldFont( "Arial-BoldMT" );
    std::string differentFont( "AmericanTypewriter" );
#else
    std::string normalFont( "Arial" );
    std::string boldFont( "Arial Bold" );
    std::string differentFont( "Papyrus" );
#endif

    // Japanese
    unsigned char japanese[] = { 0xE6, 0x97, 0xA5, 0xE6, 0x9C, 0xAC, 0xE8, 0xAA, 0x9E, 0 };
    // this does a complicated layout
    TextLayout layout;
    layout.clear( ColorA( 0.2f, 0.2f, 0.2f, 0.2f ) );
    layout.setFont( Font( normalFont, 24 ) );
    layout.setColor( Color( 1, 1, 1 ) );
    layout.addLine( std::string( "Unicode: " ) + (const char*)japanese );
    layout.setColor( Color( 0.5f, 0.25f, 0.8f ) );
    layout.setFont( Font( boldFont, 12 ) );
    layout.addRightLine( "Now is the time" );
    layout.setFont( Font( normalFont, 22 ) );
    layout.setColor( Color( 0.75f, 0.25f, 0.6f ) );
    layout.append( " for all good men" );
    layout.addCenteredLine( "center justified" );
    layout.addRightLine( "right justified" );
    layout.setFont( Font( differentFont, 24 ) );
    layout.addCenteredLine( "A different font" );
    layout.setFont( Font( normalFont, 22 ) );
    layout.setColor( Color( 1.0f, 0.5f, 0.25f ) );
    layout.addLine( " • Point 1 " );
    layout.setLeadingOffset( -10 );
    layout.addLine( " • Other point with -10 leading offset " );
    layout.setLeadingOffset( 0 );
    layout.setColor( ColorA( 0.25f, 0.5f, 1, 0.5f ) );
    layout.addLine( " • Back to regular leading but translucent" );
    Surface8u rendered = layout.render( true, PREMULT );
    mTexture = gl::Texture( rendered );

    // Create a custom font by loading it from a resource
    Font customFont( Font( loadResource( RES_CUSTOM_FONT ), 72 ) );
    console() << "This font is called " << customFont.getFullName() << std::endl;

    TextLayout simple;
    simple.setFont( customFont );
    simple.setColor( Color( 1, 0, 0.1f ) );
    simple.addLine( "Cinder" );
    simple.addLine( "Font From Resource" );
    mSimpleTexture = gl::Texture( simple.render( true, PREMULT ) );
}