コード例 #1
0
void FboMaskManager::update(){
	if(!hasAutoloaded){
		editing = false;
		if(autoload){
			mask.load(loadPath);
			drawToFboBlending();
		}
		hasAutoloaded = true;
	}
	//if(drawToOutputs){
	//			drawToFboBlending();
	//			drawToOutputs = false;
	//		}
	
	if (_editing != editing) {
		_editing = editing;
		if (_editing) {
			addListeners();
		} else {
			removeListeners();
		}
	}
	
	if(editing){
		
		if(!blankOutput){
			blankOutput = true;
			drawToFboBlending();
		}
		
		if(hideMouseWhileEditing){
			ofHideCursor();
		} else {
			ofShowCursor();
		}
		
		if(load){
			mask.load(loadPath);
			load = false;
		}
		if(save){
			mask.save(loadPath);
			save = false;
		}
		
	} else {
		ofShowCursor();
		if(blankOutput){
			blankOutput = false;
			drawToFboBlending();
		}
		
	}
	
	
}
コード例 #2
0
void ofxMouseAutoHider::setEnabled(bool enabled) {
	if(this->enabled == enabled) {
		return;
	}
	
	this->enabled = enabled;
	ofShowCursor();
	printf("----------------------Setting enabled\n");
	cursorShowing = true;
	lastTimeMouseMoved = ofGetElapsedTimef();
	
	if(enabled) {
		ofAddListener(ofEvents().update, this, &ofxMouseAutoHider::update);
		ofAddListener(ofEvents().mouseMoved, this, &ofxMouseAutoHider::mouseEvent);
		ofAddListener(ofEvents().mousePressed, this, &ofxMouseAutoHider::mouseEvent);
		ofAddListener(ofEvents().mouseDragged, this, &ofxMouseAutoHider::mouseEvent);
		ofAddListener(ofEvents().mouseReleased, this, &ofxMouseAutoHider::mouseEvent);
	} else {
		ofRemoveListener(ofEvents().update, this, &ofxMouseAutoHider::update);
		ofRemoveListener(ofEvents().mouseMoved, this, &ofxMouseAutoHider::mouseEvent);
		ofRemoveListener(ofEvents().mousePressed, this, &ofxMouseAutoHider::mouseEvent);
		ofRemoveListener(ofEvents().mouseDragged, this, &ofxMouseAutoHider::mouseEvent);
		ofRemoveListener(ofEvents().mouseReleased, this, &ofxMouseAutoHider::mouseEvent);
	}
}
コード例 #3
0
ファイル: ofApp.cpp プロジェクト: Bentleyj/Textsplosion
//--------------------------------------------------------------
void ofApp::keyPressed(int key) {
	if (key == ' ') {
		goToNextText();
	}
	if (key == 'a') {
		if (animating) {
			cameraPosTarget = cameraPosTarget.getNormalized() * zoomOutDist;
			cameraPosOld = cameraPosOld.getNormalized() * zoomOutDist;
		}
		animating = !animating;
	}
	if (key == 'f') {
		ofToggleFullscreen();
	}
	if (key == 's') {
		fadingUp = !fadingUp;
	}
	if (key == 'g') {
		if (showGui) {
			ofHideCursor();
		}
		else {
			ofShowCursor();
		}
		showGui = !showGui;
	}
}
コード例 #4
0
ファイル: ofApp.cpp プロジェクト: bensnell/urg-videography
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
//    if(key == 'l'){
//        cameraTrack->lockCameraToTrack = !cameraTrack->lockCameraToTrack;
//    }
//    else if(key == 't'){
//        // NOTE: cannot edit keyframes, only add new ones!
//        cameraTrack->addKeyframe();
//    }
    if (key == 'f') ofToggleFullscreen();
    if (key == 'b') bDrawTimeline = !bDrawTimeline;
    if (key == 'n') bDrawPanel = !bDrawPanel;
    if (key == 'p') timeline.play();
    if (key == 'r') {
        if (bRunTimelapse) {
            bRunTimelapse = false;
        } else {
            timelapse.reset();
            bRunTimelapse = true;
            timeline.play();
        }
    }
    if (key == 'c') {
        bHideCursor ? ofShowCursor() : ofHideCursor();
        bHideCursor = !bHideCursor;
    }

}
コード例 #5
0
ファイル: testApp.cpp プロジェクト: ituita/ituita-outdoor
//--------------------------------------------------------------
// MARK: DRAW
//--------------------------------------------------------------
void testApp::draw(){

    fbo.begin();
    
    glPushAttrib(GL_ALL_ATTRIB_BITS);  
    glEnable(GL_BLEND);  
    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);  
    
    ofSetColor(0, iFboAlpha);
    ofRect(0, 0, FBO_W, FBO_H);
    
    runParticles(streetParticles, *streetPath);
    runParticles(neighborhoodParticles, *neighborhoodPath);
    runParticles(cityParticles, *cityPath);
    
    glDisable(GL_BLEND);  
    glPopAttrib(); 
        
    fbo.end();
    
    ofEnableAlphaBlending();
    fbo.draw(0, 0);
    ofDisableAlphaBlending();
    
    if(isGUIActive) {
        ofShowCursor();
        drawGUI();
    } else {
        ofHideCursor();
    }
    
}
コード例 #6
0
//--------------------------------------------------------------
void captureApp::keyPressed(int key) {
	if(key == 'f') {
		ofToggleFullscreen();
	}
	if(key == '\t') {
	
		if( !hidden &&  ofxFileHelper::doesFileExist(capturePrefix+"capture") && ofxFileHelper::doesFileExist(capturePrefix+"capture/0.jpg") ){
			string unique = ofToString(ofGetYear()) + ofToString(ofGetMonth()) + ofToString(ofGetDay()) + ofToString(ofGetHours()) + ofToString(ofGetMinutes()) + ofToString(ofGetSeconds());
			ofxFileHelper::moveFromTo(capturePrefix+"capture", capturePrefix+"savedFolder"+unique);
			ofxFileHelper::makeDirectory(capturePrefix+"capture");
			cameraFrameNum = 0;
		}
	
		hidden = !hidden;
		panel.hidden = hidden;
		if(hidden)
			ofHideCursor();
		else
			ofShowCursor();
		if(!hidden)
			imageSaver.saveAll();
	}
	if(panel.getValueB("frameByFrame") && key == OF_KEY_UP){
		patternFrame--;
	}

	if(panel.getValueB("frameByFrame") && key == OF_KEY_DOWN){
		patternFrame++;
	}
}
コード例 #7
0
void testApp::keyReleased(int key){
    if (bMouse){
        ofShowCursor();
    } else {
        ofHideCursor();
    }
}
コード例 #8
0
ファイル: sphereSystem.cpp プロジェクト: hiroMTB/spiroSynth
void sphereSystem::keyPressed(int key){

	switch(key){
		case '!':
			epi[oscTargetSlot].saveToXml("temp");
			break;

		case '#':
			ofToggleFullscreen();
			break;

		case '$':
			timeline.toggleShow();
			if(timeline.getIsShowing())
				ofShowCursor();
			else
				ofHideCursor();

			break;

		case OF_KEY_LEFT:
			break;

		case ' ':
			timeline.togglePlay();
			//bGlobalMute = false;
			break;

	}
}
コード例 #9
0
ファイル: ofApp.cpp プロジェクト: yoshiwarab/ofxFlowTools
//--------------------------------------------------------------
void ofApp::draw(){
	ofClear(0,0);
	if (doDrawCamBackground.get())
		drawSource();
		
		
	if (!toggleGuiDraw) {
		ofHideCursor();
		drawComposite();
	}
	else {
		ofShowCursor();
		switch(drawMode.get()) {
			case DRAW_COMPOSITE: drawComposite(); break;
			case DRAW_PARTICLES: drawParticles(); break;
			case DRAW_FLUID_FIELDS: drawFluidFields(); break;
			case DRAW_FLUID_DENSITY: drawFluidDensity(); break;
			case DRAW_FLUID_VELOCITY: drawFluidVelocity(); break;
			case DRAW_FLUID_PRESSURE: drawFluidPressure(); break;
			case DRAW_FLUID_TEMPERATURE: drawFluidTemperature(); break;
			case DRAW_FLUID_DIVERGENCE: drawFluidDivergence(); break;
			case DRAW_FLUID_VORTICITY: drawFluidVorticity(); break;
			case DRAW_FLUID_BUOYANCY: drawFluidBuoyance(); break;
			case DRAW_FLUID_OBSTACLE: drawFluidObstacle(); break;
			case DRAW_FLOW_MASK: drawMask(); break;
			case DRAW_OPTICAL_FLOW: drawOpticalFlow(); break;
			case DRAW_SOURCE: drawSource(); break;
			case DRAW_MOUSE: drawMouseForces(); break;
			case DRAW_VELDOTS: drawVelocityDots(); break;
		}
		drawGui();
	}
}
コード例 #10
0
//--------------------------------------------------------------
void ofApp::keyPressed(int key)
{
	if( key == 'f' )
	{
		//gotta toggle full screen for it to be right
		ofToggleFullscreen();
	}
	
	if(key == 's'){
		oculusRift.reloadShader();
	}
	
	if(key == 'l'){
		oculusRift.lockView = !oculusRift.lockView;
	}
	
	if(key == 'o'){
		showOverlay = !showOverlay;
	}
	if(key == 'r'){
		oculusRift.reset();
		
	}
	if(key == 'h'){
		ofHideCursor();
	}
	if(key == 'H'){
		ofShowCursor();
	}
	
	if(key == 'p'){
		predictive = !predictive;
		oculusRift.setUsePredictedOrientation(predictive);
	}
}
コード例 #11
0
ファイル: testApp.cpp プロジェクト: ericcorriel/ofxCocoa
void testApp::keyPressed(int key){
	switch(key) {
		case 'f':
			ofToggleFullscreen();
			break;
			
		case 'm':
		{
			static bool showCursor = true;
			showCursor ^= true;
			if(showCursor) ofShowCursor();
			else ofHideCursor();
		}
			break;
			
		case 't':
			MSA::ofxCocoa::setTransparent(!MSA::ofxCocoa::getTransparent());
			break;
			
			
		case 'd':
			doDisplayLink ^= true;
			MSA::ofxCocoa::setSyncToDisplayLink(doDisplayLink);
			break;
			
		case 'v':
			doVSync ^= true;
			ofSetVerticalSync(doVSync);	
			break;
			
			
	}
}
コード例 #12
0
//--------------------------------------------------------------
void ofApp::keyPressed(int key){

    switch (key){
        case 's':
            if (show_fps == true){
                show_fps = false;
            } else{
                show_fps = true;
            }
            break;
        case 'f':
            ofToggleFullscreen();
            break;
        case 'k':
            bKaleidoscope = !bKaleidoscope;
            break;
        case '2':
            if(bKaleidoscope == true){
                KaleidoscopeSlices+=2;
                if (KaleidoscopeSlices >= 100) KaleidoscopeSlices = 100;
            }
            break;
        case '1':
            if(bKaleidoscope == true){
                KaleidoscopeSlices-=2;
                if (KaleidoscopeSlices < 2) KaleidoscopeSlices = 2;
            }
            break;
        case OF_KEY_UP:
            nFrag++;
            if (nFrag >= frags.size()) nFrag = 0;
            cout << endl << "--------" << endl << " Loading Frag: "<< nFrag+1 << endl << "--------" << endl;
            setCode(frags[nFrag]);
            break;
        case OF_KEY_DOWN:
            nFrag--;
            if (nFrag < 0) nFrag = frags.size()-1;
            cout << endl << "--------" << endl << " Loading Frag: "<< nFrag+1 << endl << "--------" << endl;
            setCode(frags[nFrag]);
            break;
        case 'r':
            resolPantalla++;
            if (resolPantalla == 3) resolPantalla = 4;
            if (resolPantalla > 4) resolPantalla = 1;
            cout << resolPantalla << endl;
            pingPong.allocate( resolHoriz/resolPantalla, resolVert/resolPantalla, GL_RGB);
            pingPong.swap();
            break;
        case 'h':
            if (bHideCursor == true){
                bHideCursor = false;
                ofShowCursor();
            } else{
                bHideCursor = true;
                ofHideCursor();
            }
            break;
    }
}
コード例 #13
0
ファイル: ofApp.cpp プロジェクト: veev/jrh
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
    vs.mouseMoved(x, y-displaySystemYOffset);
    
    if(x < ds.width && y < ds.height)
        ofHideCursor();
    else
        ofShowCursor();
}
コード例 #14
0
ファイル: ofApp.cpp プロジェクト: xavibove/Cancons-Visuals
///--------------------------------------------------------------
void ofApp::update()
{
#ifdef OF_DEBUG
    ofShowCursor();

    currentScene = sceneManager.getCurrentSceneIndex();
#endif
}
コード例 #15
0
ファイル: Global.cpp プロジェクト: cristianofigo/musica_movel
//--------------------------------------------------------------
void Global::resetGraphics() {
	ofSetupGraphicDefaults();
	ofSetBackgroundAuto(true);
	ofSetVerticalSync(true);
	ofBackground(100, 100, 100);
	ofSetFrameRate(60);
	ofShowCursor();
}
コード例 #16
0
ファイル: testApp.cpp プロジェクト: HellicarAndLewis/Triptych
//--------------------------------------------------------------
void testApp::keyPressed(int key){
	 if(key==' ') {
		gui.toggleDraw();
	}
	
	if(key == 'd') {
		debug = !debug;
	}
	else if(key == 'g') {
		show_gui = !show_gui;
	}
	
	else if(key == 'w') {
		#ifdef USE_FLOCK_GUI
		flock_gui.save(ofToDataPath("gui.bin", true));
		#endif
		#ifdef USE_LIGHT_RAYS
		rays_gui.save(ofToDataPath("rays.bin",true));
		#endif
		ia_gui.save(ofToDataPath("ia.bin",true));
		bloom_gui.save(ofToDataPath("bloom.bin",true));
	}
	else if(key == 's') {
		must_take_screenshot = true;
	}
	else if(key == 'l') {
		#ifdef USE_FLOCK_GUI
		flock_gui.load(ofToDataPath("gui.bin",true));
		#endif
		#ifdef USE_LIGHT_RAYS
		rays_gui.load(ofToDataPath("rays.bin",true));
		#endif
		ia_gui.load(ofToDataPath("ia.bin",true));
		bloom_gui.load(ofToDataPath("bloom.bin",true));
	}

	else if(key == 'f') {
		ofToggleFullscreen();
	}
	else if(key == 'r') {
		settings.rotate_scene = !settings.rotate_scene;
	}
	else if(key == 't') {
		printf("Width: %d Height: %d\n", ofGetWidth(), ofGetHeight());
	}
	else if(key == 'm') {
		show_mouse = !show_mouse;
		if(!show_mouse) {
			ofHideCursor();
		}
		else {
			ofShowCursor();
		}
	}
	else if(key == 'i') {
		show_fps = !show_fps;
	}
}
コード例 #17
0
ファイル: ofApp.cpp プロジェクト: veev/jrh
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
    switch(key){
        case ' ':
            gui.isHidden = !gui.isHidden;
            if(gui.isHidden)
                ds.enterLiveMode();
            else
                ds.enterTestMode();
            break;
        case 'm':
            ofShowCursor();
            break;
        case 'f':
            isFullScreen = ! isFullScreen;
            ofSetFullscreen(isFullScreen);
            break;
        case 'l':
            gui.ledsOn = !gui.ledsOn;
            break;
        case 's':
            gui.strips = !gui.strips;
            break;
        case OF_KEY_UP:
            vs.angleKinectUp();
            break;
        case OF_KEY_DOWN:
            vs.angleKinectDown();
            break;
        case '0':
            vs.showQuote(0);
            break;
        case '1':
            vs.showQuote(1);
            break;
        case '2':
            vs.showQuote(2);
            break;
        case '3':
            vs.showQuote(3);
            break;
        case '4':
            vs.showQuote(4);
            break;
        case '5':
            vs.showQuote(5);
            break;
        case '6':
            vs.showQuote(6);
            break;
        case '7':
            vs.showQuote(7);
            break;
        case '8':
            vs.showQuote(8);
            break;
    }
    
}
コード例 #18
0
ファイル: testApp.cpp プロジェクト: hanasaan/ofxOculusDK2
//--------------------------------------------------------------
void testApp::keyPressed(int key)
{
    // dismiss safety warning on any key
    oculusRift.dismissSafetyWarning();
    
	if( key == 'f' )
	{
		//gotta toggle full screen for it to be right
		ofToggleFullscreen();
	}
    
	
    if(key == 'a'){
        cout << "FPS " << ofGetFrameRate() << " TARGET " << ofGetTargetFrameRate() << endl;
    }
    
    
	if(key == 's'){
		oculusRift.reloadShader();
	}
    if(key == 'v'){
        oculusRift.setVignette( !oculusRift.getVignette() );
    }
	
	if(key == 'l'){
		oculusRift.lockView = !oculusRift.lockView;
	}
	
	if(key == 'o'){
		showOverlay = !showOverlay;
	}
	if(key == 'r'){
		oculusRift.reset();
	}
    if(key == 'c'){
        oculusRift.recenterPose();
    }
    if(key == 'z'){
		setupBoxes();
	}
	if(key == 'h'){
		ofHideCursor();
	}
	if(key == 'H'){
		ofShowCursor();
	}
	
    if(key == 'd'){
        oculusRift.setPixelDensity( oculusRift.getPixelDensity()-0.1 );
    }
    if(key == 'D'){
        oculusRift.setPixelDensity( oculusRift.getPixelDensity()+0.1 );
    }

    if(key == 'p'){
        oculusRift.setPositionTracking( !oculusRift.getPositionTracking() );
    }
}
コード例 #19
0
ファイル: DebugUI.cpp プロジェクト: camb416/Poison_2013
bool DebugUI::toggleCursor(){
    bShowCursor = !bShowCursor;
    if(bShowCursor){
        ofShowCursor();
    } else {
        ofHideCursor();
    }
    return bShowCursor;
}
コード例 #20
0
ファイル: testApp.cpp プロジェクト: souek/promo123
//--------------------------------------------------------------
void testApp::update(){
    
// HIDE CURSOR OPTIONS
    
    if(Fullscreen){
		ofHideCursor();
	}else{
		ofShowCursor();
	}
}
コード例 #21
0
//--------------------------------------------------------------
void testApp::keyPressed  (int key){
		//no more draw hack...
//	clearBack = !clearBack;
//	
//	ofSetBackgroundAuto(clearBack);
	
	switch (key){
		case '1':{
			currentScene->kill();
			currentScene = &spring;
			currentScene->init();
			break;
		}
		case '2':{
			currentScene->kill();
			currentScene = &summer;
			currentScene->init();
			break;
		}
		case '3':{
			currentScene->kill();
			currentScene = &autumn;
			currentScene->init();
			break;
		}
		case '4':{
			currentScene->kill();
			currentScene = &winter;
			currentScene->init();
			break;
		}				
		case 'f':{
			ofToggleFullscreen();
			break;
		}
		case 'h':{
			gui.toggleView();	
			break;
		}	
		case 'm':{
			if(bShowMouse){
				ofHideCursor();
				bShowMouse = false;
			}else {
				ofShowCursor();
				bShowMouse = true;
			} 
			break;				
		} 			
		default:
		{
			break;
		}
	}	
}
コード例 #22
0
ファイル: testApp.cpp プロジェクト: relaystudio/Stoke
void testApp::updateGraphics() {
    if(debug || edit) ofShowCursor(); else ofHideCursor();
    cam->update();
    part->setVectors(cam->getAmplitudeWithinRegion());
    part->update();
    
    // Draw particle system
    cont.begin();
    ofClear(0);
//    ofBackground(0,100);
    part->draw();
    cont.end();
    
    // Make mask
    mask.begin();
    ofClear(0);
    for(int i=0;i<N_PROJECTOR;i++) {
        ofPushMatrix();
      //  ofEnableAlphaBlending();
        ofTranslate(i*pw, 0);
//        for(int j=N_LAYER;j>0;j--) {
            //ofSetColor(255,255,255,j/N_LAYER * 255);
            pview[i]->getLayer(0)->draw(0,0);
  //      }
        ofPopMatrix();
    }
    mask.end();
    
    // Bind the textures
    cont.getTextureReference().bind();
    mask.getTextureReference().bind();
    
    fbo.begin();
    alpha.begin();
    
    alpha.setUniformTexture("tex0",cont,cont.getTextureReference().getTextureData().textureID);
    alpha.setUniformTexture("tex1",mask,mask.getTextureReference().getTextureData().textureID);
    
    int fWidth = fbo.getWidth();
    int fHeight = fbo.getHeight();
    
    // Draw to a quad
    glBegin(GL_QUADS);
    glTexCoord2f(0, 0);             glVertex3f(0, 0, 0);
    glTexCoord2f(fWidth, 0);        glVertex3f(fWidth, 0, 0);
    glTexCoord2f(fWidth, fHeight);  glVertex3f(fWidth, fHeight, 0);
    glTexCoord2f(0, fHeight);       glVertex3f(0, fHeight, 0);
    glEnd();
    
    alpha.end();
    
    fbo.end();
    mask.getTextureReference().unbind();
    cont.getTextureReference().unbind();
}
コード例 #23
0
//--------------------------------------------------------------
void testApp::update(){
	globalSnd.update();
	
	if( state >= APP_RUN_NORMALLY ){
		if( cam.percentOver >= 0.98 ){
			showMouseTillTime = ofGetElapsedTimef() + 1.0;
		}
	
		if( ofGetElapsedTimef() < showMouseTillTime ){
			ofShowCursor();
		}else{
			ofHideCursor();
		}
	}
	
	if( ofGetFrameNum() > 5 ){
		
		if( state == APP_LOAD_SOUNDS ){
			loadSoundFx();
			state		= APP_SETUP_RISEFALL;	
			launchState = "Loading Rise Fall";
		}else if( state == APP_SETUP_RISEFALL ){
			splash.setButtonVisible();
			cam.loadResources();
			state = APP_WAITING_LAUNCH;
			launchState = "Waiting for launch";			
		}else if( state == APP_LOAD_CAMERA ){
			if( grabber.initGrabber(320, 240, true) ){
				launchState = "camera launched - loading ferns";			
				tracker.setup("tracking/front/model.bmp", "tracking/back/model.bmp", grabber.width, grabber.height); 
				launchState = "camera launched - ferns loaded";		
				bCapture = true;
				state = APP_RUN_NORMALLY;	
				//we do this to give the window time to go fullscreen
				targetWaitFrame = ofGetFrameNum() + 10; 
				ofSetFullscreen(true);
			}else{
				state = APP_WAITING_LAUNCH;
				launchState = "Load camera failed - check it is not in use by another application!";
				splash.setButtonVisible();
			}
		}else if( state == APP_RUN_NORMALLY ){
			if( !bSetup && ofGetFrameNum() > targetWaitFrame ){
				cam.setup();
				bSetup = true;
			}else{		
				updateCapture();
				cam.update();
			}				
		}

	}

}
コード例 #24
0
ファイル: ofApp.cpp プロジェクト: Digitopia/Gamult
void ofApp::keyPressed(int key) {
    if (key == 'm' || key == 'M' ) {
        multitouch = !multitouch;
        if (multitouch) {
            ofLogNotice() << "multitouch on" ;
            ofHideCursor();
        } else {
            ofLogNotice() << "multitouch off" ;
            ofShowCursor();
        }
    }
}
コード例 #25
0
ファイル: ofApp.cpp プロジェクト: SodaLtd/Opentable
//--------------------------------------------------------------
void ofApp::setup(){
	//
	//
	//
	string hostname = ofxNet::NetworkUtils::getNodeName();
#ifdef _DEBUG
	printf("hostname: %s\n", hostname.c_str());
#endif
    //
    //
    //
    ofSetBackgroundAuto(false);
    ofEnableAntiAliasing();
    ofSetCircleResolution( 24 );
    //m_default_font.loadFont("fonts/verdana.ttf",false,0.3, 144.0);
    m_default_font.setup("fonts/verdana.ttf");
	m_buttons[0].loadImage("ui/PhotoCollection.png");
	m_buttons[1].loadImage("ui/BusinessModel.png");
	m_buttons[2].loadImage("ui/Save.png");
	m_buttons[3].loadImage("ui/Close.png");

    ofDisableArbTex();
    m_background_tile.loadImage("ui/background_tile.png");
    m_background_tile.getTextureReference().setTextureWrap(GL_REPEAT, GL_REPEAT);
    ofEnableArbTex();
    
    layout();
    //
    //
    //
    
    m_db.setup();
    vector< openTableDocument* > sessions = m_db.getDocumentsOfType("session");
    if (sessions.size() > 0 ) {
        m_current_session = ( openTableSession* ) sessions[ 0 ];
    } else {
        m_current_session = ( openTableSession* ) m_db.add("session");
        m_db.save();
    }
    //
    // start server
    //
    m_server.setup();
    //
    //
    //
	m_show_keyboard = false;
	
	if ( !m_multitouch.setup() ) {
		ofShowCursor();
	}
	
}
コード例 #26
0
ファイル: ofApp.cpp プロジェクト: TheConstitute/Raybreak
//--------------------------------------------------------------
void ofApp::draw(){
    if(drawGui || mouseMode) ofShowCursor();
    else ofHideCursor();
    
    ofEnableAntiAliasing();
    ofBackground(0);
    
    ofEnableBlendMode(OF_BLENDMODE_ADD);

    // draw rays
    for(auto& ray: rays){
        if(!ray.isDead()){
            ray.draw();
        }
    }

    // draw prism
    prism->draw();
    
    // draw the fingers
    for (auto& f : finger){
        f.draw();
    }
    
    // draw spread display
    ofPushStyle();
    ofPushMatrix();
    ofTranslate(0, 500);
    ofSetLineWidth(2);
    spreadCircle.draw(ofGetWidth()/2 - spreadCircle.getWidth()/2, 50);
    ofVec2f v(-1, 0);
    v.rotate(spread/2.0 * 180);
    v.normalize();
    ofPoint c(ofGetWidth()/2, 89.25);
    ofSetColor(255);
    ofDrawLine(c + 10 * v, c + v * 45);
    ofRectangle bounds = tstar.getStringBoundingBox(ofToString(spread.get(), 1), 0, 0);
    tstar.drawString(ofToString(spread.get(), 1),
                     (c + v * 60).x - (bounds.getWidth()/2.0),
                     (c + v * 60).y + (bounds.getHeight()/2.0));
    ofPopMatrix();
    ofPopStyle();
    
    syphonMainOut.publishScreen();
    
    // draw debug stuff
    if(drawGui){
        gui.draw();
        ofSetColor(255);
        ofDrawBitmapString(ofGetFrameRate(), 5, ofGetHeight() - 25);
        ofDrawBitmapString(rays.size(), 5, ofGetHeight()-10);
    }
}
コード例 #27
0
//--------------------------------------------------------------
void testApp::keyPressed  (int key){
	
	if (key == 'p'){        // print
		// See outputPostscript()
		bEpsCapture = true;
		
	} else if (key == 'f'){ // fullscreen
		bFullscreen = !bFullscreen; 
		ofSetFullscreen (bFullscreen);
		
	} else if (key == 'h'){ // help
		bShowControlPanel = !bShowControlPanel;
		if (bShowControlPanel){
			gui.show();
			ofShowCursor();
		} else {
			gui.hide();
			ofShowCursor();
		}
	}
}
コード例 #28
0
void ofxMouseAutoHider::update(ofEventArgs &evt) {
	float timeSinceLastMouse = ofGetElapsedTimef() - lastTimeMouseMoved;
//	printf("time since last mouse moved: %f\n", timeSinceLastMouse);
	if(cursorShowing && timeSinceLastMouse>timeout) {
		cursorShowing = false;
		ofHideCursor();
	}
	
	if(!cursorShowing && timeSinceLastMouse<timeout) {
		cursorShowing = true;
		ofShowCursor();
	}
}
コード例 #29
0
ファイル: testApp.cpp プロジェクト: expokorea/korea
//--------------------------------------------------------------
void testApp::keyPressed(int key){
	if(key=='f'){
		ofToggleFullscreen();
	}
	if(key=='h'){
		hideGui=!hideGui;
		if(hideGui){
			ofHideCursor();
		}else{
			ofShowCursor();
		}
	}
}
コード例 #30
0
void ofxRGBDCaptureGui::keyPressed(ofKeyEventArgs& args){
    int key = args.key;
    
 	if(key == ' '){
		if(currentTab == TabCalibrate){
			captureCalibrationImage();
		}
		else if(currentTab == TabRecord){
			toggleRecord();
		}
		else if(currentTab == TabPlayback){
			timeline.togglePlay();
		}
	}
    
	if(key == OF_KEY_DEL && currentTab == TabCalibrate){
		alignment.discardCurrentPair();
		alignment.saveState();
	}
    
	if(key == 'f'){
		ofToggleFullscreen();
	}
	
	if(key == 'p'){
		fullscreenPoints = !fullscreenPoints;
		if(fullscreenPoints){
            for(int i = 0; i < buttonSet.size(); i++){
                buttonSet[i]->disableAppEvents();
                buttonSet[i]->disableMouseEvents();
            }
            for(int i = 0; i < btnTakes.size(); i++){
             	btnTakes[i].button->disableAppEvents();   
                btnTakes[i].button->disableMouseEvents();   
            }
			ofHideCursor();
		}
		else{
            for(int i = 0; i < buttonSet.size(); i++){
                buttonSet[i]->enableMouseEvents();
                buttonSet[i]->enableAppEvents();
            }
			for(int i = 0; i < btnTakes.size(); i++){
             	btnTakes[i].button->enableMouseEvents();
                btnTakes[i].button->enableAppEvents();
            }
            
			ofShowCursor();			
		}
	}   
}