//--------------------------------------------------------------
void testApp::draw(){
	
	ofDrawBitmapString("test", 10, 10);
	
	//////////////////////////
	// BACKGROUND HIGHLIGHT
	//////////////////////////
	//
	glDisable(GL_DEPTH_TEST);
	ofPushStyle();
	ofSetColor(100, 100, 100);
	ofRect(viewGrid[iMainCamera]);
	ofPopStyle();
	glEnable(GL_DEPTH_TEST);
	//
	//////////////////////////
	
	
	
	//////////////////////////
	// DRAW ALL VIEWPORTS
	//////////////////////////
	//
	
	//draw main viewport
	cameras[iMainCamera]->begin(viewMain);
	drawScene(iMainCamera);
	
	//calculate mouse ray whilst this camera is active
	updateMouseRay();
	
	cameras[iMainCamera]->end();
	
	//draw side viewports
	for (int i=0; i<N_CAMERAS; i++)
	{
		cameras[i]->begin(viewGrid[i]);
		drawScene(i);
		cameras[i]->end();
	}
	
	//
	//////////////////////////
	
	
	
	//////////////////////////
	// DRAW STUFF ON TOP
	//////////////////////////
	//
	ofPushStyle();
	glDepthFunc(GL_ALWAYS); // draw on top of everything
	
	//draw some labels
	ofSetColor(255, 255, 255);
	ofDrawBitmapString("Press keys 1-4 to select a camera for main view", viewMain.x + 20, 30);
	ofDrawBitmapString("Camera selected: " + ofToString(iMainCamera+1), viewMain.x + 20, 50);
	ofDrawBitmapString("Press 'f' to toggle fullscreen", viewMain.x + 20, 70);
	ofDrawBitmapString("Press 'p' to toggle parents on OrthoCamera's", viewMain.x + 20, 90);
	
	ofDrawBitmapString("EasyCam",	viewGrid[0].x + 20, viewGrid[0].y + 30);
	ofDrawBitmapString("Front",		viewGrid[1].x + 20, viewGrid[1].y + 30);
	ofDrawBitmapString("Top",		viewGrid[2].x + 20, viewGrid[2].y + 30);
	ofDrawBitmapString("Left",		viewGrid[3].x + 20, viewGrid[3].y + 30);

	//draw outlines on views
	ofSetLineWidth(5);
	ofNoFill();
	ofSetColor(255, 255, 255);
	//
	for (int i=0; i<N_CAMERAS; i++)
		ofRect(viewGrid[i]);
	//
	ofRect(viewMain);
	
	glDepthFunc(GL_LESS);
	ofPopStyle();
	//
	//////////////////////////
}
示例#2
0
//--------------------------------------------------------------
void testApp::draw(){
    
       
    ofDrawBitmapStringHighlight(ofToString(aaFrame.volume), ofPoint(30,30));
    
    //temp.draw(30,100);
    ofNoFill();
    ofSetColor(255,255,255);
    ofRect(30,100, 128,32);
    ofBeginShape();
    for (int i = 0; i < ACM.volume.size(); i++){
        ofVertex(30+i, 100 + 32 - ofClamp(32*ACM.volume[i]*5,0,32));
    }
    ofEndShape();
    
    
    ofNoFill();
    ofRect(30,150, 128,32);
    ofBeginShape();
    for (int i = 0; i < ACM.volumeTrigger.size(); i++){
        ofVertex(30+i, 150 + 32 - 32*ACM.volumeTrigger[i]);
    }
    ofEndShape();
    
    
    
    //temp2.draw(30,150);
    ACM.pitch.draw(30,200);
    
    ofFill();
    ofSetColor(255,255,255);
    for (int i = 0; i < AA.FFTanalyzer.nAverages; i++){
		ofRect(200+(i*20),600,20,-AA.FFTanalyzer.averages[i] * 6);
	}
	
	ofSetColor(255,0,0);
	for (int i = 0; i < AA.FFTanalyzer.nAverages; i++){
		ofRect(200+(i*20),600-AA.FFTanalyzer.peaks[i] * 6,20,-4);
	}
    
    
    
    ofSetColor(0,255,255);
    
    for (int i = 0; i < AA.FFTanalyzer.nAverages; i++){
        int who = i / 3;
        //cout << peaks[who] << endl;
		ofRect(200+(i*20),600-ACM.peaks[who] * 6,20,-4);
	}
    
    
    
    
    
    
    
    
    for (int i = 0; i < colorsForMessage.size(); i++){
        ofSetColor(colorsForMessage[i]);
        ofLine(i,0,i,10);
    }
    
    
}
示例#3
0
void testApp::fadeToColor(float r, float g, float b, float speed) {
    glColor4f(r, g, b, speed);
	ofRect(0, 0, ofGetWidth(), ofGetHeight());
}
示例#4
0
//--------------------------------------------------------------
void gamuzaMain::draw(){

	if(splashFinish){

		ofBackground(0,0,0);

		//////////////////////////////////////////////
		// GUI draw
		if(!liveCodingMode){
		    ofSetLineWidth(1.2);
			gui.draw();
            drawGui();
            ofSetLineWidth(1);
		}
		//////////////////////////////////////////////

        //////////////////////////////////////////////
		// FBO texture draw
        glColor4f(1.0,1.0,1.0,1.0);
		drawFBO();
		//////////////////////////////////////////////

        ////////////////////////////////////
        // TIMELINE
        if(showTimeline && !isFullscreen){
            ofEnableAlphaBlending();
            glColor4f(0.0,0.0,0.0,0.9);
            ofRect(0,0,MAIN_WINDOW_W-4,MAIN_WINDOW_H);
            ofDisableAlphaBlending();
        }else if(showTimeline && isFullscreen){
            ofEnableAlphaBlending();
            glColor4f(0.0,0.0,0.0,0.9);
            ofRect(0,0,mainScreenW-1,mainScreenH);
            ofDisableAlphaBlending();
        }

        timeline.draw();
        ////////////////////////////////////

	}else{
		ofBackground(20,20,20);
		ofEnableAlphaBlending();
		if(isFullscreen){
			// image
			glColor4f(1.0,1.0,1.0,1.0);
			splashImage.draw((mainScreenW/2) - 256,(mainScreenH/2) - 153);
			// loading bar
			ofSetColor(9,147,211,235);
			ofRect((mainScreenW/2) - 240,(mainScreenH/2) - 144,(ofGetElapsedTimeMillis()*1.0f/splashWait)*480.0f,6);
			ofDisableAlphaBlending();
		}else{
			// image
			glColor4f(1.0,1.0,1.0,1.0);
			splashImage.draw((MAIN_WINDOW_W/2) - 256,(MAIN_WINDOW_H/2) - 153);
			// loading bar
			ofSetColor(9,147,211,235);
			ofRect((MAIN_WINDOW_W/2) - 240,(MAIN_WINDOW_H/2) - 144,(ofGetElapsedTimeMillis()*1.0f/splashWait)*480.0f,6);
			ofDisableAlphaBlending();
		}
	}

}
示例#5
0
//-------------------------------
void ofxControlPanel::draw(){
    if( hidden ) return;

	lastFrameDrawn	= ofGetFrameNum();

    ofPushStyle();
    ofEnableAlphaBlending();

        float panelH = boundingBox.height;
        if( minimize ){
            panelH = topBar.height;
        }

		if(!bInvisible || !elementSelected){

			glPushMatrix();
				glTranslatef(boundingBox.x, boundingBox.y, 0);
				//draw the background
				ofFill();
				glColor4fv(bgColor.getColorF());
				ofRect(0, 0, boundingBox.width, panelH);

				//draw the outline
				ofNoFill();
				glColor4fv(outlineColor.getColorF());
				ofRect(0, 0, boundingBox.width, panelH);
				ofLine(0, topBar.height, boundingBox.width, topBar.height);
			glPopMatrix();

			ofRect(minimizeButton.x, minimizeButton.y, minimizeButton.width, minimizeButton.height);

			if ( bDoSaveRestore ){
				ofPushStyle();
					ofFill();

					if( saveDown )glColor4fv(fgColor.getSelectedColorF());
					else glColor4fv(fgColor.getColorF());

					ofRect(saveButton.x, saveButton.y, saveButton.width,saveButton.height);
					ofSetColor(255, 255, 255);
				
					displayText.renderString("save", saveButton.x + 3, saveButton.y + saveButton.height -3);

				ofPopStyle();

				ofPushStyle();
					ofFill();

					if( restoreDown )glColor4fv(fgColor.getSelectedColorF());
					else glColor4fv(fgColor.getColorF());

					ofRect(restoreButton.x, restoreButton.y, restoreButton.width,restoreButton.height);
					ofSetColor(255, 255, 255);
				
					displayText.renderString("restore", restoreButton.x + 3, restoreButton.y + restoreButton.height -3);
				
				ofPopStyle();
			}


			ofPushMatrix();
				ofTranslate(2,0,0);
				glColor4fv(textColor.getColorF());
				guiBaseObject::renderText();
			ofPopMatrix();
		
		}

        if( !minimize ){

            //don't let gui elements go out of their panels
            glEnable(GL_SCISSOR_TEST);
            glScissor(boundingBox.x, ofGetHeight() - ( boundingBox.y + boundingBox.height - (-2 + topSpacing) ), boundingBox.width - borderWidth , boundingBox.height);

				if(!bInvisible || !elementSelected){
					for(int i = 0; i < (int) panelTabs.size(); i++){
						if( i == selectedPanel){
							ofPushStyle();
								ofFill();
								glColor4fv(fgColor.getSelectedColorF());
								ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
								glColor4fv(outlineColor.getColorF());
							ofPopStyle();
						}
						glColor4fv(outlineColor.getColorF());
						ofNoFill();
						ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
					}
				}

                glPushMatrix();
                    glTranslatef(hitArea.x, hitArea.y, 0);
                    for(int i = 0; i < (int) panels.size(); i++){
                        if( i == selectedPanel ){
							panels[i]->setShowOnlySelectedElement(bInvisible);
							panels[i]->render();
						}
					}
                glPopMatrix();

            glDisable(GL_SCISSOR_TEST);
        }

    ofPopStyle();
	
	if(bShowStatusBar){
		ofPushStyle();
		
			float textH = displayText.getTextSingleLineHeight() + 4;
			
			float yPos = ofGetHeight()-textH;
		
			glColor4fv(bgColor.getColorF());
			ofRect(0, yPos, ofGetWidth(), textH);
			
			glColor4fv(textColor.getColorF());
			displayText.renderString("Fps: " + ofToString(ofGetFrameRate(), 0) + "  Status: " + statusMessage, 4, yPos + textH - 4);
			
		ofPopStyle();
	}
}
示例#6
0
//--------------------------------------------------------------
void testApp::draw()
{
//	glActiveTexture(GL_TEXTURE0);
    if (bSetup)
    {

        arhelper.draw();
        if (bText)
        {

            glPushMatrix();
            ofSetColor(255 , 255, 255 );
            string msg = "";;
            myFont.drawString(msg, (ofGetWidth()/2)-myFont.stringWidth(msg)/2,ofGetHeight()/2);
            glPopMatrix();
        }
        ofSetupScreen();
        glDisable(GL_DEPTH_TEST);
        if (fadable.getAlpha()>0)
        {
            ofPushStyle();
            ofEnableAlphaBlending();
            ofSetColor(0,0,0,maskA*fadable.getAlpha());
            ofRect(0,0,ofGetWidth(),ofGetHeight());



            if (bLoaded)
            {
#ifdef INSTRUCTION
                int cx = ofGetWidth()/2;
                int cy = ofGetHeight()/2;
                ofSetColor(255,255,255);

                shaderBGSub.setShaderActive(true);
                shaderBGSub.setUniform("tex1", 1);
                shaderBGSub.setUniform("tex2", 2);
                shaderBGSub.setUniform("tol", tol);
                player.draw(cx-vw/2,cy-vh/2);


                myTexture2.unbind();
                myTexture.unbind();

                shaderBGSub.setShaderActive(false);
                glDisable(GL_DEPTH_TEST);
#endif //#ifdef INSTRUCTION
            }

            ofDisableAlphaBlending();
            ofPopStyle();
        }
		ofSetColor(0xffffff);
        gui.draw();

    }
    else
    {
        ofEnableAlphaBlending();
        ofSetColor(255,255,255,255*sinf(ofGetElapsedTimef())+125);
        loading.draw(0,0);
        ofDisableAlphaBlending();
        ofDrawBitmapString("Loading ... ",ofGetWidth()/2,ofGetHeight()/2);
    }
}
示例#7
0
//--------------------------------------------------------------
void testApp::draw(){
    ofRectangle previewWindow(20,20,640,480);
    ofRectangle playbackWindow(20+640,20,640,480);

    // draw the background boxes
    ofPushStyle();
    ofSetColor(0);
    ofFill();
    ofRect(previewWindow);
    ofRect(playbackWindow);
    ofPopStyle();
    
    // draw the preview if available
	if(vidRecorder->hasPreview()){
        ofPushStyle();
        ofFill();
        ofSetColor(255);
        // fit it into the preview window, but use the correct aspect ratio
        ofRectangle videoGrabberRect(0,0,vidGrabber.getWidth(),vidGrabber.getHeight());
        videoGrabberRect.scaleTo(previewWindow);
        vidGrabber.draw(videoGrabberRect);
        ofPopStyle();
    } else{
		ofPushStyle();
		// x out to show there is no video preview
        ofSetColor(255);
		ofSetLineWidth(3);
		ofLine(20, 20, 640+20, 480+20);
		ofLine(20+640, 20, 20, 480+20);
		ofPopStyle();
	}
    
    // draw the playback video
    if(recordedVideoPlayback.isLoaded()){
        ofPushStyle();
        ofFill();
        ofSetColor(255);
        // fit it into the preview window, but use the correct aspect ratio
        ofRectangle recordedRect(ofRectangle(0,0,recordedVideoPlayback.getWidth(),recordedVideoPlayback.getHeight()));
        recordedRect.scaleTo(playbackWindow);
        recordedVideoPlayback.draw(recordedRect);
        ofPopStyle();
    }

    ofPushStyle();
    ofNoFill();
    ofSetLineWidth(3);
    if(vidRecorder->isRecording()){
        //make a nice flashy red record color
        int flashRed = powf(1 - (sin(ofGetElapsedTimef()*10)*.5+.5),2)*255;
		ofSetColor(255, 255-flashRed, 255-flashRed);
    }
    else{
    	ofSetColor(255,80);
    }
    ofRect(previewWindow);
    ofPopStyle();
    
    
    //draw instructions
    ofPushStyle();
    ofSetColor(255);
    ofDrawBitmapString("' ' space bar to toggle recording", 680, 540);
    ofDrawBitmapString("'v' switches video device", 680, 560);
    ofDrawBitmapString("'a' swiches audio device", 680, 580);
    
    //draw video device selection
    ofDrawBitmapString("VIDEO DEVICE", 20, 540);
    for(int i = 0; i < videoDevices.size(); i++){
        if(i == vidRecorder->getVideoDeviceID()){
			ofSetColor(255, 100, 100);
        }
        else{
            ofSetColor(255);
        }
        ofDrawBitmapString(videoDevices[i], 20, 560+i*20);
    }
    
    //draw audio device;
    int startY = 580+20*videoDevices.size();
    ofDrawBitmapString("AUDIO DEVICE", 20, startY);
    startY += 20;
    for(int i = 0; i < audioDevices.size(); i++){
        if(i == vidRecorder->getAudioDeviceID()){
			ofSetColor(255, 100, 100);
        }
        else{
            ofSetColor(255);
        }
        ofDrawBitmapString(audioDevices[i], 20, startY+i*20);
    }
    ofPopStyle();
}
void MaskFrame::drawLive(DisplayMode mode, StretchMode stretchMode){
    ofPushMatrix();
    ofTranslate(this->livePosition.x, this->livePosition.y);
    
    if(this->canDrawLive()){
        homographyMode = stretchMode == HOMOGRAPHY && maskPoints.size() == 4;
        ofSetColor(ofColor::white);
        
        if(homographyMode) {
            prepareHomography();
            homography.begin(input, output);
            pattern->drawLayer(0, false);
            homography.end();
        } else {
            pattern->beginMask();
            ofPushStyle();
            {
                ofFill();
                ofBackground(ofColor::black);
                ofBeginShape();
                for(int i = 0; i < maskPoints.size(); i++){
                    if(stretchMode == STRETCH_TO_MASKFRAME) {
                        x = ofMap(maskPoints[i]->getLiveX(), 0, getLiveWidth(), 0, pattern->getWidth());
                        y = ofMap(maskPoints[i]->getLiveY(), 0, getLiveHeight(), 0, pattern->getHeight());
                    } else {
                        x = maskPoints[i]->getLiveX();
                        y = maskPoints[i]->getLiveY();
                    }
                    ofVertex(x, y);
                }
                ofEndShape();
            }
            ofPopStyle();
            pattern->endMask();
            
            if(stretchMode == STRETCH_TO_MASKFRAME) {
                pattern->draw(0, 0, getLiveWidth(), getLiveHeight());
            } else {
                pattern->draw();
            }
        }
    }
    
    if(mode != Live){
        
        bool hasHighlightedDragHandle = this->hasHighlightedDragHandle();
        bool hasHighlightedMaskPoint = this->hasHighlightedMaskPoint();

        ofPushStyle();
        {
            if((highlighted || hasHighlightedDragHandle || getTransformState() == Scaling) && !hasHighlightedMaskPoint){
                ofSetColor(highlightedColor);
            }else{
                ofSetColor(notHighlightedColor);
            }
            ofRect(0, 0, this->liveWidth, this->liveHeight);

            if((highlighted || hasHighlightedDragHandle) && !hasHighlightedMaskPoint){
                for(int i = 0; i < dragHandles.size(); i++){
                    dragHandles[i]->drawLive();
                }
            }
        }
        ofPopStyle();
    }
        
    if(mode == Design){
        if(maskPoints.size() > 2){
            ofSetColor(maskLineColor);
            for(int i = 0; i < maskPoints.size(); i++){
                int nextIndex = getNextIndex(i, maskPoints.size());
                ofLine(maskPoints[i]->getLiveX(), maskPoints[i]->getLiveY(), maskPoints[nextIndex]->getLiveX(), maskPoints[nextIndex]->getLiveY());
            }
        }
    }
    
    if(mode != Live){
        
        if(this->hasAGhostPoint){
            ghostPoint.drawLive();
        }
        
        for(int i = 0; i < maskPoints.size(); i++){
            maskPoints[i]->drawLive();
        }
    }
    
    ofPopMatrix();
}
示例#9
0
文件: ofApp.cpp 项目: tokujin/pool
//--------------------------------------------------------------
void ofApp::draw(){
	
    
    gui.draw();
    
	videoGrayscaleCvImage.draw(120,20, 312,240);
    //	videoBgImage.draw(312+40, 20, 312, 240);

    //	this is where the point image comes(20,240+40);
	panel.draw();

    //draw 24x24
    
    ofSetColor(255, 255, 255);
    for (int i = 0; i*10 < video.getWidth()-72; i++){
		for (int j = 0; j*10 < video.getHeight(); j++){
			int pct = ofMap(leds_flip[24*j+i], 0,255, 0,5);
			ofSetColor(255,255,255);
			ofCircle(120 + i*10 + 13/2, 240 + 40 + j*10 + 10/2, pct);
		}
    
    //draw 8x72
    for (int i=0; i<72; i++) {
        for (int j=0; j<8; j++) {
            int pct = ofMap(led_matrix[j][i], 0, 255, 0, 5);
            ofCircle(120-1 + 13/2 + i*10, 280-1 + 240 + 20 + 10/2 + j*10, pct);
        }
    }

    //additional line
    ofPushStyle();
        ofNoFill();
        ofSetColor(255, 0, 0);
        ofSetLineWidth(1.5);
        ofSetRectMode(OF_RECTMODE_CORNER);
    
        //3x3 grid
        for (int i=0; i<3; i++) {
            for (int j=0; j<3; j++) {
                ofRect(120-1 + 240/3*i,280-1 + 240/3*j, 240/3, 240/3);
            }
        }
        ofSetColor(0, 255, 0);
    
        //9 strip
        for (int i=0; i<9; i++) {
            ofRect(120-1 + 240/3*i,280-1 + 240 + 20, 240/3, 240/3);
        }
    
        //8 lines for casode
        ofSetColor(255, 0, 0);
        for (int i=0; i<8; i++) {
            ofLine(120-1 +13/2, 280-1 + 240 + 20 + 10/2 + 10*i, 120-1 +13/2 + 10*(72-1), 280-1 + 240 + 20 + 10/2 + 10*i);
        }
    
    ofPopStyle();
    }
    
    
    if(!isInitialized)
        ofDrawBitmapString("PRESS 'S' TO SEND KICKOFF BYTE", 400, 400);
    else {
        //just for debug
        ofDrawBitmapString("num messages sent total: "+ ofToString(numMsgSent), 400, 450);
    }

}
示例#10
0
//--------------------------------------------------------------
void testApp::draw() {
    ofBackground(0); 
    ofSetColor(255);
    ofSetRectMode(OF_RECTMODE_CORNER);
    backgroundimg.draw(0,0, ofGetWidth(), ofGetHeight());
    ofSetColor(0, 173, 238, 125);
               
    if(startScreen){
        ofSetColor(236, 28, 36);
        visitor82.drawString("VFA PONG", bounds.x + bounds.width/2 - visitor82.stringWidth("VFA PONG")/2, bounds.y + bounds.height/2);
        visitor82.drawString("Press button to start a new game",  bounds.x + bounds.width/2 - 775,bounds.y + bounds.height/2 + 100);        printf("startscreen \n");
    }
   
    if(!user1load && players && !startScreen){
        //    printf("alpha: %d: \n", alpha);
        ofSetColor(0, 173, 238, alpha);
        ofSetRectMode(OF_RECTMODE_CORNER);
        ofRect(bounds.x,bounds.y + 86, bounds.width/2, bounds.height - 86);
        ofSetColor(255);
        visitor82.drawString("Left Player Tap!", bounds.x + 80, bounds.y + bounds.height/2);
        visitor42.drawString("Press button to play as guest!", bounds.x + 30, bounds.y + bounds.height/2 + 100);
    }
    
    if(user1load && !user2load && players){
        ofSetColor(0, 173, 238, alpha);
        ofSetRectMode(OF_RECTMODE_CORNER);
        ofRect(bounds.x + bounds.width/2, bounds.y + 86, bounds.width/2, bounds.height - 86);
        ofSetColor(255);
        user1.draw(bounds.x + bounds.width/4 - 50, bounds.height/2, 100, 100);
        visitor82.drawString(username1, bounds.x + bounds.width/4 - visitor82.stringWidth(username1)/2, bounds.y + bounds.height/2 + 120);
        ofSetColor(255);
        visitor82.drawString("Right Player Tap!", bounds.x + bounds.width/2 + 80, bounds.y + bounds.height/2);
        visitor42.drawString("Press button to play as guest", bounds.x + 30 + bounds.width/2, bounds.y + bounds.height/2 + 100);
        
    }
    
    if(user1load &&  user2load){
        countdownnumbool = true;
        ofSetColor(255);
        user1.draw(bounds.x + bounds.width/4 - 50, bounds.height/2, 100, 100);
        user2.draw(bounds.x + bounds.width/4 - 50 + bounds.width/2, bounds.height/2, 100, 100);
        visitor82.drawString(username1, bounds.x + bounds.width/4 - visitor82.stringWidth(username1)/2, bounds.y + bounds.height/2 + 120);
        visitor82.drawString(username2, bounds.x + bounds.width/4 - visitor82.stringWidth(username2)/2 + bounds.width/2, bounds.y + bounds.height/2 + 120);
        if(countdownnum > 300)
            visitor82.drawString("3", bounds.x + bounds.width/2, bounds.y + bounds.height/2);
        if(countdownnum > 200 &&countdownnum < 300 )
            visitor82.drawString("2", bounds.x + bounds.width/2, bounds.y + bounds.height/2);
        if(countdownnum > 100 && countdownnum < 200)
            visitor82.drawString("1", bounds.x + bounds.width/2, bounds.y + bounds.height/2);
        if(countdownnum > 0 && countdownnum < 100)
            visitor82.drawString("GO!", bounds.x + bounds.width/2, bounds.y + bounds.height/2);
        if (countdownnum == 0 && countdownnumbool){
            countdownnumbool = false;
            countdownnum = 400;
            startGame();
            drawusers = true;
            players = false;
            user1load = false;
            user2load = false;
            newBall();
        }
        
    }
    if(startGameBool){
	
	for(int i=0; i<circles.size(); i++) {
	Data * data = (Data*)circles[i].getData();
        ofSetColor(255);
        ofEnableAlphaBlending();
      //  ofRectMode(OF_RECTMODE_CORNER);
        vimeologo.draw(circles[i].getPosition().x, circles[i].getPosition().y, circles[i].getRadius() * 2, circles[i].getRadius() * 2); 

	}
	

	for(int i=0; i<paddles.size(); i++) {
		ofFill();
		Data * data = (Data*)paddles[i].getData();
        ofSetColor(236, 28, 36);
		paddles[i].draw();
	}
    
    for(int i=0; i<winningvideos.size(); i++) {
        winningvideos[i].draw();
       	}
    
    for(int i=0; i<nomvideos.size(); i++) {
        nomvideos[i].draw();
	}
    
    if (score1 > 4 && counter < 200) {
        ofSetColor(255,221,21);
        visitor82.drawString("YOU WIN!", bounds.x + bounds.width/4 - visitor82.stringWidth("YOU WIN!")/2, bounds.y + bounds.height/2 - 120);
        visitor82.drawString("YOU LOSE!", bounds.x + bounds.width/4 - visitor82.stringWidth("YOU LOSE!")/2 + bounds.width/2, bounds.y + bounds.height/2 - 120);        
        ofSetColor(255);
        ofSetRectMode(OF_RECTMODE_CORNER);
        user1.draw(bounds.x + bounds.width/4 - 50,  bounds.height/2 + 20, 100, 100);
        user2.draw(bounds.x + bounds.width/4 - 50 + bounds.width/2,  bounds.height/2 + 20, 100, 100);
        ofSetColor(255,221,21);
        visitor82.drawString(username1, bounds.x + bounds.width/4 - visitor82.stringWidth(username1)/2, bounds.y + bounds.height/2 + 120);
        visitor82.drawString(username2, bounds.x + bounds.width/4 - visitor82.stringWidth(username2)/2 + bounds.width/2, bounds.y + bounds.height/2 + 120);
        
        counter++;
        if (!user1photo.compare("images/guest.jpg")){
        ofxOscMessage m;
		m.setAddress( "/user" );
		m.addStringArg( user1photo );
        sender.sendMessage( m );
        }

    }
    if (score2 > 4 && counter < 200) {
        ofSetColor(255,221,21);
        visitor82.drawString("YOU LOSE!", bounds.x + bounds.width/4 - visitor82.stringWidth("YOU LOSE!")/2, bounds.y + bounds.height/2 - 120);
        visitor82.drawString("YOU WIN!", bounds.x + bounds.width/4 - visitor82.stringWidth("YOU WIN!")/2 + bounds.width/2, bounds.y + bounds.height/2 - 120);        
        ofSetColor(255);
        ofSetRectMode(OF_RECTMODE_CORNER);
        user1.draw(bounds.x + bounds.width/4 - 50,  bounds.height/2 + 20, 100, 100);
        user2.draw(bounds.x + bounds.width/4 - 50 + bounds.width/2,  bounds.height/2 + 20, 100, 100);
        ofSetColor(255,221,21);
        visitor82.drawString(username1, bounds.x + bounds.width/4 - visitor82.stringWidth(username1)/2, bounds.y + bounds.height/2 + 120);
        visitor82.drawString(username2, bounds.x + bounds.width/4 - visitor82.stringWidth(username2)/2 + bounds.width/2, bounds.y + bounds.height/2 + 120);
        
        counter++;
        if (!user2photo.compare("images/guest.jpg")){
            ofxOscMessage m;
            m.setAddress( "/user" );
            m.addStringArg( user2photo );
            sender.sendMessage( m );
        }
    }

   	ofSetColor(236, 28, 36);
    
    if (drawusers){
    visitor82.drawString("SCORE " + ofToString(score1, 1), bounds.x+120, bounds.y +65);
    visitor82.drawString("SCORE " + ofToString(score2, 1), bounds.x + bounds.width/2 + 120, bounds.y +65);
    ofSetColor(255);
    user1.draw(bounds.x+ 30, bounds.y+35, 80,80);
    user2.draw(bounds.x+ 30 + bounds.width/2, bounds.y+35, 80,80);
    }
    }
    

}
示例#11
0
文件: testApp.cpp 项目: MrMdR/julapy
//--------------------------------------------------------------
void testApp::draw()
{
	tileSaver.begin();
	
	//-- background.
	
	ofFill();
	ofSetColor( 0x000000 );
	ofRect( 0, 0, ofGetWidth(), ofGetHeight() );
	
	//-- large.
	
	if( bDrawColor )
	{
		ofColor c0 = colorPicker0.getColor();
		
		ofFill();
		ofSetColor( c0.r, c0.g, c0.b );
		ofRect( 0, 0, ofGetWidth(), ofGetHeight() );
		
		drawContourLines( contourBlobsSimplified, true );
	}
	
	if( bDrawLines )
	{
		ofNoFill();
		ofSetColor( 0xFFFFFF );
		drawContourLines( contourBlobsScaled );
	}
	
	if( bDrawSimplified )
	{
		ofNoFill();
		ofSetColor( 0xFFFFFF );
		drawContourLines( contourBlobsSimplified );
	}
	
	if( bDrawCurves )
	{
		ofNoFill();
		ofSetColor( 0xFFFFFF );
		drawContourCurveLines( contourBlobsScaled );
	}
	
	if( bDrawPoints )
	{
		ofFill();
		ofSetColor( 0xFF0000 );
		drawContourPoints( contourBlobsScaled );
	}
	
	tileSaver.end();
	
	if( screenGrabUtil.isRecording() )
		screenGrabUtil.save();
	
	//-- debug.
	
	if( !bDebug )
		return;
	
	int pad;
	pad = 10;
	
	glPushMatrix();
	glTranslatef( ofGetWidth() - debugRect.width - pad, pad, 0 );
	
	drawBorder( debugRect );
	drawNoiseImage();
	
	glTranslatef( 0, debugRect.height + pad, 0 );
	
	drawBorder( debugRect );
	drawNoiseBand();

	glTranslatef( 0, debugRect.height + pad, 0 );
	
	drawBorder( debugRect );
	drawNoiseBandSum();

	glTranslatef( 0, debugRect.height + pad, 0 );
	
	drawBorder( debugRect );
	drawContoursSmall();
	
	glPopMatrix();
	
	gui.draw();
}
示例#12
0
//--------------------------------------------------------------
void testApp::draw(){
#pragma mark BUTTON
    if(folderPath == "")
        ofSetColor(100, 100, 100);
    else
        ofSetColor(100, 200, 100);
    ofRect(10, 10, 100, 40);
    
    if(!imageCnt)
        ofSetColor(100, 100, 100);
    else
        ofSetColor(100, 200, 100);
    ofRect(120, 10, 100, 40);
    
    if(!colorTable.size())
        ofSetColor(100, 100, 100);
    else
        ofSetColor(100, 200, 100);
    ofRect(230, 10, 100, 40);
    
    if(!bFileDone)
        ofSetColor(100, 100, 100);
    else
        ofSetColor(100, 200, 100);
    ofRect(340, 10, 100, 40);
    
#pragma mark BUTTON TEXT
    ofSetColor(0, 0, 0);
    ofDrawBitmapString(" Open(O)", 10, 35);
    ofDrawBitmapString(" Load(L)", 120, 35);
    ofDrawBitmapString(" Analysts(A)", 230, 35);
    ofDrawBitmapString(" Create(C)", 340, 35);
    
#pragma mark IMAGE SCALE
    ofSetColor(150,0,0);
    ofDrawBitmapString("set Image Width  : " + ofToString(imgWidth), 10, 70);
    ofDrawBitmapString("set Image Height : " + ofToString(imgHeight), 10, 90);
    
#pragma mark SCALE CONTROL BUTTON
    ofSetColor(150,150,150);
    ofRect(204+36*0+4*0, 58, 36, 16);
    ofRect(204+36*1+4*1, 58, 36, 16);
    ofRect(204+36*2+4*2, 58, 36, 16);
    ofRect(204+36*3+4*3, 58, 36, 16);
    ofRect(204+36*4+4*4, 58, 36, 16);
    ofRect(204+36*5+4*5, 58, 36, 16);
    
    ofRect(204+36*0+4*0, 78, 36, 16);
    ofRect(204+36*1+4*1, 78, 36, 16);
    ofRect(204+36*2+4*2, 78, 36, 16);
    ofRect(204+36*3+4*3, 78, 36, 16);
    ofRect(204+36*4+4*4, 78, 36, 16);
    ofRect(204+36*5+4*5, 78, 36, 16);
    
    ofSetColor(150,0,0);
    ofDrawBitmapString("+100 -100  +10  -10   +1   -1", 206, 70);
    ofDrawBitmapString("+100 -100  +10  -10   +1   -1", 206, 90);
    
#pragma mark RESULT STRING
    ofSetColor(0);
    if(folderPath.length() >= 35)
    {
        tmpPath = folderPath;
        while (tmpPath.size() > 35)
        {
            tmpPath.erase(tmpPath.begin());
        }
        ofDrawBitmapString("Folder Path : ..." + tmpPath, 10, 120);
    }
    else
        ofDrawBitmapString("Folder Path : " + folderPath, 10, 120);
    
    ofDrawBitmapString("Loaded Image : " + ofToString(imageCnt), 10, 140);
    ofDrawBitmapString("Pixel : " + ofToString(colorCnt), 10, 160);
    
    if (colorTable.size() > 0)
    {
        ofDrawBitmapString("Used Color : " + ofToString(colorTable.size()), 10, 180);
    }else{
        ofDrawBitmapString("Used Color : 0", 10, 180);
    }
    
#pragma mark EXPANSION PANNEL
    if(bFileDone){
        ofSetWindowShape(450,330);
        ofDrawBitmapString("------------------------------------------------------", 10, 200);
        if(ofToInt(chgColorNumStr) >= 1 && ofToInt(chgColorNumStr) <= colorCnt+1){
            for(int i=0; i<cutterInt.size(); i++){
                ofSetColor(colorTable[cutterInt[i]-1]);
                ofRect(10+i*430/cutterInt.size(), 224, 430/cutterInt.size(), 20);
            }
        }else{
            ofSetColor(255,255,255);
            ofRect(10, 224, 430, 20);
        }
        ofSetColor(0);
        if(chgColorNumStr.length() >= 30){
            int tmp = chgColorNumStr.length();
            ofDrawBitmapString("                     "+ chgColorNumStr, 12+(30-tmp)*8, 218);
        }else{
            ofDrawBitmapString("                     "+ chgColorNumStr, 12, 218);
        }
        ofSetColor(200, 200, 200);
        ofRect(0,200, 173, 20);
        ofSetColor(0);
        ofDrawBitmapString("input color number : ",12, 218);
        
        
        ofSetColor(wantColor);
        ofRect(10, 244, 430, 20);
        
        ofSetColor(150,150,150);
        ofRect(10, 278, 60, 40);
        ofSetColor(0);
        ofDrawBitmapString("Change", 12, 302);
    }
    
#pragma mark SCALE CONTROL BUTTON2
    ofSetColor(150,0,0);
    ofDrawBitmapString("R : " + ofToString(wr),  110, 278);
    ofDrawBitmapString("G : " + ofToString(wg), 110, 298);
    ofDrawBitmapString("B : " + ofToString(wb), 110, 318);
    
    ofSetColor(150,150,150);
    ofRect(204+36*0+4*0, 266, 36, 16);
    ofRect(204+36*1+4*1, 266, 36, 16);
    ofRect(204+36*2+4*2, 266, 36, 16);
    ofRect(204+36*3+4*3, 266, 36, 16);
    ofRect(204+36*4+4*4, 266, 36, 16);
    ofRect(204+36*5+4*5, 266, 36, 16);
    
    ofRect(204+36*0+4*0, 286, 36, 16);
    ofRect(204+36*1+4*1, 286, 36, 16);
    ofRect(204+36*2+4*2, 286, 36, 16);
    ofRect(204+36*3+4*3, 286, 36, 16);
    ofRect(204+36*4+4*4, 286, 36, 16);
    ofRect(204+36*5+4*5, 286, 36, 16);
    
    ofRect(204+36*0+4*0, 306, 36, 16);
    ofRect(204+36*1+4*1, 306, 36, 16);
    ofRect(204+36*2+4*2, 306, 36, 16);
    ofRect(204+36*3+4*3, 306, 36, 16);
    ofRect(204+36*4+4*4, 306, 36, 16);
    ofRect(204+36*5+4*5, 306, 36, 16);
    
    ofSetColor(150,0,0);
    ofDrawBitmapString("+100 -100  +10  -10   +1   -1", 206, 278);
    ofDrawBitmapString("+100 -100  +10  -10   +1   -1", 206, 298);
    ofDrawBitmapString("+100 -100  +10  -10   +1   -1", 206, 318);
    
    
#pragma mark PROCESS MESSAGE
    if(bPushLoad)
    {
        ofSetColor(100, 100, 100);
        ofRect(0, 0, 450, 200);
        ofSetColor(255, 255, 255);
        ofDrawBitmapString("Load... ", 190, 100);
        bLoad = true;
    }
    
    if(bPushAnal)
    {
        ofSetColor(100, 100, 100);
        ofRect(0, 0, 450, 200);
        ofSetColor(255, 255, 255);
        ofDrawBitmapString("Analyst... ", 190, 100);
        bAnal = true;
    }
    
    if(bPushCreate)
    {
        ofSetColor(100, 100, 100);
        ofRect(0, 0, 450, 200);
        ofSetColor(255, 255, 255);
        ofDrawBitmapString("Create... ", 190, 100);
        bCreate = true;
    }
    
    if(bImageMakePush)
    {
        ofSetColor(100, 100, 100);
        ofRect(0, 0, 450, 270);
        ofSetColor(255, 255, 255);
        ofDrawBitmapString("Change... ", 190, 100);
        bImageMakeStart = true;
    }
}
示例#13
0
//--------------------------------------------------------------
void ofApp::draw(){

	float lineHeight = ofMap(mouseY, 0, ofGetHeight(), 0, 2, true);
	unicodeFont.setLineHeight(lineHeight);

	float x = 30;
	float y = 40;
	
	string demoText = "This is my text in BitStream Vera font.";
	float fontSize = 28;

	// simple demo //////////////////////////////////////////////////////////
	
	drawPoint(x, y);		//draw insertion point	

	ofSetColor(255);
	TIME_SAMPLE_START("simple draw");
	font.draw(
				  demoText,	//text to draw
				  fontSize,	//font size
				  x,		//x coord where to draw
				  y			//y coord where to draw
			  );
	TIME_SAMPLE_STOP("simple draw");

	// bounding box demo ///////////////////////////////////////////////////
	ofRectangle bbox;
	ofRectangle bboxMultiline;

	ofSetColor(255, 0, 0, 32);
	TIME_SAMPLE_START("bbox");
	bbox = font.getBBox( demoText, fontSize, x, y);
	TIME_SAMPLE_STOP("bbox");
	ofRect( bbox );

	// draw multiline text /////////////////////////////////////////////////
	
	y += 25 + bbox.height;
	drawPoint(x, y); //draw insertion point	
	
	ofSetColor(255);
	string s = (string)"ofxFontStash can draw multiline text" + "\n" +
	"It also supports unicode strings: " + "\n" +
	"槊監しゅ祟䤂לרפובליקה. אם מיזם 銆銌 憉 圩芰敔 तकनिकल कार्यलय";

	TIME_SAMPLE_START("drawMultiLine");
	unicodeFont.drawMultiLine( s,  fontSize, x, y);
	TIME_SAMPLE_STOP("drawMultiLine");
	
	// multiline bbox /////////////////////////////////////////////////////

	ofSetColor(0, 255, 0, 32);
	TIME_SAMPLE_START("getBoundingBoxSize");
	bboxMultiline = unicodeFont.getBBox( s, fontSize, x, y);
	TIME_SAMPLE_STOP("getBoundingBoxSize");
	ofRect( bboxMultiline );


	// draw multiline column with a fixed width ///////////////////////////

	y += 25 + bboxMultiline.height;
	drawPoint(x, y); //draw insertion point

	ofSetColor(255);
	s = "And you can wrap text to a certain (mouseX) width:\n\nLorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam.";
	//s = "international bananas";

	int numLines = 0;
	bool wordsWereCropped;
	ofRectangle column;
	TIME_SAMPLE_START("drawMultiLineColumn");
	column = font.drawMultiLineColumn(	s,			/*string*/
										fontSize,	/*size*/
										x, y,		/*where*/
										MAX( 10 ,mouseX - x), /*column width*/
										numLines,	/*get back the number of lines*/
										false,		/* if true, we wont draw (just get bbox back) */
										5,			/* max number of lines to draw, crop after that */
										true,		/*get the final text formatting (by adding \n's) in the supplied string;
													 BE ARWARE that using TRUE in here will modify your supplied string! */
										&wordsWereCropped /* this bool will b set to true if the box was to small to fit all text*/
									 );
	TIME_SAMPLE_STOP("drawMultiLineColumn");


	//report if some words had to be cropped to fit in the column when using drawMultiLineColumn()
	if(!wordsWereCropped) ofSetColor(255,32);
	else (ofGetFrameNum()%6 <= 2) ? ofSetColor(255,32):ofSetColor(255,0,0,32); //flash if cropped
	ofRect(column);


	// batch drawing, optimized for multiple drawing calls /////////////////

	y += column.height + 25;
	drawPoint(x, y); //draw insertion point

	ofSetColor(255);
	TIME_SAMPLE_START("drawBatch");
	font.beginBatch();	//call "begin" before drawing fonts
	for (int i = 0; i < 5; i++){
		font.drawBatch("batch mode #" + ofToString(i+1), fontSize, x, y + i * fontSize );
	}
	font.endBatch();		//call "end" once finished
	TIME_SAMPLE_STOP("drawBatch");

	// formatted text //////////////////////////////////////////////////////

	string formattedText = "the #0xff0000 @1 %2.0 red %1.0 #0xffffff @0 apple is on the big %4.0 #0x00ff00 tree.";

	ofPushMatrix();
	ofTranslate(20,500);
	ofSetColor(255);
	ofVec2f size = font.drawMultiColumnFormatted(formattedText, 22, mouseX);
	ofSetColor(255,10);
	ofRect(0, 0, size.x, size.y);
	ofPopMatrix();


	// rotating text ///////////////////////////////////////////////////////
	
	ofPushMatrix();
		ofTranslate(x + 400, y + 50);
		ofRotate( -200 * ofGetElapsedTimef(), 0, 0, 1);
		ofSetColor(ofRandom(255), ofRandom(255), ofRandom(255));
		font.draw("surrealismoooo!", fontSize, 0, 0 );
		drawPoint(0,0);
	ofPopMatrix();

	// scaling text with mipmaps ///////////////////////////////////////////

	ofPushMatrix();
	ofTranslate(600, 40);
	float scale = mouseY /(float) ofGetHeight();
	ofPushMatrix();
	ofScale(scale, scale);
	ofSetColor(255);
	unicodeFont.draw("MIPMAPS :)", fontSize * 2, 0, 0 );
	drawPoint(0,0);
	ofPopMatrix();

	ofTranslate(0, 30);
	ofScale(scale, scale);
	font.draw("NO MIPMAPS :(", fontSize * 2, 0, 0 );
	drawPoint(0,0);
	ofPopMatrix();


}
示例#14
0
void ofxTLCurves::drawModalContent(){
	
	//****** DRAW EASING CONTROLS
	if(!drawingEasingWindow){
    	return;
    }
	
    ofxTLTweenKeyframe* tweenFrame = (ofxTLTweenKeyframe*) selectedKeyframe;
	if(tweenFrame == NULL){
		if(selectedKeyframes.size() == 0){
			return;
		}
		tweenFrame = (ofxTLTweenKeyframe*)selectedKeyframes[0];
	}
	
	for(int i = 0; i < easingTypes.size(); i++){
        //TODO turn into something like selectionContainsEaseType();
        //so that we can show the multi-selected easies
        if(easingTypes[i] ==  ((ofxTLTweenKeyframe*)selectedKeyframes[0])->easeType){
            ofSetColor(150, 100, 10);
        }
        else{
            ofSetColor(80, 80, 80);
        }
        ofFill();
        ofRect(easingWindowPosition.x + easingTypes[i]->bounds.x, easingWindowPosition.y + easingTypes[i]->bounds.y,
               easingTypes[i]->bounds.width, easingTypes[i]->bounds.height);
        ofSetColor(200, 200, 200);
        timeline->getFont().drawString(easingTypes[i]->name,
									   easingWindowPosition.x + easingTypes[i]->bounds.x+11,
									   easingWindowPosition.y + easingTypes[i]->bounds.y+10);
        ofNoFill();
        ofSetColor(40, 40, 40);
        ofRect(easingWindowPosition.x + easingTypes[i]->bounds.x,
               easingWindowPosition.y + easingTypes[i]->bounds.y,
               easingTypes[i]->bounds.width, easingTypes[i]->bounds.height);
    }

    for(int i = 0; i < easingFunctions.size(); i++){
        //TODO: turn into something like selectionContainsEaseFunc();
        if(easingFunctions[i] == tweenFrame->easeFunc){
            ofSetColor(150, 100, 10);
        }
        else{
            ofSetColor(80, 80, 80);
        }
        ofFill();
        ofRect(easingWindowPosition.x + easingFunctions[i]->bounds.x, easingWindowPosition.y +easingFunctions[i]->bounds.y, 
               easingFunctions[i]->bounds.width, easingFunctions[i]->bounds.height);
        ofSetColor(200, 200, 200);
//        timeline->getFont().drawString(easingFunctions[i]->name,
//                           easingWindowPosition.x + easingFunctions[i]->bounds.x+10, 
//                           easingWindowPosition.y + easingFunctions[i]->bounds.y+15);			
		ofPushMatrix();
		ofTranslate(easingWindowPosition.x + easingFunctions[i]->bounds.x,
					easingWindowPosition.y + easingFunctions[i]->bounds.y);
		if(tweenFrame->easeType->type == ofxTween::easeIn){
			easingFunctions[i]->easeInPreview.draw();
		}
		else if(tweenFrame->easeType->type == ofxTween::easeOut){
			easingFunctions[i]->easeOutPreview.draw();
		}
		else {
			easingFunctions[i]->easeInOutPreview.draw();
		}
		
		ofPopMatrix();
        ofNoFill();
        ofSetColor(40, 40, 40);
        ofRect(easingWindowPosition.x + easingFunctions[i]->bounds.x, easingWindowPosition.y +easingFunctions[i]->bounds.y, 
               easingFunctions[i]->bounds.width, easingFunctions[i]->bounds.height);	
    }
    
}
void
ServiceEntity::draw(void)
{
    ODL_OBJENTER(); //####
    ServiceViewerApp & owner = _panel.getOwner();
    
    _panel.draw();
    if (_drawConnectMarker)
    {
        ofPoint markerPos(_panel.getWidth() / 2, _panel.getHeader());
        
        ofSetColor(ServiceViewerApp::getMarkerColor());
        ofFill();
        ofCircle(markerPos + getShape().getTopLeft(), kMarkerSide / 2);
    }
    else if (_drawDisconnectMarker)
    {
        ofPoint markerPos(_panel.getWidth() / 2, _panel.getHeader());
        
        ofSetColor(ServiceViewerApp::getMarkerColor());
        ofNoFill();
        ofSetLineWidth(2);
        ofCircle(markerPos + getShape().getTopLeft(), kMarkerSide / 2);
    }
    else if (_drawMoveMarker)
    {
        ofPoint markerPos(_panel.getWidth() / 2, _panel.getHeader());
        
        ofSetColor(ServiceViewerApp::getMarkerColor());
        ofFill();
        markerPos += getShape().getTopLeft() - ofPoint(kMarkerSide / 2, kMarkerSide / 2);
        ofRect(markerPos, kMarkerSide, kMarkerSide);
    }
    for (int ii = 0, mm = _panel.getNumPorts(); mm > ii; ++ii)
    {
        PortEntry * anEntry = _panel.getPort(ii);
        
        if (anEntry)
        {
            ofPoint                        aCentre(anEntry->getCentre());
            const PortEntry::Connections & connex = anEntry->getOutputConnections();
            
            for (PortEntry::Connections::const_iterator walker(connex.begin());
                 connex.end() != walker; ++walker)
            {
                PortEntry::AnchorSide       anchorHere;
                PortEntry::AnchorSide       anchorThere;
                MplusM::Common::ChannelMode mode = walker->_connectionMode;
                PortEntry *                 otherEntry = walker->_otherPort;
                ofPoint                     otherCentre(otherEntry->getCentre());
                ofPoint                     fromHere;
                ofPoint                     toThere;
                
                // Check if the destination is above the source, in which case we
                // determine the anchors in the reverse order.
                if (aCentre.y < otherCentre.y)
                {
                    anchorHere = anEntry->calculateClosestAnchor(fromHere, true, false,
                                                                 otherCentre);
                    anchorThere = otherEntry->calculateClosestAnchor(toThere, false,
                                                     PortEntry::kAnchorBottomCentre == anchorHere,
                                                                     aCentre);
                }
                else
                {
                    anchorThere = otherEntry->calculateClosestAnchor(toThere, false, false,
                                                                     aCentre);
                    anchorHere = anEntry->calculateClosestAnchor(fromHere, true,
                                                     PortEntry::kAnchorBottomCentre == anchorThere,
                                                                 otherCentre);
                }
                if (otherEntry->isService())
                {
                    ofSetLineWidth(owner.getServiceConnectionWidth());
                }
                else if (otherEntry->isInputOutput())
                {
                    ofSetLineWidth(owner.getInputOutputConnectionWidth());
                }
                else
                {
                    ofSetLineWidth(owner.getNormalConnectionWidth());
                }
                switch (mode)
                {
                    case MplusM::Common::kChannelModeTCP :
                        ofSetColor(ServiceViewerApp::getTcpConnectionColor());
                        break;
                        
                    case MplusM::Common::kChannelModeUDP :
                        ofSetColor(ServiceViewerApp::getUdpConnectionColor());
                        break;
                        
                    default :
                        ofSetColor(ServiceViewerApp::getOtherConnectionColor());
                        break;
                        
                }
                DrawBezier(fromHere, toThere, aCentre, otherCentre);
                ofSetLineWidth(1);
                PortEntry::drawSourceAnchor(anchorHere, fromHere);
                PortEntry::drawTargetAnchor(anchorThere, toThere);
            }
        }
    }
    ODL_OBJEXIT(); //####
} // ServiceEntity::draw
示例#16
0
//--------------------------------------------------------------
void ofApp::draw(){
    ofBackground(0, 0, 0);
    ofSetColor(255, 255, 255);
    
//    ofFill();
//    
//    ofCircle(300, 250, 100);
//    ofRect(200, 450, 200, 200);
//    ofTriangle(100, 100, 100, 200, 150, 150);
//    ofEllipse(500, 500, 100, 200);
//    ofLine(0, 0, 300, 400);
//    
//    
//    ofNoFill();
//    ofSetLineWidth(5.0);
//    ofBeginShape();
//    ofVertex(30, 30);
//    ofVertex(40, 35);
//    ofVertex(50, 100);
//    ofVertex(60, 45);
//    ofVertex(70, 50);
//    ofVertex(80, 55);
//    ofVertex(90, 60);
//    ofVertex(190, 95);
//    ofEndShape();
//
    // make grid
    
    
    easycam.begin();
    
    int gridXNum = 8;
    int gridYNum = 6;
    
    int gridX = ofGetWidth() / gridXNum;
    int gridY = ofGetHeight() / gridYNum;
    
    ofSetColor(100, 100, 100);
    for (int i = 0; i < gridXNum; i++) {
        ofLine(i * gridX, 0, i * gridX, ofGetHeight());
    }
    for (int i = 0; i < gridYNum; i++) {
        ofLine(0, i * gridY, ofGetWidth(), i * gridY);
    }
    ofSetColor(255, 0, 0);
    // draw
//    ofEllipse(gridX * 1, gridY * 3, gridX * 1.5, gridY * 5);
    ofCircle(x, y, gridX * 0.6);
//    ofRect(gridX * 4, gridY * 2, gridX * 2, gridY * 2);
//    ofColor color = ofColor(255, 0, 0);
//    ofSetColor(color);
//    ofTriangle(gridX * 2.3, gridY * 4.3, gridX * 2.3, gridY * 5.6, gridX * 3.6, gridY * 5.6);
    
    ofPushMatrix();
    
    ofTranslate(ofGetWidth() / 2, ofGetHeight() / 2);
    ofRotate(45);
    ofRect(-100, -100, 200, 200);
    
    ofPopMatrix();
    ofRect(200, 200, 200, 200);
    
    easycam.end();
}
示例#17
0
//--------------------------------------------------------------
void ofApp::draw(){
	
	ofSetColor(225);
	verdana14.drawString("Font Example - use keyboard to type", 30, 35);

	ofSetColor(245, 58, 135);
	verdana14.drawString("anti aliased", 155, 92);
	verdana14.drawString("anti aliased", 155, 195);
	verdana14A.drawString("aliased", 545, 92);
	
	ofSetColor(225);
	verdana14.drawString("verdana 14pt - ", 30, 92);
	verdana14.drawString(typeStr, 30, 111);

	verdana14A.drawString("verdana 14pt - ", 422, 92);
	ofRect(420, 97, 292, 62);
	ofSetColor(54, 54, 54);	
	verdana14A.drawString(typeStr, 422, 111);
	

	ofSetColor(29,29,29);
	ofLine(30, 169, ofGetWidth()-4, 169);

	ofSetColor(225);
	verdana14.drawString("verdana 30pt - ", 30, 195);
	verdana30.drawString(typeStr, 30, 229);

	ofSetColor(29,29,29);
	ofLine(30, 312, ofGetWidth()-4, 312);

	ofSetColor(245, 58, 135);
	franklinBook14.drawString("anti aliased", 169, 338);
	franklinBook14A.drawString("aliased", 560, 338);
	
	ofSetColor(225);
	franklinBook14.drawString("franklin book 14pt - ", 30, 338);
	franklinBook14.drawString(typeStr, 30, 358);

	franklinBook14A.drawString("franklin book 14pt - ", 422, 338);
	ofRect(420, 345, 292, 62);
	ofSetColor(54, 54, 54);	
	franklinBook14A.drawString(typeStr, 422, 358);

	ofSetColor(29,29,29);
	ofLine(30, 418, ofGetWidth()-4, 418);

	ofSetColor(225);	
	verdana14.drawString("ROTATION", 30, 445);
	verdana14.drawString("SCALE", 422, 445);
	
	ofPushMatrix();
		string rotZ = "Rotate Z";
		ofRectangle bounds = verdana30.getStringBoundingBox(rotZ, 0, 0);
		
		ofTranslate(110 + bounds.width/2, 500 + bounds.height / 2, 0);
		ofRotateZ(ofGetElapsedTimef() * -30.0);
				
		verdana30.drawString(rotZ, -bounds.width/2, bounds.height/2 );
	ofPopMatrix();

	ofPushMatrix();
		string scaleAA = "SCALE AA";
		bounds = verdana14.getStringBoundingBox(scaleAA, 0, 0);
		
		ofTranslate(500 + bounds.width/2, 480 + bounds.height / 2, 0);
		ofScale(2.0 + sin(ofGetElapsedTimef()), 2.0 + sin(ofGetElapsedTimef()), 1.0);
				
		verdana14.drawString(scaleAA, -bounds.width/2, bounds.height/2 );
	ofPopMatrix();	

	ofPushMatrix();
		string scaleA = "SCALE ALIASED";
		bounds = verdana14A.getStringBoundingBox(scaleA, 0, 0);
		
		ofTranslate(500 + bounds.width/2, 530 + bounds.height / 2, 0);
		ofScale(2.0 + cos(ofGetElapsedTimef()), 2.0 + cos(ofGetElapsedTimef()), 1.0);
				
		verdana14A.drawString(scaleA, -bounds.width/2, bounds.height/2 );
	ofPopMatrix();	
	
}
void ofxTimeMeasurements::draw(float x, float y) {

	if (!enabled) return;
	
	drawLines.clear();
	float percentTotal = 0.0f;
	float timePerFrame = 1000.0f / desiredFrameRate;

	mutex.lock();

	vector<TimeMeasurement*> toResetUpdatedLastFrameFlag;

	//update time stuff, build draw lists
	for( unordered_map<string,TimeMeasurement*>::iterator ii = times.begin(); ii != times.end(); ++ii ){
		TimeMeasurement* t = ii->second;
		string key = ii->first;
		if(!t->measuring){
			if (t->life > 0.01){
				t->life *= idleTimeColorDecay; //decrease life
			}else{ //life decays very slow when very low
				t->life *= deadThreadExtendedLifeDecSpeed; //decrease life very slowly
			}
		}
		if (!t->updatedLastFrame && timeAveragePercent < 1.0f){ // if we didnt update that time, make it tend to zero slowly
			t->avgDuration = (1.0f - timeAveragePercent) * t->avgDuration;
		}
		toResetUpdatedLastFrameFlag.push_back(t);
	}

	unordered_map<Poco::Thread*, ThreadInfo>::iterator ii;
	vector<Poco::Thread*> expiredThreads;

	//lets make sure the Main Thread is always on top
	vector< pair<Poco::Thread*, ThreadInfo> > sortedThreadList;

	for( ii = threadInfo.begin(); ii != threadInfo.end(); ++ii ){ //walk all thread trees
		if (ii->first == NULL){ //main thread is NULL!
			sortedThreadList.insert(sortedThreadList.begin(), *ii);
		}else{
			sortedThreadList.push_back(*ii);
		}
	}
	std::sort(sortedThreadList.begin(), sortedThreadList.end(), compareThreadPairs);

	#if defined(USE_OFX_HISTORYPLOT)
	vector<ofxHistoryPlot*> plotsToDraw;
	#endif

	for( int k = 0; k < sortedThreadList.size(); k++ ){ //walk all thread trees

		Poco::Thread* thread = sortedThreadList[k].first;
		core::tree<string> &tr = sortedThreadList[k].second.tree;

		PrintedLine header;
		header.formattedKey = "+" + *tr;
		header.color = threadInfo[thread].color;
		header.key = *tr; //key for selection, is thread name
		drawLines.push_back(header); //add header to drawLines

		int numAlive = 0;
		int numAdded = 0;

		core::tree<string>::iterator wholeTreeWalker = tr.in();
		bool finishedWalking = false;

		while( !finishedWalking ){

			string key = *wholeTreeWalker;
			TimeMeasurement * t = times[*wholeTreeWalker];

			#if defined(USE_OFX_HISTORYPLOT)
			bool plotActive = false;
			if(plots[key]){
				if(t->settings.plotting){
					if(t->updatedLastFrame){
						if (t->accumulating){
							plots[key]->update(t->microsecondsAccum / 1000.0f);
						}else{
							plots[key]->update(t->avgDuration / 1000.0f);
						}
					}
					plotsToDraw.push_back(plots[key]);
					plotActive = true;
				}
			}
			#endif

			bool visible = t->settings.visible;
			bool alive = t->life > 0.0001;
			if(alive){
				numAlive++;
			}

			if (visible){
				PrintedLine l;
				l.key = key;
				l.tm = t;

				int depth = wholeTreeWalker.level();
				for(int i = 0; i < depth; ++i) l.formattedKey += " ";

				if (wholeTreeWalker.size() == 0){
					l.formattedKey += "-";
				}else{
					l.formattedKey += "+";
				}
				l.formattedKey += key;
				#if defined(USE_OFX_HISTORYPLOT)
				if(plotActive) l.formattedKey += " [p]";
				#endif

				l.time = getTimeStringForTM(t);

				l.color = threadInfo[thread].color * ((1.0 - idleTimeColorFadePercent) + idleTimeColorFadePercent * t->life);
				if (!t->settings.enabled){
					l.color = disabledTextColor;
				}
				if (t->key == selection && menuActive){
					if(ofGetFrameNum()%5 < 4){
						l.color.invert();
					}
				}
				drawLines.push_back(l);
				numAdded++;
			}

			//only update() and draw() count to the final %
			if(key == TIME_MEASUREMENTS_DRAW_KEY || key == TIME_MEASUREMENTS_UPDATE_KEY){
				percentTotal += (t->avgDuration * 0.1f) / timePerFrame;
			}
			t->accumulating = false;
			t->microsecondsAccum = 0;

			//control the iterator to walk the tree "recursivelly" without doing so.
			if(wholeTreeWalker.size()){
				wholeTreeWalker = wholeTreeWalker.in();
			}else{
				if ( wholeTreeWalker.next() == wholeTreeWalker.end() ){
					wholeTreeWalker = wholeTreeWalker.out();
					while( wholeTreeWalker.next() == wholeTreeWalker.end() && wholeTreeWalker != tr){
						wholeTreeWalker = wholeTreeWalker.out();
					}
					if(wholeTreeWalker == tr){
						finishedWalking = true;
					}else{
						wholeTreeWalker++;
					}
				}else{
					++wholeTreeWalker;
				}
			}
		}

		if (numAlive == 0 && removeExpiredThreads){
			//drop that whole section if all entries in it are not alive
			for(int i = 0; i < numAdded + 1; i++){
				if(drawLines.size() > 0){
					int delID = drawLines.size() - 1;
					//clear selection if needed
					if (selection == drawLines[delID].key){
						selection = TIME_MEASUREMENTS_UPDATE_KEY;
					}
					drawLines.erase(drawLines.begin() + delID);
				}
			}
			expiredThreads.push_back(thread);
		}
	}

	//delete expired threads
	for(int i = 0; i < expiredThreads.size(); i++){
		unordered_map<Poco::Thread*, ThreadInfo>::iterator treeIt = threadInfo.find(expiredThreads[i]);
		if (treeIt != threadInfo.end()) threadInfo.erase(treeIt);
	}

	mutex.unlock();

	updateLongestLabel();

	//update max width, find headers
	int tempMaxW = -1;
	vector<int> headerLocations;
	for( int i = 0; i < drawLines.size(); i++ ){
		if (drawLines[i].tm){ //its a measurement
			//add padding to draw in columns
			for(int j = drawLines[i].formattedKey.length(); j < longestLabel; j++){
				drawLines[i].formattedKey += " ";
			}
			if (!drawLines[i].tm->error){
				drawLines[i].fullLine = drawLines[i].formattedKey + " " + drawLines[i].time;
			}else{
				drawLines[i].fullLine = drawLines[i].formattedKey + "    Error!" ;
			}
			int len = drawLines[i].fullLine.length();
			if(len > tempMaxW) tempMaxW = len;
		}else{ //its a header
			drawLines[i].fullLine = drawLines[i].formattedKey;
			headerLocations.push_back(i);
		}
	}
	maxW = tempMaxW;

	ofSetupScreen(); //mmmm----
	ofPushStyle();
	ofPushMatrix();
	ofScale(uiScale,uiScale);
	ofSetDrawBitmapMode(OF_BITMAPMODE_SIMPLE);

	ofFill();
	ofEnableAlphaBlending();

	#if defined(USE_OFX_HISTORYPLOT)
	//int numCols = plotsToDraw.size()
	for(int i = 0; i < plotsToDraw.size(); i++){
		int y = ofGetHeight() / uiScale - plotHeight * (i + 1);
		plotsToDraw[i]->draw(0, y, ofGetWidth() / uiScale, plotHeight);
		ofSetColor(99);
		if(i != plotsToDraw.size() -1){
			ofLine(0, y, ofGetWidth() / uiScale, y );
		}
	}
	#endif

	float totalW = getWidth();
	float totalH = getHeight();

	ofSetColor(bgColor, 245);
	int barH = 1;
	ofRect(x, y + 1, totalW, totalH);

	//thread header bg highlight
	for(int i = 0; i < headerLocations.size(); i++){
		int loc = headerLocations[i];
		//whole section
		ofSetColor(drawLines[loc].color, 40);
		int h = charH * ((i < headerLocations.size() - 1) ? headerLocations[i+1] - headerLocations[i] : drawLines.size() - loc );
		ofRect(x, y + 2 + loc * charH, totalW, h);
		//thread header
		ofSetColor(drawLines[loc].color, 40);
		ofRect(x, y + 2 + loc * charH, totalW, charH + 1);
	}

	ofSetColor(hilightColor);
	ofRect(x, y + 1, totalW, barH);
	ofRect(x, y + totalH - charH - 4 , totalW, barH);
	ofRect(x, y + totalH, totalW - barH, barH);

	for(int i = 0; i < drawLines.size(); i++){
		ofSetColor(drawLines[i].color);
		drawString(drawLines[i].fullLine, x , y + (i + 1) * charH);
	}

	//print bottom line, fps and stuff
	bool missingFrames = ( ofGetFrameRate() < desiredFrameRate - 1.0 ); // tolerance of 1 fps TODO!
	static char msg[128];

	sprintf(msg, "%2.1f fps % 5.1f%%", ofGetFrameRate(), percentTotal );
	if(missingFrames){
		ofSetColor(170,33,33);
	}else{
		ofSetColor(hilightColor);
	}
	int len = strlen(msg);
	string pad = " ";
	int diff = (maxW - len) - 1;
	for(int i = 0; i < diff; i++) pad += " ";
	int lastLine = ( drawLines.size() + 1 ) * charH + 2;
	drawString( pad + msg, x, y + lastLine );
	ofSetColor(hilightColor);
	drawString( " '" + ofToString(char(activateKey)) + "'" + string(timeAveragePercent < 1.0 ? " avgd!" : ""),
					   x, y + lastLine );

	for(int i = 0; i < toResetUpdatedLastFrameFlag.size(); i++){
		toResetUpdatedLastFrameFlag[i]->updatedLastFrame = false;
	}
	ofPopMatrix();
	ofPopStyle();
}
示例#19
0
//------------------------------------------------------------------
void rectangle::draw() {
	ofFill();
	ofSetRectMode(OF_RECTMODE_CENTER); // center around the position
    ofSetColor(198,246,55);
    ofRect(pos.x, pos.y, 20,20);
}
示例#20
0
void ofxMPD24::drawInterface(int x, int y){
    
    int numCols = 4;
    int numRows = 4;
    int padWidth = 50;
    int padHeight = 50;
    
    ofPushStyle();


        //Draw Pads Area 1-----------------------
        ofPushMatrix();
        ofTranslate(x,y);
        int countpos = 1;
        for(int k = 4; k>0;k--){ //start in bottom left
            for(int j = 0; j<4;j++){
                ofPushMatrix();
                ofTranslate((j*55)+50, (k*55));
                
                ofSetRectMode(OF_RECTMODE_CORNER);
                ofSetColor(0, 0, 0);
                ofNoFill();
                ofRect(0,0,padWidth, padHeight);
                
                
                float xScale, yScale, pressureScale;
                pressureScale = ofMap(afterTouchVals[(countpos)], 0, 127, 0, padWidth);
                
                ofSetRectMode(OF_RECTMODE_CENTER);
                ofSetColor(100, 100, 255);
                ofFill();
                ofRect(padWidth/2,(padWidth/2),pressureScale, pressureScale);
                
                //name of pad
                ofSetColor(0);
                ofDrawBitmapString(ofToString(countpos), 20,20);
                ofPopMatrix();
                
                countpos++;
            }
        }
      ofPopMatrix();
    
    // Draw pads area 2
    ofPushMatrix();
    ofTranslate(x+55*4+50+5, y);
        int countpos2 = 17;
        for(int k = 4; k>0;k--){ //start in bottom left
            for(int j = 0; j<4;j++){
                ofPushMatrix();
                ofTranslate((j*55)+50, (k*55));
                
                ofSetRectMode(OF_RECTMODE_CORNER);
                ofSetColor(0, 0, 0);
                ofNoFill();
                ofRect(0,0,padWidth, padHeight);
                

                float xScale, yScale, pressureScale;
                pressureScale = ofMap(afterTouchVals[(countpos2)], 0, 127, 0, padWidth);
                
                ofSetRectMode(OF_RECTMODE_CENTER);
                ofSetColor(100, 100, 255);
                ofFill();
                ofRect(padWidth/2,(padWidth/2),pressureScale, pressureScale);
                
                ofSetRectMode(OF_RECTMODE_CORNER);
                //name of pad
                ofSetColor(0);
                ofDrawBitmapString(ofToString(countpos2), 20,20);
                ofPopMatrix();
                
                countpos2++;
            }
        }
    ofPopMatrix();

        //Draw Sliders Buttons----------------------
        ofPushMatrix();
            ofTranslate(x+50, y);
            ofDrawBitmapString("Sliders", 0,40);
            for (int i=0; i<6; i++){
                ofPushMatrix();
                ofTranslate(i*20,0);
                    ofSetRectMode(OF_RECTMODE_CENTER);
                
                    int locScale = ofMap(controlVals[mpdSliderLocNum[i]], 127, 0, 0, padHeight);
                    
                    ofNoFill();
                    ofSetColor(0, 0, 0);
                    ofRect(0,0,10, padHeight);
                ofFill();
                    ofSetColor(0, 0, 0);
                    ofRect(0, locScale-padHeight/2, 10, 3);
                ofPopMatrix();
            }
        ofPopMatrix();
    
        //Draw Knobs----------------------
        ofPushMatrix();
            ofTranslate(x+50, y+320);
            ofDrawBitmapString("Knob", 0,40);
            for (int i=0; i<8; i++){
                ofPushMatrix();
                ofTranslate(i*20,0);
                ofSetRectMode(OF_RECTMODE_CENTER);
                
                int locScale = ofMap(controlVals[knobNum[i]], 127, 0, 0, padHeight);
                
                ofNoFill();
                ofSetColor(0, 0, 0);
                ofRect(0,0,10, padHeight);
                
                ofFill();
                ofSetColor(0, 0, 0);
                ofRect(0, locScale-padHeight/2, 10, 3);
                ofPopMatrix();
            }
        ofPopMatrix();
    
        //Draw Buttons----------------------
    //These dont update because they just send 127 continuously and never get a 0 message like a velocity change
        ofPushMatrix();
        ofTranslate(x+240, y+320);
        ofDrawBitmapString("Buttons", 0,40);
        for (int i=0; i<5; i++){
            ofPushMatrix();
            ofTranslate(i*20,0);
            ofSetRectMode(OF_RECTMODE_CENTER);
            
            int locScale = ofMap(controlVals[buttonNum[i]], 127, 0, 0, padHeight);
            
            ofNoFill();
            ofSetColor(0, 0, 0);
            ofRect(0,0,10, padHeight);
            
            ofFill();
            ofSetColor(0, 0, 0);
            ofRect(0, locScale-padHeight/2, 10, 3);
            ofPopMatrix();
        }
    
    for (int i=0; i<oscPaths.size(); i++){
        ofDrawBitmapString(oscPaths[i], 20, 100+i*20);
    }
        ofPopMatrix();
        
  
    
    ofPopStyle();
}
示例#21
0
void gpuPictoString::update(){

    float w = testApp::getInstance()->getW();
    float h = testApp::getInstance()->getH();
    
    if(bNeedUpdateCharPos){
        charPosList = calcCharPos();
        bNeedUpdateCharPos = false;
    }
    
    int total = gpuPicto::totalPicto;
    int totalPix = textureRes*textureRes;
    
    // manual mipmap
    //                              *** should check icon size
    
    resizeIcon(h);
    int iconSize = prm.iconSize * h;
    iconSize*=0.5;
    if(iconSize<1){ iconSize=1; }
    

    
    //
    //  nomad
    //
    bool bNomad = true;
    if(bNomad){
        if(total>0 && ofRandom(1.0)>0.95){
            
            if(gpchars.size()>2){
                int charIndexA = (int)ofRandom(2, gpchars.size()-2);
                int charIndexB = charIndexA + (int)ofRandom(-2, 2);
            
                if(charIndexA!=charIndexB){
                    int numPictoA = gpchars[charIndexA]->numPicto;
                    int numPictoB = gpchars[charIndexB]->numPicto;
                    int firstIdA = gpchars[charIndexA]->firstIndex;
                    int firstIdB = gpchars[charIndexB]->firstIndex;
                    
                    int indexA = ofRandom(firstIdA, numPictoA-1);
                    int indexB = ofRandom(firstIdB, numPictoB-1);
                    
                    float attractOnA = springPrmData[indexA*4+3];
                    float attractOnB = springPrmData[indexB*4+3];
                    
                    if(attractOnA<0 && attractOnB<0){
                        float Ax = finalTargetPosData[indexA*3 + 0];
                        float Ay = finalTargetPosData[indexA*3 + 1];
                        
                        finalTargetPosData[indexA*3 + 0] = finalTargetPosData[indexB*3 + 0];
                        finalTargetPosData[indexA*3 + 1] = finalTargetPosData[indexB*3 + 1];

                        finalTargetPosData[indexB*3 + 0] = Ax;
                        finalTargetPosData[indexB*3 + 1] = Ay;

                        finalTargetTex.loadData(finalTargetPosData, textureRes, textureRes, GL_RGB);
                    }
                }
            }
        }
    }
    
    
    {
//        offset = attractor::getPos();
        
        const ofVec2f& attr = attractor::getPos();
        float K = 20;
        float maxSpeed = 0.05;

        ofVec2f dir = attr - offset;
        ofVec2f acc =  K * 0.000167 * dir;
        offsetVel += acc;
        
        offsetVel.limit(maxSpeed);
        offset += offsetVel;
        
        ofVec2f dirf = attr - offset;
        if(dirf.length() > 0.1){
            offset += dirf - dirf.normalized() * 0.1;
        }
    }
    
    //
    //  check pictoChar
    //
    bool shouldUpdateSpringTexture = false;
    GPICTO_STR_ITR itr = gpchars.begin();
    int particleMax = textureRes*textureRes;
    for(; itr!=gpchars.end(); itr++){
        
        if((*itr)->update()){
            shouldUpdateSpringTexture = true;
            int index = (*itr)->firstIndex;
            int numPicto = (*itr)->numPicto;

            if(index<=particleMax){

                for(int i=0; i<numPicto; i++){
                    springPrmData[index*4 + 3] = -1;    // attractOn
                    
                    index++;
                    if(index>particleMax){
                        index = 0;
                    }
                }
            }
        }
    }
    
    if(clearCheck()){
        clearAll();
        bNeedUpdateCharPos = true;
    }

    if(testApp::gprm.bAutoPlay)
        shouldStartNextCheck();

    if(shouldUpdateSpringTexture){
        springPrmTex.loadData(springPrmData, textureRes, textureRes, GL_RGBA);
    }
    
    
    //
    // make random tex
    //
//    if(ofGetFrameNum()%3 == 0){
        for(int index=0; index<total; index++){
                randomData[index*3 + 0] = ofRandom(1.0);
                randomData[index*3 + 1] = ofRandom(1.0);
                randomData[index*3 + 2] = ofRandom(1.0);
//                randomData[index*4 + 3] = ofRandom(1.0);
        }
        randomTex.loadData(randomData, textureRes, textureRes, GL_RGB);
//    }


    //
    // 1. calc vel
    //
    velPingPong.dst->begin();{
        ofClear(0);
        updateVel.begin();{
            updateVel.setUniformTexture("backbuffer", velPingPong.src->getTextureReference(), 0);
            updateVel.setUniformTexture("posData", posPingPong.src->getTextureReference(), 1);
            updateVel.setUniformTexture("springData", springPrmTex, 2);
            updateVel.setUniformTexture("randomData", randomTex, 3);
            updateVel.setUniformTexture("targetData", finalTargetTex, 4);
            
            updateVel.setUniform1i("resolution", (int)textureRes);
            updateVel.setUniform2f("screen", (float)width, (float)height);
            updateVel.setUniform2f("offset", (float)offset.x, (float)offset.y);
            updateVel.setUniform2f("pastOffset", (float)pastOffset.x, (float)pastOffset.y);

            updateVel.setUniform1f("timestep", (float)timeStep);
            updateVel.setUniform1f("ACCEL",(float) prm.accel );
            updateVel.setUniform1f("SPEED",(float) prm.speed);
            updateVel.setUniform1f("VIBRATION",(float) prm.vibration );
            
            // draw the source velocity texture to be updated
            velPingPong.src->draw(0, 0);
        }updateVel.end();
    }velPingPong.dst->end();
    
    velPingPong.swap();
    
    
    //
    // 2. calc pos
    //
    posPingPong.dst->begin();{
        ofClear(0);
        updatePos.begin();{
            updatePos.setUniformTexture("prevPosData", posPingPong.src->getTextureReference(), 0); // Previus position
            updatePos.setUniformTexture("velData", velPingPong.src->getTextureReference(), 1);  // Velocity
            updatePos.setUniformTexture("springData", springPrmTex, 2);

            updatePos.setUniform1f("timestep",(float) timeStep );
//            updatePos.setUniform2f("offset", (float)offset.x, (float)offset.y);
//            updatePos.setUniform2f("pastOffset", (float)pastOffset.x, (float)pastOffset.y);
            posPingPong.src->draw(0, 0);
        }updatePos.end();
    }posPingPong.dst->end();
    
    posPingPong.swap();
    
    
    
    //
    // 3. render
    //
    renderFBO.begin();{

        ofClear(testApp::getBackgroundColor()); // ofClear(0);
        //ofClear(0, 0, 0, 0);

        updateRender.begin();{
            updateRender.setUniformTexture("posTex", posPingPong.dst->getTextureReference(), 0);
            updateRender.setUniformTexture("sparkTex", img->getTextureReference() , 1);
            updateRender.setUniformTexture("iconPrmTex", iconPrmTex, 2);
            updateRender.setUniformTexture("springData", springPrmTex, 3);

            updateRender.setUniform1i("resolution", (float)textureRes);
            updateRender.setUniform2f("screen", (float)testApp::getInstance()->getW(), (float)testApp::getInstance()->getH());
            updateRender.setUniform1i("size", (int)iconSize);
            updateRender.setUniform1f("imgWidth", imgSize);
            updateRender.setUniform1f("imgHeight", imgSize);
            // updateRender.setUniform2f("offset", (float)offset.x, (float)offset.y);

            ofPushStyle();
            //ofEnableBlendMode( OF_BLENDMODE_ADD );
            ofEnableBlendMode( OF_BLENDMODE_ALPHA);
            ofEnableAlphaBlending();
            ofEnableSmoothing();

            ofSetColor(255);
            ofFill();

            glBegin( GL_POINTS );{
                int count = 0;
                for(int y = 0; y < textureRes; y++){
                    for(int x = 0; x < textureRes; x++){
                      if(count >= total) break;
                        count++;
                        glVertex2d(x,y);
                        glTexCoord2i(x, y);
                    }
                    if(count >= total) break;
                }
            }glEnd();

            ofPopStyle();

        }updateRender.end();

        if(testApp::getDebugDraw()){
            {
                // Attractor
                const ofVec2f& attr = attractor::getPos();
                ofFill();
                ofSetColor(255, 55, 0);
                ofRect(attr.x*w, attr.y*h, 10, 10);

                ofFill();
                ofSetColor(5, 255, 0);
                ofRect(pastOffset.x*w, pastOffset.y*h, 10, 10);

                ofFill();
                ofSetColor(0, 5, 220);
                ofRect(offset.x*w, offset.y*h, 10, 10);
            }

            {
                // + line
                if(testApp::gprm.bWallMapMouseAdjust){
                    ofSetColor(0, 255, 0);
                }else{
                    ofSetColor(255, 0, 0);
                }
                glBegin(GL_LINES);
                glVertex3f(w/2, 0, 0); glVertex3f(w/2, h, 0);
                glVertex3f(0, h/2, 0); glVertex3f(w, h/2, 0);

                glVertex3f(1, 1, 0); glVertex3f(w-1, 1, 0);
                glVertex3f(1, h-1, 0); glVertex3f(w-1, h-1, 0);

                glVertex3f(1, 1, 0); glVertex3f(1, h-1, 0);
                glVertex3f(w-1, 1, 0); glVertex3f(w-1, h-1, 0);

                glVertex3f(1, 1, 0); glVertex3f(w-1, h-1, 0);
                glVertex3f(w-1, 1, 0); glVertex3f(1, h-1, 0);

                glEnd();
            }
        }

        if(testApp::gprm.bShowInfo){
            ofPushMatrix();{
                ofTranslate(0,0);
                ofSetColor(ofColor(255,255,255)-testApp::gprm.bg);
                ofFill();
                ofRect(0, 0, w, 30);
                ofSetColor(testApp::gprm.bg);
                int y = 23;
                ofDrawBitmapString("fps: " + ofToString(ofGetFrameRate()),20,y);
                ofDrawBitmapString("picto num: " + ofToString(gpuPicto::totalPicto), 200, y);

                ofDrawBitmapString("Frame num: " + ofToString(ofGetFrameNum()), 400, y);
            }ofPopMatrix();
        }
    }renderFBO.end();
    
    pastOffset = offset;

}
示例#22
0
//--------------------------------------------------------------
void testApp::draw(){

// MARK: DRAW KINECT POINT CLOUD    
//    int inc = 20;
//    for (int i = 0; i < kinect.pointCloud.size(); i+=inc) {
//        
//        float z = (kinect.pointCloud[i].z < 0.001) ? 1 : kinect.pointCloud[i].z;
//
//        float prox = (1.0 - z);
//        float sz = pow(prox, 3) * inc;
//        ofCircle(kinect.pointCloud[i].x * (float)ofGetWidth(), kinect.pointCloud[i].y * (float)ofGetHeight(), sz);
//
//        int limit_w = kinect.getOutputWidth();
//        if(i % limit_w == 0) {
//            i += inc * limit_w;
//        }
//    }
    
    
// MARK: DRAW BOX2D PARTICLES TO FBO
    fbo.begin();
    ofClear(0, 0, 0, 255);
    
    if(isFilterActive) {
        shader.begin();
        shader.setUniform1i("u_ratio", ledRatio);
    }
    
    for(int i = 0; i < b2dParticles.size(); i++) {
        CustomParticle p = b2dParticles[i];
        Data * customData = (Data*)p.getData();        
        
        
        if(kinect.pointCloud.size() > 0) {
//            int relativeX = ofMap(p.getPosition().x, 0, FBO_W, 0, kinect.getOutputWidth());            
            int relativeX = ofMap(p.getPosition().x, 0, FBO_W, 0, OUTPUT_SCREEN_W);
            relativeX = ofMap(relativeX, 0, OUTPUT_SCREEN_W, 0, kinect.getOutputWidth());
            int relativeY = ofMap(p.getPosition().y, 0, FBO_H, 0, kinect.getOutputHeight());
            
            int relativeKinectIndex = relativeX + (kinect.getOutputWidth() * relativeY);
            
            if(relativeKinectIndex < kinect.pointCloud.size()) {
                ofPoint kinectPoint = kinect.pointCloud[relativeKinectIndex];
                float z = (kinectPoint.z < 0.001) ? 1 : kinectPoint.z;
                float prox = 1.2 - z;
                
                float sz = 0;
                switch(customData->scope) {
                    case PERSONAL:
                        sz += personalMinParticleSize;
                        break;
                    case NEIGHBORHOOD:
                        sz += neighborhoodMinParticleSize;
                        break;
                    case CITY:
                        sz += cityMinParticleSize;
                        break;
                }                
                sz += prox * 80.0;

                float r = p.getRadius();
                
                // property = (target - property) / speed
                r += (sz - r) / 4.0f;
                
                p.setRadius(r);
            }
        }    

        p.draw();
    }
    
    if(isDebugingBox2d) { 
        ofEnableAlphaBlending();
        
        // DRAW JOINTS
        for(int j = 0; j < b2dJoints.size(); j++) {
            ofSetColor(255, 70);
            b2dJoints[j].draw();        
        }
        
        // DRAW ANCHORS
        ofSetColor(70);
        ofCircle(personalAnchorBottom.getPosition(), 4);
        ofCircle(personalAnchorTop.getPosition(), 4);
        ofCircle(personalAnchorLeft.getPosition(), 4);
        ofCircle(personalAnchorRight.getPosition(), 4);
        ofCircle(neighborhoodAnchorBottom.getPosition(), 4);
        ofCircle(neighborhoodAnchorTop.getPosition(), 4);
        ofCircle(neighborhoodAnchorLeft.getPosition(), 4);
        ofCircle(neighborhoodAnchorRight.getPosition(), 4);
        ofCircle(cityAnchorBottom.getPosition(), 4);
        ofCircle(cityAnchorTop.getPosition(), 4);
        ofCircle(cityAnchorLeft.getPosition(), 4);
        ofCircle(cityAnchorRight.getPosition(), 4);
    }

    if(isFilterActive) {        
        shader.end();
    }
    
    fbo.end();
    
    ofSetColor(255);
    fbo.draw(0,0);
// --------------------------------------------
    
// CHEAT: PILLARS MASK
    ofSetColor(25, 255);
    ofFill();
    ofRect(OUTPUT_SCREEN_W/3.0, 0, (FBO_W-OUTPUT_SCREEN_W)/2.0, FBO_H);
    ofRect(FBO_W - (OUTPUT_SCREEN_W/3.0) - (FBO_W-OUTPUT_SCREEN_W)/2.0, 0, (FBO_W-OUTPUT_SCREEN_W)/2.0, FBO_H);
// --------------------------------------------
    
    if(isGUIActive) {
        drawGUI();
    }
    
}
示例#23
0
void ofApp::boxE(){
    float _sizeRatio = 0.7;

    ofPushStyle();
    ofNoFill();
    ofSetColor( 120, 255 );
    ofPushMatrix();
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofTranslate( 0, -platePointSpacing*_sizeRatio, -platePointSpacing*_sizeRatio);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPushMatrix();
    ofRotateY(270);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPushMatrix();
    ofRotateY(270);
    ofTranslate( 0, 0, -platePointSpacing*_sizeRatio );
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPopStyle();

    ofPushStyle();
    ofFill();
    ofSetColor( 250, 255 );
    ofPushMatrix();
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofTranslate( 0, -platePointSpacing*_sizeRatio, -platePointSpacing*_sizeRatio);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofRotateX(90);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPushMatrix();
    ofRotateY(270);
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPushMatrix();
    ofRotateY(270);
    ofTranslate( 0, 0, -platePointSpacing*_sizeRatio );
    ofRect(0, 0, platePointSpacing*_sizeRatio, platePointSpacing*_sizeRatio);
    ofPopMatrix();
    ofPopStyle();
}
示例#24
0
//--------------------------------------------------------------
void testApp::draw(){

    if (bPrintToPdf){
        ofBackground(255);
        ofBeginSaveScreenAsPDF("screenshot-"+ofGetTimestampString()+".pdf", false);
    } else {
        ofBackground(11,94,148);
        ofBackgroundGradient(ofColor(11,94,148), ofColor(0,45,128,100));
        float margin = 10;
        ofRectangle grid = ofRectangle(margin,margin,ofGetWidth()-margin*2.0,ofGetHeight()-margin*2.0);
        
        ofPushStyle();
        
        ofSetColor(200,20);
        ofSetLineWidth(2);
        ofNoFill();
        ofRect(grid);
        ofSetLineWidth(0.3);
        drawGrid(grid, 10);
        
        ofPopStyle();
    }
    
    //  Potentialy New Gear
    //
    if( bValid && !bPrintToPdf) {
        ofSetColor(255,0,0);
        picked->update();
        picked->draw();
    }
    
    //  Draw Disk
    //
    if (bPrintToPdf){
        ofSetColor(0,100);
    } else {
        ofSetColor(255,100);
    }
    ofFill();
    ofBeginShape();
    for (int i = 0; i < disk.size(); i++) {
        ofVertex(disk[i]);
    }
    ofEndShape();
    
    if (onA)
        ofFill();
    else
        ofNoFill();
    ofCircle(A, 10);
    
    if (onB)
        ofFill();
    else
        ofNoFill();
    ofCircle(B, 10);
    
    ofNoFill();
    ofDrawBitmapString("A", A.x-3,A.y+4);
    ofDrawBitmapString("B", B.x-3,B.y+4);
    ofRect(window);
    
    //  Draw Gears
    //
    for (int i = 0; i < gears.size(); i++) {
    
        gears[i]->bPrint = bPrintToPdf;
        gears[i]->bSelected = (hoverGear == i);
        
        ofSetColor(255);
        gears[i]->update();
        gears[i]->draw();

    }
    
    if (bPrintToPdf){
        ofEndSaveScreenAsPDF();
        bPrintToPdf = false;
    }
}
//-----------------------------------------------.
void guiTypeTextDropDown::render(){

	ofPushStyle();
	guiBaseObject::renderText();

		//draw the background
		ofFill();
		glColor4fv(bgColor.getNormalColorF());
		ofRect(hitArea.x, hitArea.y, hitArea.width, hitArea.height);

		if(bShowDropDown)
		{

			for(int i = 0; i < (int) vecDropList.size(); i++)
			{
				float bx = hitArea.x;
				float by = hitArea.y + i * (boxHeight);

				if(value.getValueI() == i){
					glColor4fv(fgColor.getSelectedColorF());
				}else{
					glColor4fv(fgColor.getNormalColorF());
				}

				ofFill();

				ofRect(bx, by,  boundingBox.width, boxHeight);

				ofNoFill();
				glColor4fv(outlineColor.getColorF());
				ofRect(bx, by,  boundingBox.width, boxHeight);

				if(i==0) {
					ofFill();
					glColor4fv(outlineColor.getColorF());
					ofRect(bx + boundingBox.width - boxHeight*0.5, by, boxHeight*0.5, boxHeight*0.5);
				}

				glColor4fv(textColor.getColorF());

				displayText.renderString(vecDropList[i], bx + 2, by + boxHeight -4);

			}

		} else {
			float bx = hitArea.x;
			float by = hitArea.y;

			ofFill();
			glColor4fv(bgColor.getColorF());
			ofRect(bx, by,  boundingBox.width, boxHeight);

			ofNoFill();
			glColor4fv(outlineColor.getColorF());
			ofRect(bx, by,  boundingBox.width, boxHeight);

			ofFill();
			glColor4fv(outlineColor.getColorF());
			//ofTriangle(bx + boundingBox.width - 7, by + boxHeight, bx + boundingBox.width - 14, by,bx + boundingBox.width, by);
			ofRect(bx + boundingBox.width - boxHeight*0.5, by, boxHeight*0.5, boxHeight*0.5);

			glColor4fv(textColor.getColorF());
			//displayText.renderString(vecDropList[value.getValueI()], bx + 2, by + boxHeight -4);

		}

	ofPopStyle();
}
//--------------------------------------------------------------
void testApp::draw() {
    ofBackground(0, 0, 0);
    ofSetColor(0, 0, 0);
    ofRect(0,0,1400,1400);
    for(int i = 0; i < dropletNumber; i++) {
        droplets[i].draw();
    }

    //test.draw();
    if(! generatedObjects.empty() ) {
        for(int i = 0; i < generatedObjects.size(); i++) {
            generatedObjects[i].draw();
        }
    }


    for(int i =0; i < obstacleNumber; i++) {
        //lineNumber[i].draw();
    }


    if(showCameraStuff) {
        // draw the incoming, the grayscale, the bg and the thresholded difference
        //ofSetColor(0xffffff);
        colorImg.draw(20,20);
        grayImage.draw(360,20);
        grayBg.draw(20,280);
        grayDiff.draw(360,280);
        ofSetColor(255, 255, 255);
        ofLine(0, 432, 2000, 432);
        ofSetColor(255, 0, 0);
        ofLine(370, 0, 370, 1000);
        ofLine(570, 0, 570, 1000);

        // then draw the contours:

        ofFill();
        ofSetColor(0x333333);
        ofRect(360,540,320,240);
        ofSetColor(0xffffff);

        // we could draw the whole contour finder
        //contourFinder.draw(360,540);

        // or, instead we can draw each blob individually,
        // this is how to get access to them:
        for (int i = 0; i < contourFinder.nBlobs; i++) {
            contourFinder.blobs[i].draw(360,540);
        }

        // finally, a report:

        ofSetColor(0xffffff);
        char reportStr[1024];
        sprintf(reportStr, "bg subtraction and blob detection\npress ' ' to capture bg\nthreshold %i (press: +/-)\nnum blobs found %i", threshold, contourFinder.nBlobs);
        ofDrawBitmapString(reportStr, 20, 600);
    }


    ofSetColor(0, 0, 0);
    ofFill();
    ofRect(950, 0, 1000,1000);
    ofFill();
}
示例#27
0
void testApp::draw(){	
	ofSetColor(255, 255, 255);
	
	// draw the debug screens
	ofPushMatrix();
	ofScale(0.5, 0.5);
							
	if (isLive) {
		recordDepth.draw(0, 0, 640, 480);
		recordImage.draw(640, 0, 640, 480);
		if (panel.getValueB("isTracking")) {
			recordUser.draw();
			
			if(panel.getValueB("isMasking")) {
				glEnable(GL_BLEND);
				glBlendFunc(GL_DST_COLOR, GL_ZERO);
				recordUser.drawUserMasks(640, 0);
				glDisable(GL_BLEND);
			}
		}
	}
	else {
		playDepth.draw(0, 0, 640, 480);
		playImage.draw(640, 0, 640, 480);
		if (panel.getValueB("isTracking")) {
			
			playUser.draw();
			
			if(panel.getValueB("isMasking")) {
				glEnable(GL_BLEND);
				glBlendFunc(GL_DST_COLOR, GL_ZERO);
				playUser.drawUserMasks(640, 0);
				glDisable(GL_BLEND);
			}
		}
	}
	
	// draw rectangles to ground the debug screens
	ofNoFill();
	ofRect(0, 0, 640, 480);
	ofRect(640, 0, 640, 480);							
	ofFill();	
	
	ofPopMatrix();
	
	// draw the point cloud
	//glMatrixMode(GL_MODELVIEW);	
	
	
//	glPushMatrix();
//	glTranslatef(320, 240, 0);
//	glRotatef(panel.getValueF("cloud_rotation"), 0, 1, 0);
//	glTranslatef(-320, -240, 0);	
	
	ofPushMatrix();
	ofTranslate(ofGetWidth() / 2, ofGetHeight() / 2, -300);	
	ofRotateY(panel.getValueF("cloud_rotation"));
	ofTranslate(-320, -240, 0);

//	if (panel->getValueB("autoRotate")){
//		ofRotateY(ofGetElapsedTimef()*5);
//	}

	
	
	//glCallList(SCENE); /* draw the scene */
	
	if (isLive) {
		//recordUser.drawPointCloud(!panel.getValueB("cloudMasking"), panel.getValueI("cloud_point_size"));		
		recordUser.drawOrthogonalPointCloud(panel.getValueF("ppm"), false, panel.getValueB("show_scene_box"), panel.getValueI("cloud_point_size"));
		recordUser.drawOrthogonal(panel.getValueF("ppm"));
	}
	else {
		//playUser.drawPointCloud(!panel.getValueB("cloudMasking"), panel.getValueI("cloud_point_size"));
	}


	ofPopMatrix();		
	
	
	ofSetColor(255, 255, 0);
	
	string msg1, msg2, msg3;	//drawBitmapString is limited to some numebr of characters -> is this a bug in 007 or always the case?
	
	msg1 += "Press 's' to start/stop recording\n";
	msg1 += "Press 'p' to toggle playback/live streams\n";
	msg3 += (string)(isLive ? "LIVE STREAM\n" : "PLAY STREAM\n");
	msg3 += (string)(!isRecording ? "READY\n" : "RECORDING\n");

	
	ofDrawBitmapString(msg1, 20, 500);
	ofDrawBitmapString(msg3, 20, 600);
	ofDrawBitmapString(currentFileName, 20, 700);
	
	
}
示例#28
0
//--------------------------------------------------------------
void testApp::draw(){
	
	// set my color
	ofSetColor(255, 0, 0);
	
	// b
	ofRect(10, 10, 50, 200);
	ofRect(50, 110, 50, 100);
	
	// r
	ofRect(110, 110, 50, 100);
	ofRect(150, 110, 50, 25);
	
	// i
	ofRect(210, 110, 50, 25);
	ofRect(210, 140, 50, 70);

	// a
	ofRect(270, 110, 75, 25);
	ofRect(295, 130, 50, 80);
	ofRect(270, 160, 50, 50);
	
	// n
	ofRect(355, 110, 75, 25);
	ofRect(355, 130, 25, 80);
	ofRect(405, 130, 25, 80);

	
}
示例#29
0
void ofxGuiMatrix::draw()
{
	glPushMatrix();
	
	glTranslatef(mObjX, mObjY, 0.0f);
	
	if(mParamName != "")
		drawParamString(0.0, 0.0, mParamName + ": " + ofToString(mValue), false);
	
	ofFill();
	
	//	background
	glColor4f(mGlobals->mCoverColor.r, mGlobals->mCoverColor.g, mGlobals->mCoverColor.b, mGlobals->mCoverColor.a);
	ofRect(mCtrX, mCtrY, mCtrWidth, mCtrHeight);
	
	ofNoFill();

	//	pads
	glColor4f(mGlobals->mFrameColor.r, mGlobals->mFrameColor.g, mGlobals->mFrameColor.b, mGlobals->mFrameColor.a);
	
	int		s	= mSpacing / 2;
	float	x	= mCtrX + s;
	float	y	= mCtrY + s;
	float	w	= (mCtrWidth - mSpacing) / mXGrid;
	float	h	= (mCtrHeight - mSpacing) / mYGrid;
	
	for(int i = 0; i < mYGrid; i++)
	{
		for(int j = 0; j < mXGrid; j++)
		{
			int index = j + (i * mXGrid);
			
			if((mBuffer[index] & kofxGui_Matrix_Set) == kofxGui_Matrix_Set)
			{
				ofFill();
				glColor4f(mGlobals->mButtonColor.r, mGlobals->mButtonColor.g, mGlobals->mButtonColor.b, mGlobals->mButtonColor.a);
				ofRect(x + s, y + s, w - mSpacing, h - mSpacing);
			}
			
			if((mBuffer[index] & kofxGui_Matrix_Selected) == kofxGui_Matrix_Selected)
			{
				ofNoFill();
				glColor4f(mGlobals->mMatrixColor.r, mGlobals->mMatrixColor.g, mGlobals->mMatrixColor.b, mGlobals->mMatrixColor.a);
				ofRect(x + s, y + s, w - mSpacing, h - mSpacing);
			}
			else if(mValue == index)
			{
				ofNoFill();
				glColor4f(mGlobals->mAxisColor.r, mGlobals->mAxisColor.g, mGlobals->mAxisColor.b, mGlobals->mAxisColor.a);
				ofRect(x + s, y + s, w - mSpacing, h - mSpacing);
			}
			else
			{
				ofNoFill();
				glColor4f(mGlobals->mFrameColor.r, mGlobals->mFrameColor.g, mGlobals->mFrameColor.b, mGlobals->mFrameColor.a);
				ofRect(x + s, y + s, w - mSpacing, h - mSpacing);
			}
			
			x += w;
		}
		
		y += h;
		x  = mCtrX + s;
	}
		
	//	frame
	glColor4f(mGlobals->mFrameColor.r, mGlobals->mFrameColor.g, mGlobals->mFrameColor.b, mGlobals->mFrameColor.a);
	ofRect(mCtrX, mCtrY, mCtrWidth, mCtrHeight);
	
	glPopMatrix();
}
示例#30
0
void ofxTLSwitches::draw(){
    
    ofPushStyle();
	ofFill();
	
	//draw a little wobble if its on
	//if(isOnAtMillis(timeline->getCurrentTimeMillis())){
	//play solo change
	if(isOn()){
		ofSetColor(timeline->getColors().disabledColor, 20+(1-powf(sin(ofGetElapsedTimef()*5)*.5+.5,2))*20);
		ofRect(bounds);
	}

    for(int i = 0; i < keyframes.size(); i++){
        ofxTLSwitch* switchKey = (ofxTLSwitch*)keyframes[i];
        float startScreenX = MAX(millisToScreenX(switchKey->timeRange.min), 0);
        float endScreenX = MIN(millisToScreenX(switchKey->timeRange.max), bounds.getMaxX());
		if(startScreenX == endScreenX){
			continue;
		}
		switchKey->display = ofRectangle(startScreenX, bounds.y, endScreenX-startScreenX, bounds.height);

        //draw handles

        ofSetLineWidth(2);
        bool keyIsSelected = isKeyframeSelected(switchKey);
        if(keyIsSelected || switchKey->startSelected){
	        ofSetColor(timeline->getColors().textColor);
        }
        else{
	        ofSetColor(timeline->getColors().keyColor);    
        }

        ofLine(switchKey->display.x, bounds.y, 
               switchKey->display.x, bounds.y+bounds.height);

        if(keyIsSelected || switchKey->endSelected){
	        ofSetColor(timeline->getColors().textColor);                
        }
        else{
	        ofSetColor(timeline->getColors().keyColor);    
        }        
        ofLine(switchKey->display.x+switchKey->display.width, bounds.y, 
               switchKey->display.x+switchKey->display.width, bounds.y+bounds.height);

        //draw region
        if(keyIsSelected){
        	ofSetColor(timeline->getColors().textColor, 100);    
        }
        else{
        	ofSetColor(timeline->getColors().keyColor, 100);
        }
        //set overlay colors, this will override the colors above
        if(hoverKeyframe == switchKey){
            if(startHover){
                ofPushStyle();
                if(switchKey->startSelected){
                    ofSetColor(timeline->getColors().highlightColor);
                }
                else{
                    ofSetColor(timeline->getColors().keyColor);
                }
                ofRect(switchKey->display.x-2, bounds.y, 4, bounds.height);
                ofPopStyle();
            }
            else if(endHover){
				ofPushStyle();
                if(switchKey->endSelected){
                    ofSetColor(timeline->getColors().highlightColor);
                }
                else{
                    ofSetColor(timeline->getColors().keyColor);
                }
                ofRect(switchKey->display.x+switchKey->display.width-2, bounds.y, 4.0, bounds.height);
                ofPopStyle();
            }
            else {
                if(keyIsSelected){
	                ofSetColor(timeline->getColors().highlightColor);                    
                }else {
	                ofSetColor(timeline->getColors().keyColor);    
                }
            }
        }
        ofRect(switchKey->display);
    }
    ofPopStyle();
}