//--------------------------------------------------------------
void ofApp::setup(){
	ofBackground(255);
	ofEnableAntiAliasing();
	ofEnableSmoothing();
	ofSetFrameRate(60);

	ofEnableDepthTest(); // enable depth test for correctly drawing 3D shapes

	bResample = true;
	resampleSpacing = 5.0;
	letterThickness = 50.0;

	ofTrueTypeFont ttf;
	// to extract points, loadFont must be called with makeContours set to true
	ttf.loadFont(OF_TTF_SANS, 300, true, false, true);
	string s = "TYPE";

	// Center string code from:
	// https://github.com/armadillu/ofxCenteredTrueTypeFont/blob/master/src/ofxCenteredTrueTypeFont.h
	ofRectangle r = ttf.getStringBoundingBox(s, 0, 0);
	center = ofVec2f(floor(-r.x - r.width * 0.5f), floor(-r.y - r.height * 0.5f));

	vector <ofTTFCharacter> letters = ttf.getStringAsPoints(s);

	for(int i = 0; i < letters.size(); i++){
		ofPath resampledPath = bResample ? resamplePath(letters[i], resampleSpacing) : letters[i];
		ofMesh meshLetter = createMeshFromPath(resampledPath, letterThickness);
		mesh.append(meshLetter);
	}

	colorFaces(mesh);

	// adhere easycam view to openFrameworks coordinate system
	cam.setVFlip(true);
}
Пример #2
0
////////////////////////////////////////
// setup
////////////////////////////////////////
void ofApp::setup()
{
    //---------------------------------------- ofxTokyo2020
    fontSize = 60.0;
    
    // set font size
    ofxTokyo2020::setFontSize( fontSize );
    
    // set letter spacing
    ofxTokyo2020::setLetterSpacing( fontSize / 3 );
    
    // set line height
    ofxTokyo2020::setLineHeight( ( fontSize / 3 ) * 4 );
    
    str           = "ofxtokyo2020";
    bCell         = true;
    bWaitPrevious = false;
    
    font.setString( str, fontSize, ofGetHeight() * 0.5, ( bCell ) ? ANIMATION_TYPE_CELL: ANIMATION_TYPE_EASING, bWaitPrevious );
    
    
    //---------------------------------------- application settings
    ofSetVerticalSync( true );
    ofEnableAntiAliasing();
    ofSetCircleResolution( 48 );
    
    ofBackground( 255 );
}
//--------------------------------------------------------------
void ofApp::setup(){
	saveOneFrame = false; // variable used to save a single frame as a PDF page

	bg_color = ofColor(255);
	fbo_color = ofColor(0);

	ofBackground(bg_color);
	ofEnableAntiAliasing();
	ofEnableSmoothing();
	ofSetFrameRate(60);

	ofTrueTypeFont ttf;
	ttf.loadFont(OF_TTF_SANS, 350);
	string s = "TYPE";

	ofFbo fbo;
	fbo.allocate(ofGetWidth(), ofGetHeight(), GL_RGBA);
	pix.allocate(ofGetWidth(), ofGetHeight(), OF_PIXELS_RGBA);
	fbo.begin();
	ofClear(0, 0, 0, 0);
	// Center string code from:
	// https://github.com/armadillu/ofxCenteredTrueTypeFont/blob/master/src/ofxCenteredTrueTypeFont.h
	ofRectangle r = ttf.getStringBoundingBox(s, 0, 0);
	ofVec2f offset = ofVec2f(floor(-r.x - r.width * 0.5f), floor(-r.y - r.height * 0.5f));
	ofSetColor(fbo_color);
	ttf.drawString(s, fbo.getWidth() / 2 + offset.x, fbo.getHeight() / 2 + offset.y);
	fbo.end();

	fbo.readToPixels(pix); // the ofPixels class has a convenient getColor() method
}
Пример #4
0
//--------------------------------------------------------------
void testApp::setup(){
    ofEnableAntiAliasing();
    ofSetVerticalSync( true );
    ofSetFrameRate( 30 );
    
    #ifdef DISABLE_STREAMING
    cout << "Disabled streaming: compile with 'Release' to enable" << endl;
    #else
    cout << "Enabled streaming: compile with 'Release NoStream' to disable" << endl;
    #endif

    videoFeedController.init();
    overlay.init();
    

#ifndef DISABLE_STREAMING
    // MULTI STREAMER
    // --------------------------------------------------
    int fps = 15;
    if(!streamer.setup("streamer.xml", ofGetWidth(), ofGetHeight(), fps)) {
      printf("error: cannot setup the streamer.\n");
      ::exit(EXIT_FAILURE);
    }

    if(!streamer.start()) {
      printf("error: cannot start the streamer.\n");
      ::exit(EXIT_FAILURE);
    }

    sound_stream.listDevices();
    sound_stream.setup(this, 0, 2, 44100, 1024, 4);
#endif
    
}
Пример #5
0
/// \brief The standard setup function.
void setup() {
    // Set the background to zero / black.
    ofBackground(0);
    
    // Enable alpha blending.
    ofEnableAlphaBlending();
    
    // Enable anti-aliasing.
    ofEnableAntiAliasing();

     // Set the size of the window.
    ofSetWindowShape(1000, 1000);
    
    // Enable depth tests to ensure that correct 3D rendering.
    ofEnableDepthTest(); 

    // The size of the box in the x, y and z dimension.    
    boxSize = ofPoint(600, 600, 300);

    // Create particles.
    for (int i = 0; i < 100; i++)
    {
        // Create a half-sized box for calculations.
        ofPoint halfBoxSize = boxSize / 2;
        
        // Instantiate our base particle.
        std::shared_ptr<BaseParticle> aParticle = std::shared_ptr<BaseParticle>(new BaseParticle());
        
        // Set the initial position to a random point inside our bounding box.
        aParticle->position = ofPoint(ofRandom(-halfBoxSize.x, halfBoxSize.x),
                                      ofRandom(-halfBoxSize.y, halfBoxSize.y),
                                      ofRandom(-halfBoxSize.z, halfBoxSize.z));
        
        // Set a random velocity.
        aParticle->velocity = ofPoint(ofRandom(-10, 10),
                                     ofRandom(-10, 10),
                                     ofRandom(-10, 10));

        // Set a random drag.
        float drag = ofRandom(0.9, 0.99);
        
        // Our drag is the same in the x, y and z directions.
        aParticle->drag = ofPoint(drag, drag, drag);
        
        // Create a random size for our particle.
        float size = 3;
        
        // Our particle size is the same in the x, y and z directions.
        aParticle->size = ofPoint(size, size, size);

        // Assign a random color to the particle.
        aParticle->color = ofColor(255, 127);
        
        // Add the particle to our collection.
        particles.push_back(aParticle);
    }
}
Пример #6
0
void ofApp::setupVisual(){
	cout << "setting up Visual" << endl;

	ofSetFrameRate(60);
	ofSetVerticalSync(true);
	ofSetCircleResolution(10);
	ofDisableAlphaBlending();
	ofEnableAntiAliasing();
	ofDisableSmoothing();
}
Пример #7
0
//--------------------------------------------------------------
void ofApp::keyPressed  (int key){
	if (key == 's'){
		bSmooth = !bSmooth;
        if (bSmooth){
            ofEnableAntiAliasing(); 
        }else{
            ofDisableAntiAliasing(); 
        }
	}
}
Пример #8
0
//--------------------------------------------------------------
void ofApp::keyPressed  (int key){
	// the key of s toggles antialiasing
	if (key == 's'){
		bSmooth = !bSmooth;
        if (bSmooth){
            ofEnableAntiAliasing(); 
        }else{
            ofDisableAntiAliasing(); 
        }
	}
}
Пример #9
0
void testApp::draw() {
  ofEnableAlphaBlending();
  ofEnableDepthTest();
  ofEnableAntiAliasing();

  cam.begin();
    ofPushMatrix();
      double amp = rms() * 450;
      if (amp > 50) {
        float spectral_centroid = mfft.spectralCentroid();
        int resolution = (int) floor(spectral_centroid / 20000.f * 64);
        mesh = createGeoSphere(resolution, resolution);
        ofVec3f center = mesh.getCentroid();

        ofDrawBox(center.x, center.y, 0, 1, amp * 8, 1);
        ofDrawBox(center.x, center.y, 0, amp * 8, 1, 1);
        ofDrawBox(center.x, center.y, 0, 1, 1, amp * 8);

        ofNoFill();
        ofCircle(center.x, center.y, amp);
        ofCircle(center.x, center.y, amp * 2);
        ofCircle(center.x, center.y, amp * 3);

        ofScale(amp, amp, amp);

        if (spectral_centroid > 0.4) {
          position = (int) ofRandom(mesh.getNumVertices());
        }

        for (int i = 0; i < moct.nAverages; i++) {
          if (moct.averages[i] < 20) {
            continue;
          }

          position += (int) floor(mfft.spectralFlatness() * 20) + 1;
          position %= mesh.getNumVertices();

          int vertex = position;
          float offsetDistance = moct.averages[i] * 0.02;

          ofVec3f p0 = mesh.getVertex(vertex);
          ofVec3f normal = center - p0;
          normal.normalize();
          p0 -= (normal * (offsetDistance * 0.5));
          mesh.setVertex(vertex, p0);
        }

       mesh.drawWireframe();
      }
    ofPopMatrix();
  cam.end();

  ofDrawBitmapString(ofToString((int) ofGetFrameRate()) + " fps", 32, 32);
}
Пример #10
0
//------------------------------------------------------------------------------
void ofApp::setup()
{
    ofEnableAntiAliasing();
    ofEnableSmoothing();
    ofSetFrameRate(60);
    glEnable(GL_DEPTH_TEST);

    particleEmitter = new MeshParticleEmitter(10, 100.0f, 2.0f);

    light.setPointLight();
    light.setPosition(0,0,0);
}
Пример #11
0
void Application::setup(){
	if(!loadXmlSettings(PIMAPPER_USER_SURFACES_XML_FILE)){
		ofLogWarning("Application::setup()") << "Failed to load user settings. Populated default one" << endl;
	}
	ofSetBackgroundColor(ofColor::black);
	ofEnableAntiAliasing();
	ofSetFrameRate(25);
	ofHideCursor();
	consoleListener.setup(this);
	_osc.setup(5250);
	ofAddListener(ofxOscEvent::packetIn, this, &Application::onPacketIn);
}
Пример #12
0
//--------------------------------------------------------------
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();
	}
	
}
Пример #13
0
//--------------------------------------------------------------
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);
    }
}
Пример #14
0
//--------------------------------------------------------------
void testApp::setup(){
    ofEnableAntiAliasing();
    ofSetFrameRate(15);
    for (int i=0; i<NUMOFBOIDS; i++) {
        boids.push_back(Boid());
    }
    sender.setup("127.0.0.1", 6666);
    
    //old OF default is 96 - but this results in fonts looking larger than in other programs.
	ofTrueTypeFont::setGlobalDpi(72);
    
    verdana14.loadFont("verdana.ttf", 14, true, true);
	verdana14.setLineHeight(18.0f);
	verdana14.setLetterSpacing(1.037);
}
Пример #15
0
//--------------------------------------------------------------
void ofApp::setup(){
	//we run at 60 fps!
	ofSetVerticalSync(true);
	ofSetFrameRate(60);
	ofEnableAntiAliasing();

	//create the socket and bind to port 11999
	ofxUDPSettings settings;
	settings.receiveOn(11999);
	settings.blocking = false;

	udpConnection.Setup(settings);

	ofSetBackgroundAuto(false);
	ofSetBackgroundColor(255);
}
Пример #16
0
//--------------------------------------------------------------
void testApp::setup() {

    // [P] println("hello ITP");
    cout << "hello ITP" << endl;

    // [P] smooth();
    ofEnableAntiAliasing();
    ofSetCircleResolution(50);

    rad = 50;

    // center of your window
    posX = ofGetWidth()/2;
    posY = ofGetHeight()/2;

    speedX = 5;
    speedY = 5;
}
Пример #17
0
void Button::draw()
{
    ofColor backgroundColor;
    ofColor textColor;

    switch (state) {
    case BUTTON_STATE_DISABLED:
        backgroundColor = disabledColor;
        textColor = ofColor(100);
        break;
    case BUTTON_STATE_IDLE:
        backgroundColor = idleColor;
        textColor = ofColor(255);
        break;
    case BUTTON_STATE_HOVER:
        backgroundColor = hoverColor;
        textColor = ofColor(255);
        break;
    case BUTTON_STATE_PRESSED:
    case BUTTON_STATE_CLICKED:
        backgroundColor = pressedColor;
        textColor = ofColor(255);
        break;
    }

    ofDisableAntiAliasing();

    // Background
    ofSetColor(backgroundColor);
    ofRect(displayX + colorBorder + 1, displayY + colorBorder, displayWidth - (colorBorder + 4), displayHeight - (colorBorder + 3));

    // Borders
    ofSetColor(borderColor);
    ofLine(displayX, displayY, displayX + displayWidth, displayY); // Top
    ofLine(displayX, displayY + displayHeight, displayX + displayWidth, displayY + displayHeight); // Bottom
    ofLine(displayX + 1, displayY, displayX + 1, displayY + displayHeight); // Left
    ofLine(displayX + displayWidth, displayY, displayX + displayWidth, displayY + displayHeight); // Right

    // Text
    ofEnableAntiAliasing();
    ofSetColor(textColor);
    font.drawString(text, textX, textY);
}
Пример #18
0
//--------------------------------------------------------------
void ofApp::setup(){
	ofEnableAntiAliasing();
	ofEnableSmoothing();
	ofEnableDepthTest();

	bResample = true;
	resampleSpacing = 5.0;
	letterThickness = 145.0;

	ofTrueTypeFont ttf;
	// to extract points, loadFont must be called with makeContours set to true
	ttf.loadFont(OF_TTF_SANS, 300, true, false, true);
	string s = "TYPE";

	// Center string code from:
	// https://github.com/armadillu/ofxCenteredTrueTypeFont/blob/master/src/ofxCenteredTrueTypeFont.h
	ofRectangle r = ttf.getStringBoundingBox(s, 0, 0);
	center = ofVec2f(floor(-r.x - r.width * 0.5f), floor(-r.y - r.height * 0.5f));

	vector <ofTTFCharacter> letters = ttf.getStringAsPoints(s);

	for(int i = 0; i < letters.size(); i++){
		ofPath resampledPath = bResample ? resamplePath(letters[i], resampleSpacing) : letters[i];
		ofMesh meshLetter = createMeshFromPath(resampledPath, letterThickness);
		mesh.append(meshLetter);
	}

	getBoundaries(mesh);

	numSpheres = 7000; // the maximum number of Spheres
	addSpeed = 25; // the number of Spheres that is added per update() loop

	ofEnableLighting();
	ofSetGlobalAmbientColor(ofColor(128));

	directionalLight.setDiffuseColor(ofColor(128));
	directionalLight.setPosition(boundsMax);
	directionalLight.enable();

	cam.setVFlip(true);
}
//--------------------------------------------------------------
void ofApp::setup() {
    fg_color = ofColor(0);
    bg_color = ofColor(255);
    fbo_color = ofColor(0);

    ofBackground(bg_color);
    ofSetBackgroundAuto(false);
    ofEnableAntiAliasing();
    ofSetFrameRate(60);

    ofTrueTypeFont ttf;
    ttf.loadFont(OF_TTF_SANS, 350);
    string s = "TYPE";

    ofFbo fbo;
    ofPixels pix;
    fbo.allocate(ofGetWidth(), ofGetHeight(), GL_RGBA);
    pix.allocate(ofGetWidth(), ofGetHeight(), OF_PIXELS_RGBA);
    fbo.begin();
    ofClear(0, 0, 0, 0);
    // Center string code from:
    // https://github.com/armadillu/ofxCenteredTrueTypeFont/blob/master/src/ofxCenteredTrueTypeFont.h
    ofRectangle r = ttf.getStringBoundingBox(s, 0, 0);
    ofVec2f offset = ofVec2f(floor(-r.x - r.width * 0.5f), floor(-r.y - r.height * 0.5f));
    ofSetColor(fbo_color);
    ttf.drawString(s, fbo.getWidth() / 2 + offset.x, fbo.getHeight() / 2 + offset.y);
    fbo.end();

    fbo.readToPixels(pix); // get the fbo's ofPixels object (to set the division rates in the RD class)

    int w = 320;
    int h = 180;
    // setup the reaction-diffusion simulation
    rd.setup(w, h); // setup the simulation with the specified width and height
    rd.setFeedRates(0.0374, 0.0585); // set the in & out feed rates (in this sketch also dynamically changed in the update() loop)
    rd.setKillRates(0.0695, 0.0610); // set the in & out kill rates
    rd.kickstart(150); // randomly set N substance values to kickstart the simulation
    rd.setImage(pix); // use the ofPixels object of the offscreen fbo to set the division rates
    // setup the result image with the same dimensions as the simulation
    result.allocate(w, h, OF_IMAGE_COLOR);
}
void Patch::draw() {

    if (isMouseOver()) {
        hover = true;
    } else {
        hover = false;
    }

    ofPushStyle();
    ofSetColor(150.0f);
    ofEnableSmoothing();
    ofEnableAntiAliasing();
    ofSetLineWidth(2.0f);

    if (port_connect) {
        ofLine(line_start, ofPoint(ofGetMouseX(), ofGetMouseY()));
    }

    // also draw all connections
    for (int i = 0; i < connections.size(); i++) {
        ofLine(connections[i]->from->cp, connections[i]->to->cp);
    }

    ofPopStyle();


    switch (type) {
    case PATCH:
        drawPatch();
        break;
    case UI_BUTTON:
        drawButton();
        break;
    case UI_FIXED_BUTTON:
        drawFixedButton();
        break;
    };
}
Пример #21
0
void lineScene::draw(float x, float y, float scale){
    
//    if ( oni->isSkeleton() ) {
    ofEnableAntiAliasing();
//    ofEnableAlphaBlending();
    
//    ofBackground(bgColor);
    ofSetColor(lineColor);
    
    ofPushMatrix();
    ofTranslate(x, y);
    ofTranslate(160, 120);
    ofScale(scale, scale);
    ofTranslate(-160, -120);
    ofScale(0.5, 0.5);
    if ( bDrawMoire) drawMoire();
    if ( bDrawBody ) drawBodyLines();
    ofPopMatrix();

//    ofDisableAlphaBlending();
    ofDisableAntiAliasing();
//    }

}
Пример #22
0
//--------------------------------------------------------------
void ofApp::setup(){

    
    ofEnableSmoothing();
    ofEnableAlphaBlending();
    ofEnableAntiAliasing();
    ofSetFrameRate(30);
    
    
    string imgPath = "Serviette.png";
    string exportPath = "export2.tiff";
    

    int maGamme[]={0xcccccc,0xc950e3,0xefff1a,0x36af1c,0x0000ff,0xff0000};
        
    carton.setColorRange(6,maGamme);
    carton.analyseImg();
    
    
    carton.setup(imgPath);

    carton.addWeaveToColor(0, myWeave.fondGris);
    carton.addWeaveToColor(1, myWeave.fondJaune);
    carton.addWeaveToColor(2, myWeave.dessinSurGris);
    carton.addWeaveToColor(3, myWeave.dessinSurJaune);
    carton.addWeaveToColor(4, myWeave.empty);
    carton.addWeaveToColor(5, myWeave.full);
    
    carton.showColorRange(true);
    
    carton.setCardScale(2, 3);
    carton.makeCard();
    carton.exportcard(exportPath);
    
    
}
Пример #23
0
//--------------------------------------------------------------
void ofApp::setup() {


#ifdef DEBUG

#else
    ofSetDataPathRoot("../Resources/data");
#endif



    ofBackground(0,0);
    ofSetFrameRate(60);

    ofEnableAntiAliasing();
    ofEnableDepthTest();
    ofEnableAlphaBlending();
    ofEnableBlendMode(OF_BLENDMODE_ADD);

//    glPointSize(1);
//    glLineWidth(4);


    cam.setAutoDistance(false);
    cam.setDistance(700);


    posSize.x = 4000;
    posSize.y = 4000;

    fbo.allocate(posSize.x, posSize.y, GL_RGBA);

    ofDisableArbTex();


    texture.load("pluto.jpg");



    texture.getTexture().setTextureWrap( GL_REPEAT, GL_REPEAT );
    sphere.setMode( OF_PRIMITIVE_TRIANGLES );

    baseColor = ofColor(255, 180);

    mesh.setMode(OF_PRIMITIVE_LINES);
    darkMesh.setMode(OF_PRIMITIVE_TRIANGLES);
    baseLunar.setMode(OF_PRIMITIVE_TRIANGLES);
    allMesh.setMode(OF_PRIMITIVE_LINES);

    creatorNum = 1500;
    lineAlpha = 80;
    baseColor = ofColor(255, lineAlpha);

    ofAddListener(ofEvents().mouseReleased, this, &ofApp::guiMouseReleased, OF_EVENT_ORDER_BEFORE_APP);

    gui.setup();
    gui.add(hideGui.setup("h key GUI Menu OnOff", ""));
    gui.add(fullScreenOnOff.setup("f key Full Screen", ""));
    gui.add(numCreators.setup("Num Creators", creatorNum, 0, 4500));
    gui.add(randomHeight.setup("Random Height", 0.025, 0, 0.05));
    gui.add(lineAlpha.setup("Line Alpha", 80, 0, 255));
    gui.add(meshOnOff.setup("Default Draw", true));
    gui.add(lineOnOff.setup("Normal Line", true));
    gui.add(creatorOnOff.setup("Creator", true));
    gui.add(darkPlane.setup("Dark Plane", false));
    gui.add(arcOnOff.setup("Arc Draw", false));
    gui.add(innerCircle.setup("Base Sphere", true));
    gui.add(textureOnOff.setup("Texture", false));
    gui.add(innerCircleSize.setup("Inner Size", 0.95, 0.9, 1.1));
    gui.add(frameRate.setup("FPS", ""));
    gui.add(screenCapture.setup("Screen Capture"));


//    setPoint3D(creatorNum);
    polarPositionProb();
    creatorSetting();

    fullScreen = false;
    bHide = true;
    innerCircle = false;

    //    light.setAttenuation();
    //    light.setPosition(-100, 100, 100);

    inLineAlpha = false;
    inNumCreators = false;
    inRandomHeight = false;

}
Пример #24
0
//--------------------------------------------------------------
void cyrilApp::setup(){
  doResetTimers = true;
  
  ofSoundStreamSetup(0, 1, this, 44100, beat.getBufferSize(), 4);
  
  // Switch back to external data folder
  ofSetDataPathRoot("../../../data/");
  
  ofBackground(0);
  pauseProg = false;
  //lightsOn = true;
  lightsOn = true;
  isOrtho = false;
  fxOn = true;
  
  runningProg = false;
  running[0] = false;
  running[1] = false;
  running[2] = false;
  running[3] = false;
  running[4] = false;
  running[5] = false;
  running[6] = false;
  running[7] = false;
  running[8] = false;
  running[9] = false;
  error[0] = false;
  error[1] = false;
  error[2] = false;
  error[3] = false;
  error[4] = false;
  error[5] = false;
  error[6] = false;
  error[7] = false;
  error[8] = false;
  error[9] = false;

#ifdef FULL_DEBUG
	ofSetLogLevel("ofxGLEditor", OF_LOG_VERBOSE);
#endif
  
  
  editor.addCommand('z', this, &cyrilApp::toggleFx);
  editor.addCommand('f', this, &cyrilApp::toggleFullscreen);
  editor.addCommand('a', this, &cyrilApp::toggleEditor);
  editor.addCommand('d', this, &cyrilApp::toggleBackground);
  editor.addCommand('k', this, &cyrilApp::toggleLights);
  editor.addCommand('l', this, &cyrilApp::loadFile);
  editor.addCommand('s', this, &cyrilApp::saveFile);
  editor.addCommand('e', this, &cyrilApp::resetTimers);
  editor.addCommand('p', this, &cyrilApp::pauseProgram);
  editor.addCommand('r', this, &cyrilApp::runScript);
  editor.addCommand('o', this, &cyrilApp::toggleOrtho);
  
  editorVisible = true;
  
  lastSignalReport = -1;
  
  // Init evaluation stack to empty
  _state.stk = new stack<float>;
  // Initialise our own matrix stack
  // TODO: replace with call to get from current renderer?
  _state.ms = new ofMatrixStack(*ofGetWindowPtr());
  // Initialise empty paticle system
  _state.ps = new vector<Particle*>;
  // Initialise empty variable/register map
  _state.sym = new map<int, float>;
  // Initialise palettes
  _state.cs = new map<int, Palette *>;
  // Initialise sprites
  _state.img = new map<int, ofImage *>;
  _state.parent = NULL;
  _state.light = new ofLight();
  //_state.light = NULL;
  
  
  // Directory watcher for data folder
  codeWatcher.registerAllEvents(this);
  spriteWatcher.registerAllEvents(this);
  codeWatcher.addPath(ofToDataPath("code", true), true, &fileFilter);
  spriteWatcher.addPath(ofToDataPath("sprites", true), true, &fileFilter);
  
  
  (*_state.sym)[REG_X_MAX] = 640;
  (*_state.sym)[REG_Y_MAX] = 480;
  (*_state.sym)[REG_X_MID] = (*_state.sym)[REG_X_MAX] / 2.0;
  (*_state.sym)[REG_Y_MID] = (*_state.sym)[REG_Y_MAX] / 2.0;
  
  (*_state.sym)[REG_X_SCALE] = 100;
  (*_state.sym)[REG_Y_SCALE] = 100;
  (*_state.sym)[REG_Z_SCALE] = 100;
  
  (*_state.sym)[REG_PI] = PI;
  (*_state.sym)[REG_TWO_PI] = TWO_PI;
  
  (*_state.sym)[REG_PARTICLE_HEALTH] = 1;
  (*_state.sym)[REG_PARTICLE_DECAY] = 0.1;
  
  // Reserve some space for Particle System
  _state.ps->reserve(2000);
  
  // Global settings
  ofEnableDepthTest();
	ofSetVerticalSync(true);
  if (lightsOn) {
    ofEnableLighting();
    _state.light->setAmbientColor(ofColor(0,0,0));
    _state.light->setDiffuseColor(ofColor(255,255,255));
    _state.light->setSpecularColor(ofColor(255,255,255));
    _state.light->setPointLight();
    _state.light->setAttenuation(1.f,0.f,0.f);
  }
  
  autoClearBg = true;
  ofSetBackgroundAuto(true);
  
  // changed this...
  cursorVisible = true;
  //ofHideCursor();
#ifdef __APPLE__
  //CGDisplayHideCursor(NULL); // <- OK
#endif
  
  
  (*_state.sym)[REG_FRAME] = 0;
  
  edBuf.allocate();
  edBuf.begin();
  ofClear(0,0,0,0);
  edBuf.end();
  
  ofEnableAlphaBlending();
  ofEnableAntiAliasing();
  ofEnableSmoothing();
  
  isFullScreen = false;
  //ofSetFullscreen(true);
  
	//mainOutputSyphonServer.setName("Cyril Main Output");
	//mClient.setup();
  //mClient.set("","Cyril Server");
  
	// listen on the given port
	//cout << "listening for osc messages on port " << PORT << endl;
	//receiver.setup(PORT);
  
  // Configure the ofxPostProcessing effects
  _state.post = ofxPostProcessing();
  _state.post.init(ofGetWidth(), ofGetHeight());
  _state.post.setFlip(false);
  _state.kaleido = _state.post.createPass<KaleidoscopePass>();
  _state.noisewarp = _state.post.createPass<NoiseWarpPass>();
  _state.pixelate = _state.post.createPass<PixelatePass>();
  _state.bloom = _state.post.createPass<BloomPass>();
}
Пример #25
0
void ofApp::setup() {
    
    ofEnableSmoothing();
    ofEnableAlphaBlending();
    ofSetFrameRate(60);
    ofSetVerticalSync(true);
    ofEnableDepthTest();
    ofEnableAntiAliasing();

    memset( dmxData_, 0, DMX_DATA_LENGTH );
    
    //open the device
    dmxInterface_ = ofxGenericDmx::createDevice(DmxDevice::DMX_DEVICE_RAW);
    bool opened = dmxInterface_->open();
    if ( dmxInterface_ == 0 || !opened ) {
        printf( "No FTDI Device Found\n" );
    } else {
        printf( "isOpen: %i\n", dmxInterface_->isOpen() );
    }
    
    printf("ofxGenericDmx addon version: %s.%s\n", ofxGenericDmx::VERSION_MAJOR, ofxGenericDmx::VERSION_MINOR);
    
    std::string file = "Lightweave_loops2.json";
    std::string columnsFile = "Lightweave_columns2.json";
    std::string facesFile = "Lightweave_faces2.json";
    
    bool parsingSuccessful = result.open(file);
    
    bool parsingSuccessfulColumn = columnGeometry.open(columnsFile);

    bool parsingSuccessfulFaces = faceGeometry.open(facesFile);

    
    for (int region = 0; region < 6; region++) {
        string blah = "region" + ofToString(region);
        for (int rings = 0; rings < result[blah].size(); rings++) {
            string ring = "ring" + ofToString(rings);
            for (int pointPos = 0; pointPos < 3; pointPos++) {
                string point = "point" + ofToString(pointPos);
            }
        }
    }
        
    //setupUDP();
    
    camWidth = 320;
    camHeight = 240;

    vector<ofVideoDevice> devices = vidGrabber.listDevices();
    for (int i = 0; i < devices.size(); i++) {
        if (devices[i].bAvailable) {
            ofLogNotice() << devices[i].id << ": " << devices[i].deviceName;
        } else {
            ofLogNotice() << devices[i].id << ": " << devices[i].deviceName << " - unavailable ";
        }
    }
    
    for (int i = 0; i < devices.size(); i++) {
        if (!devices[i].deviceName.find("USB")) {
            cout << devices[i].id << endl;
            pcCams.push_back(devices[i].id);
        }
    }
    

    vidGrabber.setDeviceID(pcCams[0]);
//    vidGrabber.setDeviceID(0);

    vidGrabber.initGrabber(320,240);
    
    vidGrabber1.setDeviceID(pcCams[1]);
//    vidGrabber1.setDeviceID(0);

    vidGrabber1.initGrabber(320,240);
    
    colorImg1.allocate(320,240);
    grayImage1.allocate(320,240);
    grayBg1.allocate(320,240);
    grayDiff1.allocate(320,240);
    
    colorImg.allocate(320,240);
    grayImage.allocate(320,240);
    grayBg.allocate(320,240);
    grayDiff.allocate(320,240);
    
    bLearnBackground = true;
    bLearnBackground1 = true;
    threshold = 80;
    drawOne = false;
    
    bottomSwarm.a = 1.1f;
    bottomSwarm.b = (curWidth/4.0);
    bottomSwarm.c = 100.0;
    bottomSwarm.bVel = 1.0;
    
    xPos = 0;
    yPos = 0;
    zPos = 0;
    
    cam.setPosition(result["region0"]["ring0"]["point0"][0].asFloat(),result["region0"]["ring0"]["point0"][1].asFloat(),result["region0"]["ring0"]["point0"][2].asFloat());
    cam.lookAt(ofVec3f(result["region0"]["ring1"]["point0"][0].asFloat(),result["region0"]["ring1"]["point0"][1].asFloat(),result["region0"]["ring1"]["point0"][2].asFloat()));
    cam.rotate(ofRadToDeg(PI/2), 1.0, 0.0, 0.0);
    cam.setFov(32.0);
    
    sphereZPos = 25.9297;
    sphereXPos = 364.928;
    
    for (int i = 0; i < 20; i++) {
        spheresXPos[i] = ofRandom(result["region0"]["ring0"]["point0"][0].asFloat()-500, result["region0"]["ring0"]["point0"][0].asFloat()+500.0);
        spheresZPos[i] = ofRandom(result["region0"]["ring0"]["point0"][2].asFloat()-100.0, result["region0"]["ring0"]["point0"][2].asFloat()+100.0);
    }
    
    /* LIGHTING */
    ofSetSmoothLighting(true);

    pointLight.setDiffuseColor( ofColor(0.f, 255.f, 0.f));
    
    pointLight.setSpecularColor( ofColor(255.f, 255.f, 255.f));
    pointLight.setPosition(result["region0"]["ring0"]["point0"][0].asFloat(),result["region0"]["ring0"]["point0"][1].asFloat(),result["region0"]["ring0"]["point0"][2].asFloat());
    
    material.setShininess( 64 );
    
    colorHue = ofRandom(0, 250);
    colorHue2 = ofRandom(0, 250);
    
    lightColor.setBrightness( 180.f );
    lightColor.set(250,250,210);
    
    materialColor.setBrightness(250.f);
    materialColor.set(100,100,100);
    
    lightColor.setHue(colorHue);
    pointLight.setDiffuseColor(lightColor);
    
    materialColor.setHue(colorHue);
    material.setSpecularColor(materialColor);
    
    
    materialColor.set(255.0,0.0,0.0);
    columnMaterial.setSpecularColor(materialColor);
    
    materialColor.set(55.0,55.0,55.0);
    peopleMaterial.setSpecularColor(materialColor);
    
    cameraColor1.set(0.0, 0.0, 255.0);
    cameraColor2.set(0.0, 0.0, 255.0);
    columnColor.set(255, 0, 0);
    activeColor.set(0.0,0.0,255.0);

}
Пример #26
0
//--------------------------------------------------------------
void ofApp::setup(){
    // This is enabled by default in recent version of openFrameworks
    ofEnableAntiAliasing();

    ofSetCircleResolution(50); // For smoother looking circles + ellipses
}
Пример #27
0
//--------------------------------------------------------------
void testApp::keyReleased(int key){
    switch (key) {
        case 'f':
            ofToggleFullscreen();
            break;
        case '0':
            ofEnableBlendMode(OF_BLENDMODE_DISABLED);
            break;
        case '1':
            ofEnableBlendMode(OF_BLENDMODE_ALPHA);
            break;
        case '2':
            ofEnableBlendMode(OF_BLENDMODE_ADD);
            break;
        case '3':
            ofEnableBlendMode(OF_BLENDMODE_SUBTRACT);
            break;
        case '4':
            ofEnableBlendMode(OF_BLENDMODE_MULTIPLY);
            break;
        case '5':
            ofEnableBlendMode(OF_BLENDMODE_SCREEN);
            break;
        case 'a':
            ofEnableAntiAliasing();
            break;
        case 'b':
            ofBackground(0, 0, 0, 255);
            break;
        case 'd':
            ofDisableAlphaBlending();
            break;
        case 'e':
            ofEnableAlphaBlending();
            break;
        case 'r':
            //read file
            importFileForStruct();
            break;
        case 's':
            ofDisableAntiAliasing();
            break;
        case 'w':
            ofBackground(255, 255, 255, 255);
            break;
        case ' ':
        {
            saveToFile = true;
            ofLog(OF_LOG_NOTICE, "calculating...");
            //ペアのデータを作成 -->
            vector<pointPair> pointPairVectorForWriting;
            for (int k=0; k<image1.getWidth()*image1.getHeight(); k++) {
                if (k <= image1.getWidth()*image1.getHeight()) {
                    // 左の画像を右の画像に入れ替える
                    ofPoint referencePoint;
                    if (enableRandomExchange) {
                        //ランダムで交換
                        referencePoint = ofPoint(exchangeOrderVector[k]%(int)image1.getWidth(), exchangeOrderVector[k]/(int)image1.getWidth());
                        
                    }else{
                        //上から順に交換
                        referencePoint = ofPoint(k%(int)image1.getWidth(), k/(int)image1.getWidth());
                    }
                    ofColor referenceColor = image1.getColor(referencePoint.x, referencePoint.y);
                    double minimumDistance = image1.getWidth()+image2.getHeight();
                    ofPoint minimumDistancePoint;
                    unsigned char * checkImagePixels = image2.getPixels();
                    // 最小の距離の色を調べる
                    for (int i=0; i<image1.getHeight(); i++) {
                        for (int j=0; j<image1.getWidth(); j++) {
                            if (!enableDuplicate) {
                                // 重複を許さない
                                if (!usedOrNotVector[i*(int)image2.getWidth()+j]) {
                                    ofColor checkColor = ofColor(checkImagePixels[(i*(int)image2.getWidth()+j)*3],
                                                                 checkImagePixels[(i*(int)image2.getWidth()+j)*3+1],
                                                                 checkImagePixels[(i*(int)image2.getWidth()+j)*3+2]);
                                    double checkDistance = getColorDistance(referenceColor, checkColor);
                                    if (checkDistance < minimumDistance) {
                                        if (!usedOrNotVector[i*(int)image2.getWidth()+j]) {
                                            minimumDistance = checkDistance;
                                            minimumDistancePoint = ofPoint(j, i);
                                        }
                                        // 同じ色の重複を許す
                                        minimumDistance = checkDistance;
                                        minimumDistancePoint = ofPoint(j, i);
                                    }
                                }
                            } else{
                                ofColor checkColor = ofColor(checkImagePixels[(i*(int)image2.getWidth()+j)*3],
                                                             checkImagePixels[(i*(int)image2.getWidth()+j)*3+1],
                                                             checkImagePixels[(i*(int)image2.getWidth()+j)*3+2]);
                                double checkDistance = getColorDistance(referenceColor, checkColor);
                                if (checkDistance < minimumDistance) {
                                    if (!usedOrNotVector[i*(int)image2.getWidth()+j]) {
                                        minimumDistance = checkDistance;
                                        minimumDistancePoint = ofPoint(j, i);
                                    }
                                    // 同じ色の重複を許す
                                    minimumDistance = checkDistance;
                                    minimumDistancePoint = ofPoint(j, i);
                                }
                            }
                        }
                    }
                    //最も近い距離の色の組み合わせをベクターに保存
                    pointPair tempPointPair;
                    tempPointPair.point1 = referencePoint;
                    tempPointPair.point2 = minimumDistancePoint;
                    
                    // 重複を許さない
                    if (!enableDuplicate) {
                        //再利用しないために、使用したPointを保存
                        usedOrNotVector[minimumDistancePoint.y*(int)image2.getWidth()+minimumDistancePoint.x] = true;
                    }
                    pointPairVectorForWriting.push_back(tempPointPair);
                }
            }
            ofLog(OF_LOG_NOTICE, "pointPairVectorForWriting done!");
            //<-- ペアのデータを作成
            ofLog(OF_LOG_NOTICE, "X1:"+ofToString(pointPairVectorForWriting[0].point1.x)+" Y1:"+ofToString(pointPairVectorForWriting[0].point1.y));
            ofLog(OF_LOG_NOTICE, "X2:"+ofToString(pointPairVectorForWriting[0].point2.x)+" Y2:"+ofToString(pointPairVectorForWriting[0].point2.y));
            exportFileForStruct(pointPairVectorForWriting);
            ofLog(OF_LOG_NOTICE, ofToString("writing file..."));
            saveToFile = false;
            ofLog(OF_LOG_NOTICE, "done");
        }
            break;
        default:
            break;
    }
}
Пример #28
0
//--------------------------------------------------------------
void testApp::setup()
{
    ofEnableAntiAliasing();
    //  set Video Size
    vidSize = ofVec2f(640, 480);
    ofSetFrameRate(30);
    //  initialize mouse point
    mouse_point = ofPoint(0,0);
    //  intialize video ID
    vidID = 0;
    //  initialize next Bot ID
    potential_bot_id = 0;
    //  initialized bot color number
    botColorNum = 0;
    
    //  set up message queue thread
    cout << "setting up ZMQ thread" << endl;
    zmqThread.start();

    
    //  initialize control booleans
    shouldBeginSendingBotInfo = shouldCaptureNewBot = shouldSetNewBackGround = false;
    shouldSetNewBackGround = true;
    
	#ifdef _USE_LIVE_VIDEO

        vidGrabber.setVerbose(true);
        vidGrabber.initGrabber(vidSize.x,vidSize.y);
        colorImg.allocate(vidSize.x,vidSize.y);
        grayImage.allocate(vidSize.x,vidSize.y);
        grayBg.allocate(vidSize.x,vidSize.y);
        grayDiff.allocate(vidSize.x,vidSize.y);
        ofSetWindowShape(vidSize.x,vidSize.y);


	#else
        vidPlayer.loadMovie("../GridDetectionNoText.mov");
        vidPlayer.play();
        colorImg.allocate(vidPlayer.width,vidPlayer.height);
        grayImage.allocate(vidPlayer.width,vidPlayer.height);
        grayBg.allocate(vidPlayer.width,vidPlayer.height);
        grayDiff.allocate(vidPlayer.width,vidPlayer.height);
        ofSetWindowShape(vidPlayer.width,vidPlayer.height);

	#endif

    //  add many colors to vector for random assignment later
    colors[0] = ofColor::green;
    colors[1] =ofColor::aqua;
    colors[2] =ofColor::maroon;
    colors[3] =ofColor::lightCoral;

    colors[4] =ofColor::cyan;
    colors[5] =ofColor::red;
    colors[6] =ofColor::lightBlue;
    colors[7] =ofColor::salmon;
    colors[8] =ofColor::blueViolet;
    colors[9] =ofColor::hotPink;
    colors[10] =ofColor::honeyDew;
    colors[11] =ofColor::yellow;
    colors[12] =ofColor::limeGreen;
    colors[13] =ofColor::orange;
    colors[14] =ofColor::indigo;
    colors[15] =ofColor::fuchsia;
    colors[16] =ofColor::crimson;
    colors[17] =ofColor::purple;


    // GUI setup
    gui.setup();
    gui.add(alterationsLabel.setup("Alternations\n", ""));
    gui.add(thresholdSlider.setup("Threshold", 45, 0, 255));
    gui.add(dilateSlider.setup("Dilation", 4, 0, 20));
    gui.add(autoFindBots.setup("Auto Find", false));

    gui.add(infoLabel.setup("Displayed Information\n", ""));
    gui.add(drawReportStringToggle.setup("Info Table", true));
    gui.add(drawBotRectToggle.setup("Rectangles", false));
    gui.add(drawBotIDToggle.setup("ID", false));
    gui.add(drawBotPathToggle.setup("Path", false));
    gui.add(drawAssociationToggle.setup("Association", true));

    gui.add(imageLabel.setup("Image\n", ""));
    gui.add(showColorImage.setup("Show Color"));
    gui.add(showGrayImage.setup("Show Gray"));
    gui.add(showSubtractedImage.setup("Show Subtracted Image"));
    gui.add(showBackgroundImage.setup("Show Background"));

    showColorImage.addListener(this, &testApp::showColorPressed);
    showGrayImage.addListener(this, &testApp::showGrayPressed);
    showBackgroundImage.addListener(this, &testApp::showBGPressed);
    showSubtractedImage.addListener(this, &testApp::showSubtractedPressed);

    showGUI = false;
}
Пример #29
0
//--------------------------------------------------------------
void ofApp::setup() {

#ifdef DEBUG

#else
    ofSetDataPathRoot("../Resources/data/");
#endif


    ofBackground(0);
    ofEnableAntiAliasing();

    gui.setup();
    gui.add(onOffInternet.setup("Connect Internet", false));

    sunName.load("NewMedia Fett.ttf", 20, true);
    sunName.setGlobalDpi(72);

    for (int i = 0; i < 512; i++) {
        amp[i] = 0;
        hertzScale[i] = 0;
        phases[i] = 0;
        sineBuffer[i] = sines[i];
        sineBufferLeft[i] = sines[i];
        sineBufferRight[i] = sines[i];
    }


    //    soundStream.printDeviceList();
    ofSoundStreamSettings settings;
    auto devices = soundStream.getMatchingDevices("default");
    if (!devices.empty()) {
        settings.setOutDevice(devices[1]);
    }
    settings.setOutListener(this);
    settings.bufferSize = INITIAL_BUFFER_SIZE;
    settings.sampleRate = SAMPLE_RATE;
    settings.numInputChannels = 0;
    settings.numOutputChannels = 2;
    soundStream.setup(settings);

    bPlaying = false;
    line = 0.1;


    maxHertz = 8000;
    minHertz = 150;

    astroidFBO.allocate(30, BIT, GL_RGB);

    // http://www.asterank.com/api
    string url = "http://asterank.com/api/asterank?query={\"e\":{\"$lt\":0.9},\"i\":{\"$lt\":2},\"a\":{\"$lt\":1.5}}&limit=1";

    // Now parse the JSON
    //    bool parsingInternetSuccessful = json(url);
    //    parsingInternetSuccessful = false;
    //    if (!parsingInternetSuccessful) {
    //        json.open("asteroid_500.json");
    //    } else {
    //        json.open(url);
    //    }


    threshold = 0.9;

    cam.setAutoDistance(false);
    cam.setDistance(400);

    //    if (parsingSuccessful) {
    //        ofLogNotice("ofApp::setup") << json.getRawString(true);
    //    } else {
    //        ofLogNotice("ofApp::setup") << "Failed to parse JSON.";
    //    }

    sun.set(2, 10);

    earthOrbit = setupEarthOrbit();

    orbits = setupOrbits("asteroid_500.json");

    drawTrackingLine.resize(orbits.size());

}
Пример #30
0
//--------------------------------------------------------------
void testApp::setup() {
	
	ofSetVerticalSync(true);
	ofBackgroundHex(0x000000);
	ofSetLogLevel(OF_LOG_NOTICE);
	ofEnableAntiAliasing();

	box2d.init();
	box2d.setGravity(0, 0);
	box2d.setFPS(30.0);

	isKeyPressed = false;
	isMousePressed = false;
	
	// add objects
	for (int i=0; i<200; i++) {
		// circulos
		addCircle(ofPoint(ofGetWidth()/2+ofRandom(100), ofGetHeight()/2+ofRandom(100)));
				  
		// rectangulos
		addBox(ofPoint(ofGetWidth()/2+ofRandom(100), ofGetHeight()/2+ofRandom(100)));
	}
	bAddCircle = false;
	bAddBox = false;
	
	ptoMed_circles = ptoMedio(circles);
	ptoMed_boxes = ptoMedio(boxes);
	
	bola.loadImage("images/dot.png");
	ladoPart1 = 5;
	ladoPart2 = 10;
	
	coloresBN.push_back(ofColor(0));
	coloresBN.push_back(ofColor(150));
	coloresBN.push_back(ofColor(255));
	
	bDraw4Forces = true;
	
	fRed = true;
	
	borde.clear();
	ofColor ctmp = ofColor::black;
	borde.setFillColor(ctmp);
	//http://www.openframeworks.cc/documentation/graphics/ofPath.html#show_setPolyWindingMode
	borde.setPolyWindingMode(OF_POLY_WINDING_ODD);
	// rectangulo 
	borde.rectangle(0,0,ofGetWidth(),ofGetHeight());
	borde.setCircleResolution(60);
	borde.circle(ofGetWidth()/2,ofGetHeight()/2,ofGetHeight()/2*0.95);
	
	
	// fbos
	fbo1.allocate(ofGetHeight()/2,ofGetHeight()/2);
	fbo2.allocate(ofGetHeight()/2,ofGetHeight()/2);
	fbo3.allocate(ofGetHeight()/2,ofGetHeight()/2);
	fbo4.allocate(ofGetHeight()/2,ofGetHeight()/2);
	
	fbo1.begin();	ofClear(255,255,255,0);	fbo1.end();
	fbo2.begin();	ofClear(255,255,255,0);	fbo2.end();
	fbo3.begin();	ofClear(255,255,255,0);	fbo3.end();
	fbo4.begin();	ofClear(255,255,255,0);	fbo4.end();	
	
	bDrawFbos = false;
	
}