//-------------------------------------------------------------- void testApp::setup(){ radius = 400; max = 60; glEnable(GL_DEPTH_TEST); //make sure we test depth for 3d ofSetVerticalSync(true); ofEnableLighting(); ofEnableAlphaBlending(); ofEnableSmoothing(); ofEnableBlendMode(ofBlendMode(OF_BLENDMODE_ALPHA)); mesh.addVertex(ofPoint(0,0,0)); // add center vertex mesh.addColor(ofColor(137,137,140,255)); // center is same as bg mesh.addNormal(ofVec3f(0,0,1)); // center normal points up zfreq = 3.; zamt = .3; //loop around and make verts in a circle, with a bit of a z-wave for (int i = 0; i < max; i++){ float step = 2*PI/max; // step size around circle float theta = ofMap(i, 0, max-1, 0, 2*PI - step); //map i as circle divisions to actual radian values around the circle (note we don't go quite all the way around by one step, because it will be the same as where we started, so we'll just index that starting vertex when we make faces) float prevTheta = theta - step; //one step back float nextTheta = theta + step; // one step forward // create vertices in polar coordinates, plus a sine wave for z ofVec3f p(radius*cos(theta),radius*sin(theta), radius*zamt*sin(zfreq*theta) ); // add this vertex mesh.addVertex(p); // we need these for calculating normals ofVec3f prev(radius*cos(prevTheta),radius*sin(prevTheta),radius*zamt*sin(zfreq*prevTheta) ); ofVec3f next(radius*cos(nextTheta),radius*sin(nextTheta),radius*zamt*sin(zfreq*nextTheta) ); // our normals for each triangle face is the cross product of the two vectors making up that sliver ofVec3f previousFaceNormal = prev.crossed(p); ofVec3f nextFaceNormal = p.crossed(next); /* notice here we go in the same direction: previous->current,current->next; we could similarly go next->current,current-prev, which would flip all of our normals; this might not be the best idea, but its certainly better than going previous->current,next->current, which would end up being quite awful. This is the concept of an "orientable mesh" or "face winding order", to be googled for more information. */ // since we want smooth normals, we'll sum the two adjacent face normals, then normalize (since usually, only the direction and not the magnitude of the normal is what matters) mesh.addNormal((previousFaceNormal + nextFaceNormal).normalize()); //add a color too ofColor c; c.setHsb(40 + 30*sin(2*theta+PI),255,255,255); mesh.addColor(c); } //index our verts/normals/colors as a triangle fan for (int i=0, j = max-1; i < max; j=i++){ mesh.addIndex(0); mesh.addIndex(i+1); mesh.addIndex(j+1); } // light the scene to show off why normals are important light.enable(); light.setPointLight(); light.setPosition(0,0,300); }
bool BarGraph::draw(unsigned int x,unsigned int y,unsigned int w,unsigned int h){ if( !initialized ) return false; if( data.size() == 0 || data.size() != numDimensions ) return false; ofPushMatrix(); ofEnableAlphaBlending(); ofTranslate(x, y); //Draw the background ofFill(); ofSetColor(backgroundColor[0],backgroundColor[1],backgroundColor[2]); ofRect(0,0,w,h); //Draw the grid if required if( drawGrid ){ ofSetColor(gridColor[0],gridColor[1],gridColor[2]); unsigned int numVLines = 20; unsigned int numHLines = 10; //Draw the horizontal lines for(unsigned int i=0; i<numHLines; i++){ float xStart = 0; float xEnd = w; float yStart = ofMap(i,0,numHLines,0,h); float yEnd = yStart; ofLine(xStart,yStart,xEnd,yEnd); } //Draw the vertical lines for(unsigned int i=0; i<numVLines; i++){ float xStart = ofMap(i,0,numVLines,0,w); float xEnd = xStart+1; float yStart = 0; float yEnd = h; ofLine(xStart,yStart,xEnd,yEnd); } } double barWidth = floor(w/(numDimensions+1.0)); double barSpacer = (w-(barWidth*numDimensions))/numDimensions; //Draw the axis lines ofSetColor(255,255,255); ofLine(-5,h,w+5,h); //X Axis ofLine(0,-5,0,h+5); //Y Axis //Draw the bars ofSetColor(barColor[0],barColor[1],barColor[2]); ofFill(); double x1 = barSpacer/2.0; double x2 = 0; double y1 = 0; double y2 = 0; double barHeight = 0; for(unsigned int n=0; n<numDimensions; n++){ if( minRanges[n] != maxRanges[n] ){ barHeight = ofMap(data[n],minRanges[n],maxRanges[n],1,h-1,constrainValuesToGraph); x2 = barWidth; y1 = 0 + h-barHeight-1; y2 = barHeight; ofRect(x1,y1,x2,y2); } x1 += barWidth + barSpacer; } ofDisableAlphaBlending(); ofPopMatrix(); return true; }
void ofApp::drawAlphabet(){ ofEnableAlphaBlending(); if (counterAlphabetsTitle<FRAME_RATE*introLength) { //facade title //blend in if(counterAlphabetsTitle<FRAME_RATE){ blendInfoFacade+=8; ofSetColor(255, 255, 255, blendInfoFacade); } //blend out else if(counterAlphabetsTitle>FRAME_RATE*(introLength-1)){ blendInfoFacade-=8; ofSetColor(255, 255, 255, blendInfoFacade); } else{ ofSetColor(255); } alphabetTitleFacade.draw(37, 259); //LED2 //blend in if(counterAlphabetsTitle<FRAME_RATE){ blendInfoLED2+=8; ofSetColor(255, 255, 255, blendInfoLED2); }else{ ofSetColor(255); } //title ofPushMatrix(); ofTranslate(508, 77); alphabetTitleLED2.draw(0,0); //draw entire alphabet for (int i=0; i<allAlphabet.size(); i++) { allAlphabet[i].drawWholeLED2(i); } ofPopMatrix(); } else if (counterDrawAlphabet<FRAME_RATE*alphabetLength) { //facade for (int i=0; i<NO_OF_ALPHABETS_RUNNING_THROUGH; i++) { allAlphabet[currImgNoAlphabet[i]].drawFacade(); } //LED //blend out if(counterDrawAlphabet>FRAME_RATE*(alphabetLength-1)){ blendInfoLED2-=8; ofSetColor(255, 255, 255, blendInfoLED2); } else{ ofSetColor(255); } //title ofPushMatrix(); ofTranslate(508, 77); //draw entire alphabet for (int i=0; i<allAlphabet.size(); i++) { allAlphabet[i].drawWholeLED2(i); } ofSetColor(255); alphabetTitleLED2.draw(0,0); ofPopMatrix(); }else{ //facade for (int i=0; i<NO_OF_ALPHABETS_RUNNING_THROUGH; i++) { allAlphabet[currImgNoAlphabet[i]].drawFacade(); } //LED2 for (int i=0; i<NO_OF_ALPHABETS_RUNNING_THROUGH_LED; i++) { //LED2 ofPushMatrix(); ofTranslate(508, 77); alphabetTitleLED2.draw(0,0); allAlphabet[currImgNoAlphabetLED2[i]].drawLED2(); ofPopMatrix(); } } ofDisableAlphaBlending(); }
void TextWriter::draw(ofRectangle box, string text, bool centred) { text = ofToUpper(text); // added these lines otherwise you get horribleness! if(box.height<=0) box.height = 1; if(box.width<=0) box.width = 1; ofPushStyle(); ofEnableAlphaBlending(); ofEnableBlendMode(OF_BLENDMODE_ADD); ofSetLineWidth(glyphLineWeight); ofPushStyle(); ofSetColor(10, 10, 255, 128); ofNoFill(); ofPopStyle(); float boxRatio = box.height / (float)box.width; int textLength = text.length(); string longestLine = ""; vector<string> lines; int numRows = (int)sqrt(boxRatio * textLength / glyphRatio); if( (text.find(' ') == string::npos) || (numRows == 0) ) { longestLine = trim(text); lines.push_back(longestLine); } else { int numCols = textLength / numRows; int start = numCols; int index = 0; int last; for( int row = 0; row < numRows - 1; row++ ) { last = index; index = findBestBreak(text, start, numCols * 2); string linePart = trim(text.substr(last, index - last)); if( linePart.length() > longestLine.length() ) { longestLine = linePart; } lines.push_back(linePart); start = index + numCols; } string linePart = trim(text.substr(index)); lines.push_back(linePart); if( linePart.length() > longestLine.length() ) { longestLine = linePart; } } float glyphScaleFactor = (box.width / (float)longestLine.length()) / (float)(glyphWidth + glyphSpacing); float glyphRenderWidth = glyphWidth * glyphScaleFactor; float glyphRenderHeight = glyphHeight * glyphScaleFactor; float glyphRenderSpacing = glyphSpacing * glyphScaleFactor; float marginTop = ((box.height - ((glyphRenderHeight + glyphRenderSpacing) * lines.size())) / 2.0); float marginLeft = 0; //(int)((box.width - calculateBlockWidth(longestLine, glyphRenderWidth, glyphRenderSpacing)) / 2.0); map <int, Letter>& letters = font.letters; ofMesh writingMesh; float ofsX = marginLeft, ofsY = marginTop; for( int j = 0; j < lines.size(); j++ ) { string line = lines[j]; float glyphMarginLeft = centred ? ((box.width - calculateBlockWidth(line, glyphRenderWidth, glyphRenderSpacing)) / 2.0) : 0; for( int i = 0; i < line.length(); i++ ) { addGlyphToMesh(letters[line[i]], ofRectangle(box.x + ofsX + glyphMarginLeft, box.y + ofsY, glyphRenderWidth, glyphRenderHeight), writingMesh); ofsX += glyphRenderWidth + glyphRenderSpacing; } ofsX = marginLeft; ofsY += glyphRenderHeight + glyphRenderSpacing; } writingMesh.setMode(OF_PRIMITIVE_LINES); writingMesh.draw(); writingMesh.setMode(OF_PRIMITIVE_POINTS); writingMesh.draw(); ofPopStyle(); return writingMesh; }
//-------------------------------------------------------------- SETING void testApp::setup(){ ofEnableAlphaBlending(); ofEnableSmoothing(); ofSetVerticalSync(false); open_flyout = false; //*** TRACKPAD SETUP ***// pad = ofxMultiTouchPad(); //*** CAMERA SETUP ***// cam.setDistance(600); cam.disableMouseInput(); cam.enableOrtho(); cam.setVFlip(true); scale = 1.f; //*** TOP MENU ***// menu = new ofxUISuperCanvas("menu", 0, MENU_TOP_PADDING, ofGetWidth(), MENU_HEIGHT); menu->getCanvasTitle()->ofxUIWidget::setVisible(false); menu->setColorBack(ofxUIColor(140, 140, 140,255)); ofxUISpacer* spacer; new menuItem(menu, "MultiImageButton", "New Patcher", "assets/new_file.png", false, 35, 20); new menuItem(menu, "MultiImageButton", "Open Patcher", "assets/open_file.png", false, 65, 20); new menuItem(menu, "MultiImageButton", "Save Patcher", "assets/save_file.png", false, 95, 20); spacer = new ofxUISpacer(130, 20, 1,25); menu->addWidget(spacer); spacer->setColorFill(ofxUIColor(120, 120, 120, 200)); new menuItem(menu, "MultiImageButton", "Create Node", "assets/node.png", false, 140, 20); spacer = new ofxUISpacer(175, 20, 1,25); menu->addWidget(spacer); spacer->setColorFill(ofxUIColor(120, 120, 120, 200)); new menuItem(menu, "MultiImageButton", "Save Snippet", "assets/save_snippet.png", false, 185, 20); new menuItem(menu, "MultiImageButton", "Open Snippet", "assets/open_snippet.png", false, 215, 20); spacer = new ofxUISpacer(250, 20, 1,25); menu->addWidget(spacer); spacer->setColorFill(ofxUIColor(120, 120, 120, 200)); new menuItem(menu, "MultiImageToggle", "Straight Links", "assets/line.png", false, 260, 20); new menuItem(menu, "MultiImageToggle", "Curved Links", "assets/curve_line.png", false, 290, 20); new menuItem(menu, "MultiImageToggle", "Segmented Links", "assets/path_line.png", true, 320, 20); spacer = new ofxUISpacer(355, 20, 1,25); menu->addWidget(spacer); spacer->setColorFill(ofxUIColor(120, 120, 120, 200)); new menuItem(menu, "MultiImageToggle", "Edit Mode on/off", "assets/edit_mode.png", false, 365, 20); ofAddListener(menu->newGUIEvent,this,&testApp::menuEvent); //*** RIGHT MENU ***// right_menu = new ofxUISuperCanvas("menu", 0, MENU_HEIGHT + MENU_TOP_PADDING, RIGHT_MENU_WIDTH, ofGetHeight() - (MENU_HEIGHT + MENU_TOP_PADDING)); right_menu->getCanvasTitle()->ofxUIWidget::setVisible(false); right_menu->setColorBack(ofxUIColor(140, 140, 140,255)); new menuItem(right_menu, "MultiImageButton", "Zoom In", "assets/zoom_in.png", false, 5, right_menu->getRect()->getHeight()-30); new menuItem(right_menu, "MultiImageButton", "Zoom Out", "assets/zoom_out.png", false, 5, right_menu->getRect()->getHeight()-60); new menuItem(right_menu, "MultiImageToggle", "Inspect", "assets/open_flyout.png", false, 5, right_menu->getRect()->getHeight()-100); ofAddListener(right_menu->newGUIEvent,this,&testApp::menuEvent); //*** MAIN CANVAS ***// gui = new ofxUISuperCanvas("", RIGHT_MENU_WIDTH, MENU_HEIGHT + MENU_TOP_PADDING, ofGetWidth() - RIGHT_MENU_WIDTH, ofGetHeight() - (MENU_HEIGHT +MENU_TOP_PADDING)); gui->setColorBack(ofxUIColor(255,255,255,0)); gui->setDraggable(false); gui->setOtherSelected(false); //*** COMPOSER AND PATCHES SETUP ***// composer = new ofxComposer(); composer->setMainCanvas(gui); composer->load("config.xml"); composer->setLinkType(PATH_LINKS); composer->setParent(cam); map<int,ofxPatch*> patches = composer->getPatches(); for(map<int,ofxPatch*>::iterator it = patches.begin(); it != patches.end(); it++ ){ it->second->setParent(cam); } //*** SCROLL BAR SETUP ***// this->scrollBars = new scrollBar(this->composer, &this->pad, SCROLL_BAR_EVENT_PRIORITY); scrollBars->setup(); }
/// \brief Callback de dessin /// /// \return void /// /// void Danseur::draw() { if(Dessinable()) { if(toBeDrawn) { ofPushStyle(); ofEnableAlphaBlending(); ofSetColor(255, 255, 255, Alpha() * 255); ofTrueTypeFont * text = _ttfText; if(bHugeText) { text = _ttfTextHuge; } float angleStep(0); float angle(0); if(Animable()) { angleStep = 360 / 5.0f; angle = ofRadToDeg(_coteAngle.getCurrentValue()) + _coteAngleOffset; } ofPushStyle(); ofPushMatrix(); ofTranslate(x, y); if(toBeDrawn & DANSEUR_TIME) { angle += angleStep; ofPushMatrix(); ofRotateZ(angle); text->drawString(_cote, offset(), 0); ofPopMatrix(); } if(Animable()) { if(toBeDrawn & DANSEUR_XPOS) { angle += angleStep; ofPushMatrix(); ofRotateZ(angle); text->drawString("x=" + ofToString(x), offset(), 0); ofPopMatrix(); } if(toBeDrawn & DANSEUR_YPOS) { angle += angleStep; ofPushMatrix(); ofRotateZ(angle); text->drawString("y=" + ofToString(y), offset(), 0); ofPopMatrix(); } if(toBeDrawn & DANSEUR_ANGLE) { angle += angleStep; ofPushMatrix(); ofRotateZ(angle); ofVec2f O(ofGetWidth() / 2.0f, ofGetHeight() / 2.0f); std::stringstream valeurAngle; valeurAngle << std::fixed << std::setprecision(2) << Tools::getAngle((*this), O); text->drawString("T=" + valeurAngle.str() + "°", offset(), 0); ofPopMatrix(); } if(toBeDrawn & DANSEUR_CONSTANTE) { angle += angleStep; ofPushMatrix(); ofRotateZ(angle); text->drawString("a=" + ofToString(M_PI), offset(), 0); ofPopMatrix(); } } ofPopMatrix(); ofDisableAlphaBlending(); ofPopStyle(); } } }
void ofApp::setup() { ofSetFrameRate(30); ofEnableAlphaBlending(); const std::string TWITTER_DATE_FORMAT = "%w %b %f %H:%M:%S %Z %Y"; std::string ts0 = "2000-01-01T12:00:00+01:00"; // Poco::DateTimeFormat::ISO8601_FORMAT std::string ts1 = "Wednesday, 1 Jan 20 12:00:00 GMT"; // Poco::DateTimeFormat::RFC1036_FORMAT std::string ts2 = "2018-01-01T17:00:00.000000+05:00"; // Poco::DateTimeFormat::ISO8601_FRAC_FORMAT std::string ts3 = "Tue Nov 12 23:14:54 +1100 2013"; // custom TWITTER_DATE_FORMAT int tzd0 = 0; int tzd1 = 0; int tzd2 = 0; int tzd3 = 0; Poco::DateTime min0; Poco::DateTime max0; Poco::DateTime min1; Poco::DateTime max1; try { // try to auto detect a known format min0 = Poco::DateTimeParser::parse(ts0, tzd0); // try to auto detect a known format max0 = Poco::DateTimeParser::parse(ts1, tzd1); // parse with a known format Poco::DateTimeParser::parse(Poco::DateTimeFormat::ISO8601_FRAC_FORMAT, ts2, min1, tzd2); // parse with a custom format Poco::DateTimeParser::parse(TWITTER_DATE_FORMAT, ts3, max1, tzd3); // we want to work with UTC time, rather than the local time parsed by // the Poco::DateTimeParser. it is easy to convert by simply calling // Poco::DateTimeParser::makeUTC() with the time zone difference (in seconds) // calculated by the parser. min0.makeUTC(tzd0); max0.makeUTC(tzd1); min1.makeUTC(tzd2); max1.makeUTC(tzd3); } catch (const Poco::SyntaxException& exc) { ofLogError("ofApp::setup()") << "Syntax exception: " << exc.displayText(); } // set up our ranges. the Time::Range::set() function will order the // Poco::Timestamps appropriately. interval0.set(min0.timestamp(), max0.timestamp()); interval1.set(min1.timestamp(), max1.timestamp()); std::string range0Min = Utils::format(interval0.getStart()); std::string range0Max = Utils::format(interval0.getEnd()); std::string range1Min = Utils::format(interval1.getStart()); std::string range1Max = Utils::format(interval1.getEnd()); ofLogNotice("ofApp::setup()") << "range0: " << range0Min << " - " << range0Max; ofLogNotice("ofApp::setup()") << "range1: " << range1Min << " - " << range1Max; }
void CloudsVisualSystemFireworks::selfDraw() { glPushAttrib(GL_ALL_ATTRIB_BITS); ofPushStyle(); ofEnableDepthTest(); glEnable(GL_NORMALIZE); ofEnableAlphaBlending(); ofBlendMode( OF_BLENDMODE_ADD ); ofEnablePointSprites(); vector<ofFloatColor> fireworkColorArray; for (map<string, ofColor>::iterator it=fwColors.begin(); it!=fwColors.end(); it++) { fireworkColorArray.push_back( ofFloatColor(it->second) ); } vector<ofFloatColor> fireworkDeathColorArray; for (map<string, ofColor>::iterator it=fwDeathColors.begin(); it!=fwDeathColors.end(); it++) { fireworkDeathColorArray.push_back( ofFloatColor(it->second) ); } shader.begin(); shader.setUniform4fv("fwColors", &fireworkColorArray[0].r, fireworkColorArray.size() ); shader.setUniform4fv("fwDeathColors", &fireworkDeathColorArray[0].r, fireworkDeathColorArray.size() ); shader.setUniform1f( "time", ofGetElapsedTimef() ); shader.setUniform1f( "nearClip", getCameraRef().getNearClip() ); shader.setUniform1f( "farClip", getCameraRef().getFarClip() ); shader.setUniform1f( "speed", speed); shader.setUniform1f( "particleSize", particleSize); shader.setUniform3f("cameraPosition", camPos.x, camPos.y, camPos.z ); ofFloatColor c0 = startColor; c0.setSaturation( startColorSaturation * 255 ); ofFloatColor c1 = endColor; c1.setSaturation( endColorSaturation * 255 ); shader.setUniform4f("startColor", c0.r, c0.g, c0.b, c0.a ); shader.setUniform4f("endColor", c1.r, c1.g, c1.b, c1.a ); shader.setUniform3f( "gravity", gravity.x, gravity.y, gravity.z ); shader.setUniformTexture("dotMap", dotImage.getTextureReference(), 4 ); shader.setUniformTexture("triangleMap", triangleImage.getTextureReference(), 3 ); shader.setUniformTexture("squareMap", squareImage.getTextureReference(), 2 ); shader.setUniformTexture("circleMap", circleImage.getTextureReference(), 1 ); shader.setUniform1f( "useCircleMap", bUseCircle ); shader.setUniform1f( "useSquareMap", bUseSquare ); shader.setUniform1f( "useTriangleMap", bUseTriangle ); shader.setUniform1f( "useDotMap", bUseDot ); ofVec3f camPos = getCameraRef().getPosition(); shader.setUniform3f("camearPosition", camPos.x, camPos.y, camPos.z); shader.setUniform1f("fogDistance", fogDistance); shader.setUniform1f("fogAttenuation", fogAttenuation); ofFloatColor fc = fogColor; fc.setSaturation(fogSaturation); shader.setUniform4f("fogColor", fc.r, fc.g, fc.b, fc.a ); vbo.drawElements( GL_POINTS, indexCount ); shader.end(); glPopAttrib(); ofPopStyle(); }
//-------------------------------------------------------------- void testApp::setup(){ ofEnableAlphaBlending(); ofSetFrameRate(60); particle_system.init(256, 132, 512, 512); }
//-------------------------------------------------------------- void testApp::draw(){ ofBackground(0); ofEnableAlphaBlending(); room.draw(); //bloom.begin(); glPushMatrix(); { ofSetupScreen(); glPushMatrix(); { glScalef((float)ofGetWidth()/(float)kinect.getWidth(), (float)ofGetHeight()/(float)kinect.getHeight(), 1); ofSetHexColor(0xFFFFFF); //for(int i = 0; i < meshes.size(); i++) { // meshes[i].draw(); //} /*brushFbo.begin(); ofEnableBlendMode(OF_BLENDMODE_ALPHA); glColor4f(0, 0, 0, backgroundAlpha); ofRect(0, 0, ofGetWidth(), ofGetHeight()); glColor4f(1,1,1,imageAlpha); ofEnableBlendMode(OF_BLENDMODE_ADD); if (usingAdd) { glBlendFunc(GL_SRC_ALPHA, GL_ONE); } else { glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); }*/ bloom.begin(); map<int,RibbonSkeleton>::iterator it; for(it = skeletons.begin(); it != skeletons.end(); it++) { (*it).second.draw(); } bloom.amount = ofMap(mouseX, 0, ofGetWidth(), 0, 1, true); bloom.end(); /*brushFbo.end(); ofEnableBlendMode(OF_BLENDMODE_ALPHA); glColor4f(1, 1, 1, 1); brushFbo.draw(0, 0);*/ } glPopMatrix(); glDisable(GL_DEPTH_TEST); } glPopMatrix(); //bloom.end(); //bloom.getOutput()->draw(0, ofGetHeight(), ofGetWidth(), -ofGetHeight()); glColor4f(1,1,1,1); glPushMatrix(); { ofSetupScreen(); // kinect.drawDebug(); gui.draw(); } glPopMatrix(); // output.getTextureReference(0).unbind(); }
//--------------------------------------------------------------------- draw void ofxSimpleGuiColorPicker::draw(float x, float y) { // enabled = true; //update postion of gui object setPos(x, y); glPushMatrix(); glTranslatef(x, y, 0); int startY = 0; for(int i=0; i<4; i++) { barwidth[i] = ofMap(getValue(i), 0, max, 0.0, (float)width); if(barwidth[i] > width) barwidth[i] = width; else if(barwidth[i] < 0) barwidth[i] = 0; ofEnableAlphaBlending(); ofFill(); setEmptyColor(); ofRect(0, startY, width, config->sliderTextHeight); if(max == 1){ switch(i) { case 0:glColor3f(getValue(i), 0, 0); break; case 1:glColor3f(0, getValue(i), 0); break; case 2:glColor3f(0, 0, getValue(i)); break; case 3:glColor3f(getValue(i), getValue(i), getValue(i)); break; } } else { switch(i) { case 0:ofSetColor(getValue(i), 0, 0); break; case 1:ofSetColor(0, getValue(i), 0); break; case 2:ofSetColor(0, 0, getValue(i)); break; case 3:ofSetColor(getValue(i), getValue(i), getValue(i)); break; } } ofRect(0, startY, barwidth[i], config->sliderTextHeight); int iover = (getMouseY() - y) / (config->sliderTextHeight); bool isOver = iover == i; if(isOver) { glColor3f(1, 1, 1); } else { glColor3f(0.5, 0.5, 0.5); } if (max == 1 && displayInteger) { ofDrawBitmapString(ofToString(getValue(i)*255, 0), 3, startY + 14); } else { if(max == 255){ ofDrawBitmapString(ofToString(getValue(i), 0), 3, startY + 14); } else { ofDrawBitmapString(ofToString(getValue(i), 4), 3, startY + 14); } } startY += config->sliderTextHeight; } ofFill(); setTextBGColor(); ofRect(0, startY, width, config->sliderTextHeight); if(max == 1){ glColor3f(getValue(0), getValue(1), getValue(2)); } else { ofSetColor(getValue(0), getValue(1), getValue(2)); } // ofRect(0, startY+config->sliderTextHeight, width, config->sliderTextHeight * 1.5); ofRect(150, startY + 3, width - 150 -3, config->sliderTextHeight - 8); setTextColor(); string s = name; ofDrawBitmapString(s, 3, startY + 14); ofDisableAlphaBlending(); glPopMatrix(); }
void ofxIndustrialRobotVisualizer::drawside(int x, int y, int w, int h){ sideView.setPosAndSize(x,y,w, h); float aspect = (float)ofGetWidth()/ofGetHeight(); //1.333... float aspect2 = (float)w/h; //1.0000 float mult = (float)aspect/aspect2; //Factor to multiply x coordinates with float scale = 0.17; // Same as to zoom ofxVec3f translate = ofxVec3f((ofGetWidth()/2.0)/mult-200, ofGetHeight()/2.0+200,0); if(sideView.click){ float cx = ((float)app->mouseX - x)/w; float cy = ((float)app->mouseY - y)/h; float a = atan2(controller->targetPosition.x,controller->targetPosition.z)-HALF_PI; ofxVec3f target = ofxVec3f((float)((cx*ofGetWidth()/(float)mult)-translate.x)/scale,(float) -((cy*ofGetHeight())-translate.y)/scale, 0.0); target.rotateRad(a, ofxVec3f(0.0,1.0,0.0)); controller->mousePressed(target); sideView.click = false; } glPushMatrix(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, (float)ofGetWidth(), 0.0, (float)ofGetHeight(), 10.0, 2500); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0, 0.0, 1000, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glScalef(1, -1, 1); // invert Y axis so increasing Y goes down. glViewport(x, ofGetHeight()- y-h, w, h); ofFill(); ofSetColor(255, 255, 0); glScaled(1.0*mult, 1.0, 1.0); glTranslated(0, -ofGetHeight(), 0); glPushMatrix(); ofEnableAlphaBlending(); ofFill(); ofSetColor(255, 255, 255, 50); ofRect(0, 0, ofGetWidth()/mult, ofGetHeight()); ofNoFill(); ofSetColor(255, 255, 255); ofRect(0, 0, ofGetWidth()/mult, ofGetHeight()); ofSetRectMode(1); glTranslated(translate.x, translate.y, 0); glScaled(scale, scale, scale); glRotated(-helper->getRotationAngle(0), 0.0,1.0,0.0); // Rotate it around the axis ofSetColor(0, 255, 0,255); /* for(int i=0;i<3000;i+=100){ for(int u=0;u<3000;u+= 100){ if(controller->legalPosition(ofxVec3f(i,u,0), controller->targetDir,0.0) || controller->legalPosition(ofxVec3f(i,u,0), controller->targetDir,1.0)) ofRect(i, -u, 100, 100); } }*/ drawGeneric(); ofFill(); glRotated(helper->getRotationAngle(0), 0.0,1.0,0.0); // Rotate it around the axis ofSetColor(255, 255, 255); ofLine(-1000, 0, 1000, 0); ofLine(0,-1000, 0, 1000); ofSetRectMode(0); glPopMatrix(); glViewport(0, 0, ofGetWidth(), ofGetHeight()); ofSetupScreen(); ofSetColor(255, 255, 255); ofDrawBitmapString("Side view", x+10, y+15); glPopMatrix(); }
void ofxIndustrialRobotVisualizer::drawtop(int x, int y, int w, int h){ topView.setPosAndSize(x,y,w, h); float aspect = (float)ofGetWidth()/ofGetHeight(); //1.333... float aspect2 = (float)w/h; //1.0000 float mult = (float)aspect/aspect2; //Factor to multiply x coordinates with float scale = 0.09; // Same as to zoom ofxVec3f translate = ofxVec3f((ofGetWidth()/2.0)/mult, ofGetHeight()/2.0,0); if(topView.click){ float cx = -(1.0- 2*((float)app->mouseX - x)/w); float cy = 1.0- 2*((float)app->mouseY - y)/h; float a1 = -atan2(cx,cy); float a2 = atan2(controller->targetPosition.x,controller->targetPosition.z)-HALF_PI; // controller->targetPosition = ofxVec3f(((cx*ofGetWidth()/mult)/scale)/2.0, controller->targetPosition.y, (cy*ofGetHeight()/scale)/2.0); ofxVec3f target = ofxVec3f((float)((cx*ofGetWidth()/mult)/scale)/2.0,(float) controller->targetPosition.y, -(float)(cy*ofGetHeight()/scale)/2.0); controller->mousePressed(target); topView.click = false; } glPushMatrix(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, (float)ofGetWidth(), 0.0, (float)ofGetHeight(), 10.0, 2500); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt(0.0, 0.0, 1000, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glScalef(1, -1, 1); // invert Y axis so increasing Y goes down. glViewport(x, ofGetHeight()- y-h, w, h); ofFill(); ofSetColor(255, 255, 0); glScaled(1.0*mult, 1.0, 1.0); glTranslated(0, -ofGetHeight(), 0); ofEnableAlphaBlending(); ofFill(); ofSetColor(255, 255, 255, 50); ofRect(0, 0, ofGetWidth()/mult, ofGetHeight()); ofNoFill(); ofSetColor(255, 255, 255); ofRect(0, 0, ofGetWidth()/mult, ofGetHeight()); ofSetRectMode(1); glTranslated(translate.x,translate.y, 0); glScaled(scale, scale, scale); glRotated(-90, 1.0, 0, 0.0); drawGeneric(); ofSetRectMode(0); glViewport(0, 0, ofGetWidth(), ofGetHeight()); ofSetupScreen(); ofSetColor(255, 255, 255); ofDrawBitmapString("Top view", x+10, y+15); glPopMatrix(); }
//-------------------------------------------------------------- void testApp::draw(){ //--------------------------- circles //let's draw a circle: ofSetColor(255,130,0); float radius = 50 + 10 * sin(counter); ofFill(); // draw "filled shapes" ofCircle(100,400,radius); // now just an outline ofNoFill(); ofSetHexColor(0xCCCCCC); ofCircle(100,400,80); // use the bitMap type // note, this can be slow on some graphics cards // because it is using glDrawPixels which varies in // speed from system to system. try using ofTrueTypeFont // if this bitMap type slows you down. ofSetHexColor(0x000000); ofDrawBitmapString("circle", 75,500); //--------------------------- rectangles ofFill(); for (int i = 0; i < 200; i++){ ofSetColor((int)ofRandom(0,255),(int)ofRandom(0,255),(int)ofRandom(0,255)); ofRect(ofRandom(250,350),ofRandom(350,450),ofRandom(10,20),ofRandom(10,20)); } ofSetHexColor(0x000000); ofDrawBitmapString("rectangles", 275,500); //--------------------------- transparency ofSetHexColor(0x00FF33); ofRect(400,350,100,100); // alpha is usually turned off - for speed puposes. let's turn it on! ofEnableAlphaBlending(); ofSetColor(255,0,0,127); // red, 50% transparent ofRect(450,430,100,33); ofSetColor(255,0,0,(int)(counter * 10.0f) % 255); // red, variable transparent ofRect(450,370,100,33); ofDisableAlphaBlending(); ofSetHexColor(0x000000); ofDrawBitmapString("transparency", 410,500); //--------------------------- lines // a bunch of red lines, make them smooth if the flag is set if (bSmooth){ ofEnableSmoothing(); } ofSetHexColor(0xFF0000); for (int i = 0; i < 20; i++){ ofLine(600,300 + (i*5),800, 250 + (i*10)); } if (bSmooth){ ofDisableSmoothing(); } ofSetHexColor(0x000000); ofDrawBitmapString("lines\npress 's' to toggle smoothness", 600,500); }
void ofxPolygonMask::draw(ofEventArgs &args) { if(points.size()==0) return; if(points.size()<4) checkWinding(); if(usingShader) { shader.begin(); shader.setUniformTexture("tex", *tex, 0); shader.setUniform1f("gamma", gamma); shader.setUniform1f("blendPower", blendPower); shader.setUniform1f("luminance", luminance); } ofFill(); ofSetColor(0, 0, 0); // do a normal fill of the inside ofBeginShape(); for(int i = 0; i < points.size(); i++) { ofVertex(points[i].x, points[i].y); } ofEndShape(true); calcBlendShape(); ofEnableAlphaBlending(); if(points.size()>0) { glBegin(GL_TRIANGLE_STRIP); for(int i = 0; i < points.size(); i++) { glColor4f(0, 0, 0, 1); glVertex2f(points[i].x, points[i].y); glColor4f(0, 0, 0, 0); glVertex2f(blendShape[i].x, blendShape[i].y); } glColor4f(0, 0, 0, 1); glVertex2f(points[0].x, points[0].y); glColor4f(0, 0, 0, 0); glVertex2f(blendShape[0].x, blendShape[0].y); glEnd(); } if(usingShader) { shader.end(); } if(editing) { ofNoFill(); ofSetHexColor(0xFF0000); // do a normal fill of the inside ofBeginShape(); for(int i = 0; i < points.size(); i++) ofVertex(points[i].x, points[i].y); ofEndShape(true); for(int i = 0; i < points.size(); i++) { if(i==focusedPoint) ofSetHexColor(0x00FF00); else ofSetHexColor(0xFF0000); ofCircle(points[i].x, points[i].y, DIST_POINT_GRAB); } ofSetHexColor(0xCC0000); ofBeginShape(); for(int i = 0; i < blendShape.size(); i++) ofVertex(blendShape[i].x, blendShape[i].y); ofEndShape(true); ofFill(); } }
void ofxKinectTracking::drawDepth(int x, int y, int w, int h){ ofSetColor(255, 255, 255); openCL.finish(); #ifndef NORMAL_CAMERA kinect->drawDepth(x,y,w,h); #else clImage[0].draw(x,y,w,h); #endif clImage[1].draw(x+w, y, w,h); ofSetColor(255, 0, 0); ofDrawBitmapString(ofToString(ofGetFrameRate(), 1), ofPoint(20,20)); ofEnableAlphaBlending(); glTranslated(0, 480*2, 0); float scale = 5000.0; { ofSetColor(255, 255, 255,100); double avg = 0; glBegin(GL_LINE_STRIP); for(int i=10;i<totalTime.size();i++){ glVertex2d(i*3, -totalTime[i]*scale); avg += totalTime[i]; } glEnd(); avg /=totalTime.size()-10; ofSetColor(255, 100, 255,255); ofLine(0, -avg*scale, 640*2, -avg*scale); ofDrawBitmapString("Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10)); double percentage = ((avg)/(1/30.0))*100; ofSetColor(255, 255, 255); ofDrawBitmapString("Time percentage of one frame used on openCL: "+ofToString(percentage, 2)+"%", ofPoint(5,-460)); } { ofSetColor(255, 0, 0,150); double avg = 0; glBegin(GL_LINE_STRIP); for(int i=10;i<killingTime.size();i++){ // cout<<totalTime[i]*10000.0<<endl; glVertex2d(i*3, -killingTime[i]*scale); avg += killingTime[i]; } glEnd(); avg /=killingTime.size()-10; ofSetColor(255, 100, 0); ofLine(0, -avg*scale, 640*2, -avg*scale); ofDrawBitmapString("K Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10)); } { ofSetColor(0, 255, 0,150); double avg = 0; glBegin(GL_LINE_STRIP); for(int i=10;i<spawningTime.size();i++){ // cout<<totalTime[i]*10000.0<<endl; glVertex2d(i*3, -spawningTime[i]*scale); avg += spawningTime[i]; } glEnd(); avg /=spawningTime.size()-10; ofSetColor(100, 255, 0); ofLine(0, -avg*scale, 640*2, -avg*scale); ofDrawBitmapString("S Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10)); } { ofSetColor(0, 0, 255,150); double avg = 0; glBegin(GL_LINE_STRIP); for(int i=10;i<updateTime.size();i++){ // cout<<totalTime[i]*10000.0<<endl; glVertex2d(i*3, -updateTime[i]*scale); avg += updateTime[i]; } glEnd(); avg /=updateTime.size()-10; ofSetColor(0, 100, 255); ofLine(0, -avg*scale, 640*2, -avg*scale); ofDrawBitmapString("U Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10)); } }
//-------------------------------------------------------------- void testApp::draw() { // ofBackground(10); ofSetColor(255, 255, 255, 255); bgImage.draw( 0, 0); glEnable(GL_DEPTH_TEST); ofEnableAlphaBlending(); // store the white highlights created from the lights in the fbo // later it will be blurred and then applied over the render lightFbo.begin(); ofClear(255, 255, 255, 0); // ofClear(0, 0, 0, 0); cam.begin(); ofSetColor(255, 255, 255); ofEnableLighting(); // glDepthMask(false); ofSetLineWidth(4.f); lightShader.begin(); lightShader.setUniform1f( "lightRadius", lightRadius ); lightShader.setUniform1i( "numLights", NUM_LIGHTS ); ofVec3f helixMidPt = h.getMidPoint(); lightShader.setUniform3fv("lightPoss", (float*)lightPoss, NUM_LIGHTS ); lightShader.setUniform1fv("lightRadiuss", (float*)lightRadiuss, NUM_LIGHTS ); glDepthMask(false); // ofEnableBlendMode(OF_BLENDMODE_ADD); ofSetColor(255); h.drawCentered(true, false); h.drawCentered( false, true ); glDepthMask(true); // ofDisableBlendMode(); ofDisableLighting(); lightShader.end(); // glDepthMask(true); // calculate distance and draw a particle image into the glow fbo // glDepthMask(false); ofEnableBlendMode(OF_BLENDMODE_ADD); dust.getTextureReference().bind(); ofSetColor(255, 255, 255, 255); float distance = 0; for(int i = 0; i < h.lines.size(); i++ ) { float closestDistance = 10000.f; float closestDistanceb = 10000.f; ofVec3f pos = h.lines[i].a - helixMidPt; ofVec3f posb = h.lines[i].b - helixMidPt; for(int j = 0; j < NUM_LIGHTS; j++ ) { ofVec3f lightPos = lights[j].getPosition(); distance = (lightPos - pos).length(); if(distance < closestDistance) closestDistance = distance; distance = (lightPos - posb).length(); if(distance < closestDistanceb) closestDistanceb = distance; } if(closestDistance < lightRadius) { float pct = 1.f - (closestDistance / lightRadius); if(pct >= .2f) { pct = ofMap(pct, 0.2f, 1.f, 0.f, 1.f, true); renderGlowParticle( pos, pct ); } } if(closestDistanceb < lightRadius) { float pct = 1.f - (closestDistanceb / lightRadius); if(pct >= .2f) { pct = ofMap(pct, 0.2f, 1.f, 0.f, 1.f, true); renderGlowParticle( posb, pct ); } } } dust.getTextureReference().unbind(); glDepthMask(true); ofDisableBlendMode(); cam.end(); lightFbo.end(); glDisable( GL_DEPTH_TEST ); ofSetColor(255); ofEnableAlphaBlending(); blur.begin(); // ofClear(255, 255, 255, 0); ofClear( 0, 0, 0, 255); lightFbo.draw(0, 0, lightFbo.getWidth(), lightFbo.getHeight() ); lightFbo.draw(0, 0, lightFbo.getWidth(), lightFbo.getHeight() ); blur.end(); ofSetLineWidth(2.f); cam.begin(); bool bDebugLights = ((ofxUIToggle*)gui->getWidget("Debug Lights"))->getValue(); if(bDebugLights) { ofSetColor(255, 255, 255); ofNoFill(); for(int i = 0; i < NUM_LIGHTS; i++ ) { ofPushMatrix(); { ofDrawArrow( ofPoint(0,0,0), ofPoint(1,0,0) ); ofTranslate( lights[i].getPosition() ); ofMatrix4x4 mat; mat.makeRotationMatrix(ofVec3f(0,0,1), cam.getLookAtDir() ); ofPushMatrix(); ofMultMatrix(mat.getPtr()); ofCircle(0, 0, lightRadiuss[i] ); ofPopMatrix(); } ofPopMatrix(); } ofFill(); } // ofSetColor(84,204,254); // h.drawCentered( true, false); // h.drawCentered( false, true ); ofSetColor(84,204,254); h.drawCentered( true, false); h.drawCentered( false, true ); cam.end(); // ofSetColor(255, 255, 255); // glDepthMask(false); // ofEnableBlendMode(OF_BLENDMODE_ADD); ofEnableAlphaBlending(); ofEnableBlendMode( OF_BLENDMODE_ADD ); // glBlendFunc(GL_SRC_COLOR, GL_ONE); ofSetColor(84,204,254); blur.getTextureReference().draw(0,768,1024,-768); ofSetColor(255, 255, 255, 255); blur.getTextureReference().draw(0,768,1024,-768); //// blur.getTextureReference().draw(0,768,1024,-768); ofSetColor(255, 255, 255, 40); // lightFbo.draw(0,768,1024,-768 ); ofDisableBlendMode(); // glDepthMask(true); bool bRenderFbos = ((ofxUIToggle*)gui->getWidget("Render FBOs"))->getValue(); if(bRenderFbos) { ofSetColor(0); ofRect(220, 20, ofGetWidth() * .25f, ofGetHeight() * .25f ); ofSetColor(255,255,255,255); lightFbo.draw(220, 20 + ofGetHeight() * .25, ofGetWidth() * .25, -ofGetHeight() * .25); } }
//-------------------------------------------------------------- void Particle::draw() { ofEnableAlphaBlending(); ofFill(); ofSetColor(color, alpha*255.0); ofCircle(pos, radius); }
//-------------------------------------------------------------- void ofApp::draw(){ ofEnableAlphaBlending(); float time = ofGetElapsedTimef(); float w = ofGetWidth(); float h = ofGetHeight(); fbo.begin(); //Draw something on the screen //Set a gradient background from white to gray //See "Sharp sphere example" in chapter "Creating in 3D with openFrameworks" ofBackgroundGradient( ofColor( 255 ), ofColor( 128 ) ); ofSetColor( 255, 255, 255 ); image.draw( 351, 221 ); fbo.end(); //Draw first image fbo2.begin(); ofBackground( 0, 0, 0 ); float ang = time * 30; //ang = 0; ofPushMatrix(); ofTranslate( w/2, h/2 ); ofRotate( ang ); ofFill(); ofSetColor( 255, 255, 255 ); ofTriangle( -200, -114, 200, -114, 0, 230 ); ofPopMatrix(); fbo2.end(); //Enable shader shader.begin(); //pass time value to shader shader.setUniform1f("time", time ); //we also pass in the mouse position //we have to transform the coords to what the shader is expecting which is 0,0 in the center and y axis flipped. //shader.setUniform2f("mouse", mouseX - ofGetWidth()/2, ofGetHeight()/2-mouseY ); shader.setUniformTexture( "texture1", fbo2.getTextureReference(), 1 ); //"1" means that it is texture 1 shader.setUniformTexture( "texture2", spectrumImage.getTextureReference(), 2 ); //"2" means that it is texture 2 //shader.setUniform1i( "N", N ); shader.setUniform1fv( "specArray", spectrum, N ); //Draw image through shader ofSetColor( 255, 255, 255 ); fbo.draw( 0, 0 ); //ofSetColor( 255, 255, 255, 128 ); //fbo2.draw( 0, 0 ); shader.end(); //Draw spectrum /* ofFill(); ofSetColor( 0, 255, 0 ); for (int i=0; i<N; i++) { ofRect( w/2 + i * 7, h/2, 7, -spectrum[i] * 100 ); } ofSetColor( 255, 255, 255 ); spectrumImage.draw( w/2, 0, N*7, 50 ); */ }
//-------------------------------------------------------------- void testApp::draw(){ glEnable(GL_DEPTH_TEST); // render the scene normally firstPass.begin(); ofEnableBlendMode(OF_BLENDMODE_ALPHA); ofClear(0); cam.begin(); ofPushMatrix(); ofTranslate(-2500, -4000, -5000); ofSetColor(255); sunImage.draw(0, 0, 2048, 2048); ofPopMatrix(); phong.begin(); phong.setUniform1i("useTex", 1); phong.setUniform3f("lightPos", -2, 3, -2); modelLoader.drawFaces(); phong.end(); cam.end(); firstPass.end(); // render the sun normally and the 'occluding objects' (tank) in black occluded.begin(); ofClear(0); cam.begin(); ofPushMatrix(); ofTranslate(-2500, -4000, -5000); ofSetColor(255); sunImage.draw(0, 0, 2048, 2048); ofPopMatrix(); ofSetColor(0); modelLoader.drawFaces(); ofSetColor(255); cam.end(); occluded.end(); lightRays.begin(); ofClear(0); scattering.begin(); scattering.setUniform1f("exposure", exposure); scattering.setUniform1f("decay", decay); scattering.setUniform1f("density", density); scattering.setUniform1f("weight", weight); scattering.setUniform2f("lightPositionOnScreen", lightPosition.x, lightPosition.y); scattering.setUniformTexture("firstPass", occluded, 0); glBegin(GL_QUADS); int x = 0; int y = 0; glTexCoord2f(x, y); glVertex2f(x, y); x = ofGetWidth(); glTexCoord2f(x, y); glVertex2f(x, y); y = ofGetHeight(); glTexCoord2f(x, y); glVertex2f(x, y); x = 0; glTexCoord2f(x, y); glVertex2f(x, y); glEnd(); scattering.end(); lightRays.end(); thresholdFbo.begin(); ofClear(0); thresholdShader.begin(); thresholdShader.setUniformTexture("tex0", firstPass, 0); thresholdShader.setUniform3f("thresholdRGB", threshR, threshG, threshB); thresholdShader.setUniform2f("dimensions", ofGetWidth(), ofGetHeight()); thresholdShader.setUniform1i("flipXY", 1); firstPass.draw(0, 0); thresholdShader.end(); thresholdFbo.end(); lensFlareFbo.begin(); ofClear(0); flareShader.begin(); flareShader.setUniformTexture("tex0", thresholdFbo, 0); flareShader.setUniform2f("dimensions", ofGetWidth(), ofGetHeight()); flareShader.setUniform1i("nSamples", samples); flareShader.setUniform1f("flareDispersal", flareDispersal); flareShader.setUniform1f("flareHaloWidth", flareHaloWidth); flareShader.setUniform3fv("flareChromaticDistortion", flareChromaticDistortion.getPtr()); thresholdFbo.draw(0, 0); flareShader.end(); lensFlareFbo.end(); blurredFbo.begin(); ofClear(0); blurShader.begin(blurAmount); lensFlareFbo.draw(0, 0); blurShader.end(); blurredFbo.end(); lensFlareFbo.begin(); ofClear(0); modulateTextureShader.begin(); modulateTextureShader.setUniformTexture("tex0", blurredFbo, 0); modulateTextureShader.setUniformTexture("tex1", dirtImage, 1); modulateTextureShader.setUniform2f("tex0dim", blurredFbo.getWidth(), blurredFbo.getHeight()); modulateTextureShader.setUniform2f("tex1dim", dirtImage.getWidth(), dirtImage.getHeight()); modulateTextureShader.setUniform1f("amount", dirtAmount); blurredFbo.draw(0, 0); modulateTextureShader.end(); lensFlareFbo.end(); ofEnableAlphaBlending(); glDisable(GL_DEPTH_TEST); lensFlareFbo.draw(0, 0); lightRays.draw(0, 0); firstPass.draw(0, 0); #ifdef SAVE_FRAMES ofSaveScreen("frames/"+ofToString(ofGetFrameNum(), 0)+".bmp"); #endif }
void ofApp::setup() { // SYSTEM ofSetLogLevel(OF_LOG_VERBOSE); ofHideCursor(); ofSetFrameRate(60); // SCREEN ofEnableAlphaBlending(); ofBackground(100); width = ofGetWindowWidth(); height = ofGetWindowHeight(); // STATE presenting = true; tooSunny = false; fboAge = 0; imageTimer = 0; imageMAX = 500; playState = 1; currentBrightness = 0; targetAlpha = 155; #ifdef INTERACTIVE // KINECT #ifdef KINECT kinect.setRegistration(true); kinect.init(); kinect.open(); if(kinect.isConnected()) { ofLogNotice() << "sensor-emitter dist: " << kinect.getSensorEmitterDistance() << "cm"; ofLogNotice() << "sensor-camera dist: " << kinect.getSensorCameraDistance() << "cm"; ofLogNotice() << "zero plane pixel size: " << kinect.getZeroPlanePixelSize() << "mm"; ofLogNotice() << "zero plane dist: " << kinect.getZeroPlaneDistance() << "mm"; } angle = 23; kinect.setCameraTiltAngle(angle); #else camera.setVerbose(true); camera.initGrabber(320, 240); #endif // CAPTURE SIZE int capture_width, capture_height; #ifdef KINECT capture_width = kinect.width; capture_height = kinect.height; #else capture_width = camera.width; capture_height = camera.height; #endif // OPENCV colorImg.allocate(capture_width, capture_height); grayImage.allocate(capture_width, capture_height); grayThreshNear.allocate(capture_width, capture_height); grayThreshFar.allocate(capture_width, capture_height); grayBg.allocate(capture_width, capture_height); grayDiff.allocate(capture_width, capture_height); closePoints.allocate(capture_width, capture_height, GL_RGBA32F_ARB); nearThreshold = 350; farThreshold = 112; bLearnBakground = true; threshold = 80; bThreshWithOpenCV = false; minBlob = 25; maxBlob = (capture_width * capture_height)/2; // FBO & GLSL SHADER setupGL(width, height); #else playState = 2; imageMAX = 2500; #endif // XML ASSETS BASEPATH = "../../../MEDIA/"; assets.loadFile("xml/assets.xml"); if( assets.loadFile("xml/assets.xml") ) { ofLog(OF_LOG_NOTICE, "Loaded xml file !!! \n"); loadFonts(); loadArtists(); loadAssets(); } else { ofLog(OF_LOG_ERROR, "UNABLE to load xml file :( \n"); } // INDEX currentIndex = 0; updateCurrentIndex(); // ASSETS brush.loadImage("mouse/brush.png"); stamp.loadImage("logo/stamp_white2.png"); demo.loadMovie(BASEPATH + "demo/studio_in_the_city_6_promo.mp4"); // MEMORY checkMemory(); cout << "Setup Is Done \n" << endl; }
//-------------------------------------------------------------- void testApp::setup(){ long size; char *buf; char *ptr; size = pathconf(".", _PC_PATH_MAX); if ((buf = (char *)malloc((size_t)size)) != NULL){ ptr = getcwd(buf, (size_t)size); } cout << ptr << endl; ofSetVerticalSync(true); ofEnableAlphaBlending(); parser.loadFromFiles(); visualSystems.loadPresets(); storyEngine.parser = &parser; storyEngine.visualSystems = &visualSystems; storyEngine.printDecisions = false; storyEngine.combinedClipsOnly = false; storyEngine.setup(); vector<CloudsClip*> startingNodes = parser.getClipsWithKeyword("#start"); srand(ofGetSeconds()); cout << "starting node size is " << startingNodes.size() << endl; ofRandomuf(); ofRandomuf(); ofRandomuf(); int startNode = ofRandomuf()*startingNodes.size(); cout << "START NODE index is " << startNode << endl; CloudsAct* act = storyEngine.buildAct(run, startingNodes[ startNode ]); run.topicHistory = act->getAllTopics(); run.clipHistory = act->getAllClips(); cout << "** TRAVERSAL INCLUDES:" << endl; for(int i = 0; i < run.clipHistory.size(); i++){ cout << " ** " << run.clipHistory[i]->getID() << endl; } // clusterMap.forceScreenResolution(1920, 1080); clusterMap.setup(); #ifdef OCULUS_RIFT if(CloudsVisualSystem::getOculusRift().isHD()){ clusterMap.loadPresetGUISFromName("FollowTraverse_OculusHD"); } else{ clusterMap.loadPresetGUISFromName("FollowTraverse_OculusSD"); } #else // clusterMap.loadPresetGUISFromName("FollowTraverse_Screen"); clusterMap.loadPresetGUISFromName("NavigationInterlude_Screen"); #endif clusterMap.setRun(run); clusterMap.setAct(act); clusterMap.buildEntireCluster(parser); clusterMap.allocateFlickerTexture(); // clusterMap.autoTraversePoints = true; clusterMap.populateDummyQuestions(); clusterMap.playSystem(); }
//-------------------------------------------------------------- void testApp::setup(){ ofEnableAlphaBlending(); ofEnableSmoothing(); ofSetLogLevel(OF_LOG_VERBOSE); ofSetVerticalSync(true); // Default Settings // mode = MODE_NORMAL; project = NULL; statusEnergy = 0; float margin = 64; string sketchName = "mySketch"; ofBackground(230,230,230); logo.loadImage("images/ofw-logo.png"); // XML Settings // ofxXmlSettings XML; XML.loadFile("settings/projectGeneratorSettings.xml"); appToRoot = XML.getValue("appToRoot", "../../../../"); defaultLoc = XML.getValue("defaultNewProjectLocation", "apps/myApps"); //------------------------------------- // calculate the bin path (../../../ on osx) and the sketch path (bin -> root - > defaultLoc) //------------------------------------- // if appToRoot is wrong, we have alot of issues. all these paths are used in this project: // #ifdef TARGET_OSX string binPath = ofFilePath::getAbsolutePath(ofFilePath::join(ofFilePath::getCurrentWorkingDirectory(), "../../../")); #else string binPath = ofFilePath::getCurrentExeDir(); #endif string ofRoot = ofFilePath::getAbsolutePath(ofFilePath::join(binPath, appToRoot)); addonsPath = ofFilePath::getAbsolutePath(ofFilePath::join(ofRoot,"addons")); string sketchPath = ofFilePath::getAbsolutePath(ofFilePath::join(ofRoot, defaultLoc)); convertWindowsToUnixPath(ofRoot); convertWindowsToUnixPath(addonsPath); convertWindowsToUnixPath(sketchPath); // there's some issues internally in OF with non unix paths for OF root // setOFRoot(ofRoot); //------------------------------------- GUI // // load font and setup the buttons // font.loadFont("fonts/Inconsolata.otf", 14, true,false,false,0.3,90); titleFont.loadFont("fonts/Inconsolata.otf", 28, true,false,false,0.3,90); secondFont.loadFont("fonts/Inconsolata.otf", 11, true,false,false,0.3,90); // Sketch button // textButton *buttonName = new textButton(); buttonName->font = &font; buttonName->secondFont = &secondFont; buttonName->prefix = "Name: "; buttonName->enableEditing(); buttonName->topLeftAnchor.set(margin+12, 160+40); //set top button position - others are set relative to this. buttonName->setText(sketchName); buttonName->secondaryText = "<< CLICK TO CHANGE THE NAME"; buttons.push_back(buttonName); // Path Button // textButton *buttonPath = new textButton(); buttonPath->font = &font; buttonPath->secondFont = &secondFont; buttonPath->topLeftAnchor.set(buttons[ buttons.size() -1 ]->topLeftAnchor.x, buttons[ buttons.size() -1 ]->topLeftAnchor.y + buttons[ buttons.size() -1 ]->height + 20); buttonPath->deliminater = "/"; buttonPath->prefix = "Path: "; buttonPath->setText(sketchPath); buttonPath->secondaryText = "<< CLICK TO CHANGE THE DIRECTORY"; buttons.push_back(buttonPath); // Platform Button // textButton *buttonPlat = new textButton(); buttonPlat->font = &font; buttonPlat->secondFont = &secondFont; buttonPlat->topLeftAnchor.set(buttons[ buttons.size() -1 ]->topLeftAnchor.x, buttons[ buttons.size() -1 ]->topLeftAnchor.y + buttons[ buttons.size() -1 ]->height + 20); buttonPlat->deliminater = ", "; buttonPlat->prefix = "Platforms: "; buttonPlat->secondaryText = "<< CLICK TO CHANGE THE PLATFORM"; buttonPlat->setText(""); buttons.push_back(buttonPlat); // Addons Button // textButton *buttonAddon = new textButton(); buttonAddon->font = &font; buttonAddon->secondFont = &secondFont; buttonAddon->topLeftAnchor.set(buttons[ buttons.size() -1 ]->topLeftAnchor.x, buttons[ buttons.size() -1 ]->topLeftAnchor.y + buttons[ buttons.size() -1 ]->height + 20); buttonAddon->deliminater = ", "; buttonAddon->prefix = "Addons: "; buttonAddon->secondaryText = "<< CLICK TO SELECT ADDONS"; buttonAddon->setText(""); buttons.push_back(buttonAddon); for (int i = 0; i < buttons.size(); i++){ buttons[i]->calculateRect(); } // Generate Button // generateButton.font = &font; generateButton.secondFont = &secondFont; generateButton.deliminater = ","; generateButton.prefix = "GENERATE PROJECT"; generateButton.setText(""); generateButton.bDrawLong = false; generateButton.topLeftAnchor.set(ofGetWidth() - buttons[0]->x - generateButton.width + 10 , ofGetHeight() - generateButton.height - 40); generateButton.calculateRect(); // Addon Button // backButton = generateButton; backButton.prefix = "BACK >>"; backButton.setText(""); backButton.bDrawLong = false; backButton.calculateRect(); // LOAD ADDONS // loadAddons(); // LOAD PLATFORMS // platformsList.set(64,12,350,500); platformsList.font = &font; platformsList.title = "Platforms"; platformsList.addElement("windows (codeblocks)",ofGetTargetPlatform()==OF_TARGET_WINGCC); platformsList.addElement("windows (visualStudio)", ofGetTargetPlatform()==OF_TARGET_WINVS); platformsList.addElement("linux (codeblocks)",ofGetTargetPlatform()==OF_TARGET_LINUX); platformsList.addElement("linux64 (codeblocks)",ofGetTargetPlatform()==OF_TARGET_LINUX64); //#define MAKE_IOS #ifdef MAKE_IOS platformsList.addElement("osx (xcode)",false); platformsList.addElement("ios (xcode)",true); #else platformsList.addElement("osx (xcode)",ofGetTargetPlatform()==OF_TARGET_OSX); platformsList.addElement("ios (xcode)",ofGetTargetPlatform()==OF_TARGET_IPHONE); #endif // update the platforms text in the platform button // buttons[2]->setText( platformsList.getSelectedAsString() ); }
//------------------------------- void ofxControlPanel::draw() { if( hidden ) return; ofPushStyle(); ofEnableAlphaBlending(); float panelH = boundingBox.height; if( minimize ) { panelH = 20; } 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, 20, boundingBox.width, 20); glPopMatrix(); ofRect(minimizeButton.x, minimizeButton.y, minimizeButton.width, minimizeButton.height); ofPushStyle(); ofFill(); if( saveDown )glColor4fv(fgColor.getSelectedColorF()); else glColor4fv(fgColor.getColorF()); ofRect(saveButton.x, saveButton.y, saveButton.width,saveButton.height); ofSetColor(255, 255, 255); if(bUseTTFFont) { guiTTFFont.drawString("save", saveButton.x + 3, saveButton.y + saveButton.height -4); } else { ofDrawBitmapString("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); if(bUseTTFFont) { guiTTFFont.drawString("restore", restoreButton.x + 3, restoreButton.y + restoreButton.height -4); } else { ofDrawBitmapString("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); 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]->render(); } glPopMatrix(); glDisable(GL_SCISSOR_TEST); } ofPopStyle(); }
//-------------------------------------------------------------- void testApp::draw() { ofNoFill(); ofSetColor(80,80,80); for (int i=0; i<2000; i+=snap) { ofLine(i,0,i,2000); ofLine(0,i,2000,i); } //draw groups ofEnableAlphaBlending(); for (int i=0; i<groups.size(); i++) { if (groups[i].active) { ofFill(); ofSetColor(50,50,50,50); ofRect(groups[i].rect); } } ofDisableAlphaBlending(); // clear stacking info stacks.clear(); for (int i=0; i<objects.size(); i++) { objects[i].stacked = false; } // draw the objects for (int i=0; i<objects.size(); i++) { // let's calculate stacking here... bool stacked = false; for (int j=0; j<i; j++) { if (i!=j) { if (objects[i].rect == objects[j].rect) { stacked = true; bool hit = false; for (int k=0; k<stacks.size(); k++) { if (stacks[k].rect == objects[i].rect) { if (!objects[i].stacked) { stacks[k].number++; } objects[i].stacked = true; hit = true; } } if (!hit) { stack s; s.rect = objects[i].rect; objects[i].stacked = true; stacks.push_back(s); } } } } if (stacked) { ofPoint p0 = ofPoint(objects[i].rect.x + 2, objects[i].rect.y + 2); ofPoint p1 = p0 + ofPoint(objects[i].rect.width, objects[i].rect.height); ofPoint A = p0; ofPoint B = ofPoint(p1.x, p0.y); ofPoint C = ofPoint(p1.x, p1.y-20); ofPoint D = ofPoint(p1.x-20, p1.y); ofPoint E = ofPoint(p0.x, p1.y); ofPoint F = ofPoint(p1.x-20, p1.y-20); ofFill(); switch (objects[i].type) { case 1: ofSetColor(255,251,176); break; case 2: ofSetColor(176,227,255); break; case 3: ofSetColor(255,211,176); break; default: ofSetColor(192,192,192); break; } ofBeginShape(); ofVertex(A); ofVertex(B); ofVertex(C); ofVertex(D); ofVertex(E); ofVertex(A); ofEndShape(); ofNoFill(); ofSetColor(32,32,32); ofBeginShape(); ofVertex(A); ofVertex(B); ofVertex(C); ofVertex(D); ofVertex(E); ofVertex(A); ofEndShape(); ofBeginShape(); ofVertex(C); ofVertex(D); ofVertex(F); ofVertex(C); ofEndShape(); } else { ofFill(); switch (objects[i].type) { case 1: ofSetColor(255,251,176); break; case 2: ofSetColor(176,227,255); break; case 3: ofSetColor(255,211,176); break; default: ofSetColor(192,192,192); break; } ofRect(objects[i].rect); ofNoFill(); ofSetColor(32,32,32); ofRect(objects[i].rect); } } // draw stack indicators for (int i=0; i<stacks.size(); i++) { if (stacks[i].number>1) { char buf[255]; sprintf(buf, "%d", stacks[i].number); int x = stacks[i].rect.x + stacks[i].rect.width - 30; int y = stacks[i].rect.y + stacks[i].rect.height - 4; ofSetColor(0,0,0); ofDrawBitmapString(buf, x, y); } } }
//-------------------------------------------------------------- void testApp::draw(){ ofFill(); ofSetColor(0xe0be21); //------(a)-------------------------------------- // // draw a star // // use poly winding odd, the default rule // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofSetPolyMode(OF_POLY_WINDING_ODD); // this is the normal mode ofBeginShape(); ofVertex(200,135); ofVertex(15,135); ofVertex(165,25); ofVertex(105,200); ofVertex(50,25); ofEndShape(); //------(b)-------------------------------------- // // draw a star // // use poly winding nonzero // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofSetColor(0xb5de10); ofSetPolyMode(OF_POLY_WINDING_NONZERO); ofBeginShape(); ofVertex(400,135); ofVertex(215,135); ofVertex(365,25); ofVertex(305,200); ofVertex(250,25); ofEndShape(); //------------------------------------- //------(c)-------------------------------------- // // draw a star dynamically // // use the mouse position as a pct // to calc nPoints and internal point radius // float xPct = (float)(mouseX) / (float)(ofGetWidth()); float yPct = (float)(mouseY) / (float)(ofGetHeight()); int nTips = 5 + xPct * 60; int nStarPts = nTips * 2; float angleChangePerPt = TWO_PI / (float)nStarPts; float innerRadius = 0 + yPct*80; float outerRadius = 80; float origx = 525; float origy = 100; float angle = 0; ofSetColor(0xa16bca); ofBeginShape(); for (int i = 0; i < nStarPts; i++){ if (i % 2 == 0) { // inside point: float x = origx + innerRadius * cos(angle); float y = origy + innerRadius * sin(angle); ofVertex(x,y); } else { // outside point float x = origx + outerRadius * cos(angle); float y = origy + outerRadius * sin(angle); ofVertex(x,y); } angle += angleChangePerPt; } ofEndShape(); //------------------------------------- //------(d)-------------------------------------- // // poylgon of random points // // lots of self intersection, 500 pts is a good stress test // // ofSetColor(0x0cb0b6); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); for (int i = 0; i < 10; i++){ ofVertex(ofRandom(650,850), ofRandom(20,200)); } ofEndShape(); //------------------------------------- //------(e)-------------------------------------- // // use sin cos and time to make some spirally shape // glPushMatrix(); glTranslatef(100,300,0); ofSetColor(0xff2220); ofFill(); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); float angleStep = TWO_PI/(100.0f + sin(ofGetElapsedTimef()/5.0f) * 60); float radiusAdder = 0.5f; float radius = 0; for (int i = 0; i < 200; i++){ float anglef = (i) * angleStep; float x = radius * cos(anglef); float y = radius * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(OF_CLOSE); glPopMatrix(); //------------------------------------- //------(f)-------------------------------------- // // ofCurveVertex // // because it uses catmul rom splines, we need to repeat the first and last // items so the curve actually goes through those points // ofSetColor(0x2bdbe6); ofBeginShape(); for (int i = 0; i < nCurveVertexes; i++){ // sorry about all the if/states here, but to do catmull rom curves // we need to duplicate the start and end points so the curve acutally // goes through them. // for i == 0, we just call the vertex twice // for i == nCurveVertexes-1 (last point) we call vertex 0 twice // otherwise just normal ofCurveVertex call if (i == 0){ ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we need to duplicate 0 for the curve to start at point 0 ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we need to duplicate 0 for the curve to start at point 0 } else if (i == nCurveVertexes-1){ ofCurveVertex(curveVertices[i].x, curveVertices[i].y); ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // to draw a curve from pt 6 to pt 0 ofCurveVertex(curveVertices[0].x, curveVertices[0].y); // we duplicate the first point twice } else { ofCurveVertex(curveVertices[i].x, curveVertices[i].y); } } ofEndShape(); // show a faint the non-curve version of the same polygon: ofEnableAlphaBlending(); ofNoFill(); ofSetColor(0,0,0,40); ofBeginShape(); for (int i = 0; i < nCurveVertexes; i++){ ofVertex(curveVertices[i].x, curveVertices[i].y); } ofEndShape(true); ofSetColor(0,0,0,80); for (int i = 0; i < nCurveVertexes; i++){ if (curveVertices[i].bOver == true) ofFill(); else ofNoFill(); ofCircle(curveVertices[i].x, curveVertices[i].y,4); } ofDisableAlphaBlending(); //------------------------------------- //------(g)-------------------------------------- // // ofBezierVertex // // with ofBezierVertex we can draw a curve from the current vertex // through the the next three vertexes we pass in. // (two control points and the final bezier point) // float x0 = 500; float y0 = 300; float x1 = 550+50*cos(ofGetElapsedTimef()*1.0f); float y1 = 300+100*sin(ofGetElapsedTimef()/3.5f); float x2 = 600+30*cos(ofGetElapsedTimef()*2.0f); float y2 = 300+100*sin(ofGetElapsedTimef()); float x3 = 650; float y3 = 300; ofFill(); ofSetColor(0xFF9933); ofBeginShape(); ofVertex(x0,y0); ofBezierVertex(x1,y1,x2,y2,x3,y3); ofEndShape(); ofEnableAlphaBlending(); ofFill(); ofSetColor(0,0,0,40); ofCircle(x0,y0,4); ofCircle(x1,y1,4); ofCircle(x2,y2,4); ofCircle(x3,y3,4); ofDisableAlphaBlending(); //------(h)-------------------------------------- // // holes / ofNextContour // // with ofNextContour we can create multi-contour shapes // this allows us to draw holes, for example... // ofFill(); ofSetColor(0xd3ffd3); ofRect(80,480,140,70); ofSetColor(0xff00ff); ofBeginShape(); ofVertex(100,500); ofVertex(180,550); ofVertex(100,600); ofNextContour(true); ofVertex(120,520); ofVertex(160,550); ofVertex(120,580); ofEndShape(true); //------------------------------------- //------(i)-------------------------------------- // // CSG / ofNextContour // // with different winding rules, you can even use ofNextContour to // perform constructive solid geometry // // be careful, the clockwiseness or counter clockwisenss of your multiple // contours matters with these winding rules. // // for csg ideas, see : http://glprogramming.com/red/chapter11.html // // info about the winding rules is here: // http://glprogramming.com/red/images/Image128.gif // ofNoFill(); glPushMatrix(); ofSetPolyMode(OF_POLY_WINDING_ODD); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glTranslatef(100,0,0); ofSetPolyMode(OF_POLY_WINDING_NONZERO); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glTranslatef(100,0,0); ofSetPolyMode(OF_POLY_WINDING_ABS_GEQ_TWO); ofBeginShape(); ofVertex(300,500); ofVertex(380,550); ofVertex(300,600); ofNextContour(true); for (int i = 0; i < 20; i++){ float anglef = ((float)i / 19.0f) * TWO_PI; float x = 340 + 30 * cos(anglef); float y = 550 + 30 * sin(anglef); ofVertex(x,y); radius += radiusAdder; } ofEndShape(true); glPopMatrix(); //------------------------------------- ofSetColor(0x000000); ofDrawBitmapString("(a) star\nwinding rule odd", 20,210); ofSetColor(0x000000); ofDrawBitmapString("(b) star\nwinding rule nonzero", 220,210); ofSetColor(0x000000); ofDrawBitmapString("(c) dynamically\ncreated shape", 420,210); ofSetColor(0x000000); ofDrawBitmapString("(d) random points\npoly", 670,210); ofSetColor(0x000000); ofDrawBitmapString("(e) fun with sin/cos", 20,410); ofSetColor(0x000000); ofDrawBitmapString("(f) ofCurveVertex\nuses catmull rom\nto make curved shapes", 220,410); ofSetColor(0x000000); ofDrawBitmapString("(g) ofBezierVertex\nuses bezier to draw curves", 460,410); ofSetColor(0x000000); ofDrawBitmapString("(h) ofNextContour\nallows for holes", 20,610); ofSetColor(0x000000); ofDrawBitmapString("(i) ofNextContour\ncan even be used for CSG operations\nsuch as union and intersection", 260,620); }
void ofApp::drawLetters(){ ofEnableAlphaBlending(); //first 5 seconds draw letters title if (counterLettersTitle<introLength*FRAME_RATE) { //draw title facade if(counterLettersTitle<FRAME_RATE){ blendInfoFacade+=8; ofSetColor(255, 255, 255, blendInfoFacade); } //blend out else if(counterLettersTitle>FRAME_RATE*(introLength-1)){ blendInfoFacade-=8; ofSetColor(255, 255, 255, blendInfoFacade); } else{ ofSetColor(255); } lettersTitleFacade.draw(37, 259); //draw title LED2 if(counterLettersTitle<FRAME_RATE){ blendInfoLED2+=8; ofSetColor(255, 255, 255, blendInfoLED2); }else{ ofSetColor(255); } ofPushMatrix(); ofTranslate(508, 77); lettersTitleLED2.draw(0,0); //draw letters LED already int noOfLetters=(int)allLetters.size(); if(noOfLetters>0){ allLetters[currLetterImgNo1].drawLED2(currLetterImgNo1); } if(noOfLetters>1){ allLetters[currLetterImgNo2].drawLED2(currLetterImgNo2); } if(noOfLetters>2){ allLetters[currLetterImgNo3].drawLED2(currLetterImgNo3); } if(noOfLetters>3){ allLetters[currLetterImgNo4].drawLED2(currLetterImgNo4); } if(noOfLetters>4){ allLetters[currLetterImgNo5].drawLED2(currLetterImgNo5); } ofPopMatrix(); } /*else if(counterLettersTitle==introLength*FRAME_RATE){ blendInfo=0; } */else{ //facade //blend in if(counterPostcardsAndLetters<FRAME_RATE){ blendInfoFacade+=8; ofSetColor(255, 255, 255, blendInfoFacade); } //blend out else if(counterPostcardsAndLetters>FRAME_RATE*(lengthLetters-1)){ blendInfoFacade-=8; ofSetColor(255, 255, 255, blendInfoFacade); } else{ ofSetColor(255); } //draw letters Sao Paulo int noOfLetters=(int)allLetters.size(); if(noOfLetters>0){ allLetters[currLetterImgNo1].drawFacade(currLetterImgNo1); } if(noOfLetters>1){ allLetters[currLetterImgNo2].drawFacade(currLetterImgNo2); } if(noOfLetters>2){ allLetters[currLetterImgNo3].drawFacade(currLetterImgNo3); } if(noOfLetters>3){ allLetters[currLetterImgNo4].drawFacade(currLetterImgNo4); } if(noOfLetters>4){ allLetters[currLetterImgNo5].drawFacade(currLetterImgNo5); } //draw title on LED2 //blend out if(counterPostcardsAndLetters>FRAME_RATE*(lengthLetters-1)){ blendInfoLED2-=8; ofSetColor(255, 255, 255, blendInfoLED2); } else{ ofSetColor(255); } ofPushMatrix(); ofTranslate(508, 77); //title LED2 lettersTitleLED2.draw(0,0); //draw letters LED if(noOfLetters>0){ allLetters[currLetterImgNo1].drawLED2(currLetterImgNo1); } if(noOfLetters>1){ allLetters[currLetterImgNo2].drawLED2(currLetterImgNo2); } if(noOfLetters>2){ allLetters[currLetterImgNo3].drawLED2(currLetterImgNo3); } if(noOfLetters>3){ allLetters[currLetterImgNo4].drawLED2(currLetterImgNo4); } if(noOfLetters>4){ allLetters[currLetterImgNo5].drawLED2(currLetterImgNo5); } ofPopMatrix(); } ofDisableAlphaBlending(); }
//-------------------------------------------------------------- void testApp::draw(){ // Main image ofSetColor(0xffffff); grayImage.draw(0, 0); ofSetColor(0x666666); ofDrawBitmapString(ofToString(artk.getNumDetectedMarkers()) + " marker(s) found", 10, 20); // Threshold image ofSetColor(0xffffff); grayThres.draw(640, 0); ofSetColor(0x666666); ofDrawBitmapString("Threshold: " + ofToString(threshold), 650, 20); ofDrawBitmapString("Use the Up/Down keys to adjust the threshold", 650, 40); // ARTK draw // An easy was to see what is going on // Draws the marker location and id number artk.draw(640, 0); // ARTK 2D stuff // See if marker ID '64' was detected // and draw blue corners on that marker only int myIndex = artk.getMarkerIndex(64); if(myIndex >= 0) { // Get the corners vector<ofPoint> corners; artk.getDetectedMarkerBorderCorners(myIndex, corners); // Can also get the center like this: // ofPoint center = artk.getDetectedMarkerCenter(myIndex); ofSetHexColor(0x0000ff); for(int i=0;i<corners.size();i++) { ofCircle(corners[i].x, corners[i].y, 10); } } // Homography // Here we feed in the corners of an image and get back a homography matrix ofMatrix4x4 Homography = artk.getHomography(myIndex, displayImageCorners); // We apply the matrix and then can draw the image distorted on to the marker ofPushMatrix(); glMultMatrixf(Homography.getPtr()); ofSetHexColor(0xffffff); colorImage.draw(0, 0); ofPopMatrix(); // ARTK 3D stuff // This is another way of drawing objects aligned with the marker // First apply the projection matrix once ofPushMatrix(); artk.applyProjectionMatrix(); // Find out how many markers have been detected int numDetected = artk.getNumDetectedMarkers(); ofEnableAlphaBlending(); // Draw for each marker discovered for(int i=0; i<numDetected; i++) { // Set the matrix to the perspective of this marker // The origin is in the middle of the marker artk.applyModelMatrix(i); // Draw a stack of rectangles by offseting on the z axis ofNoFill(); ofEnableSmoothing(); ofSetColor(255, 255, 0, 50); for(int i=0; i<10; i++) { ofRect(-25, -25, 50, 50); ofTranslate(0, 0, i*1); } } ofPopMatrix(); }
void movementLineDOFScene::draw(){ point3d * points = pointSet.points; ofEnableAlphaBlending(); glDisable(GL_DEPTH_TEST); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0); // super helpful: http://pmviewer.sourceforge.net/method.php glEnable(GL_POINT_SMOOTH); glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB); glPointSize(1); glPushMatrix(); glTranslatef(ofGetWidth()/2, ofGetHeight()/2,-2000); glRotatef(control.rotateY,-1,0,0); glRotatef(control.rotateX,0,1,0); //-------- // dofLineShader.begin(); glDisable(GL_DEPTH); glDisable(GL_DEPTH_TEST); float rgbBrightness = panel.getValueF("rgbBrightness"); float pointBrightness = panel.getValueF("point_brightness"); float aberration = panel.getValueF("aberration"); float aperture = panel.getValueF("aperture"); dofLineShader.setUniform("focusDistance", panel.getValueF("focus_offset")); dofLineShader.setUniform("aperture", aperture); dofLineShader.setUniform("pointBrightness", pointBrightness); dofLineShader.setUniform("rgbBrightness", rgbBrightness); dofLineShader.setUniform("maxPointSize", panel.getValueF("maxPointSize")); float v[4]; for(int i = 0; i < 144; i+= 2) { bool bInRun = false; for(int j = 0; j < 176; j++) { int n = (j + i * 176); if (points[n].bVisibleThisFrame == true){ if (bInRun == false){ bInRun = true; glBegin(GL_TRIANGLE_STRIP); } //ofSetColor(points[n].color.x * 255.0, points[n].color.y * 255.0, points[n].color.z * 255.0, 200.0); int n0 = n; glNormal3f(1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); glNormal3f(-1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); } else { if (bInRun == true){ glEnd(); bInRun = false; } } } if (bInRun == true){ glEnd(); bInRun = false; } } glTranslatef(-1500, 0, 0); for(int i = 0; i < 144; i+= 2) { bool bInRun = false; for(int j = 0; j < 176; j++) { int n = (j + i * 176); if (points[n].bVisibleThisFrame == true){ if (bInRun == false){ bInRun = true; glBegin(GL_TRIANGLE_STRIP); } //ofSetColor(points[n].color.x * 255.0, points[n].color.y * 255.0, points[n].color.z * 255.0, 200.0); int n0 = n; glNormal3f(1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); glNormal3f(-1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); } else { if (bInRun == true){ glEnd(); bInRun = false; } } } if (bInRun == true){ glEnd(); bInRun = false; } } glTranslatef(3000, 0, 0); for(int i = 0; i < 144; i+= 2) { bool bInRun = false; for(int j = 0; j < 176; j++) { int n = (j + i * 176); if (points[n].bVisibleThisFrame == true){ if (bInRun == false){ bInRun = true; glBegin(GL_TRIANGLE_STRIP); } //ofSetColor(points[n].color.x * 255.0, points[n].color.y * 255.0, points[n].color.z * 255.0, 200.0); int n0 = n; glNormal3f(1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); glNormal3f(-1,0,0); glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); glVertex3f(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); } else { if (bInRun == true){ glEnd(); bInRun = false; } } } if (bInRun == true){ glEnd(); bInRun = false; } } // // int step = 1; //(int)ofMap(sin(ofGetElapsedTimef()*20), -1,1, 1,8); // for(int i = 0; i < 144; i+= step) { // bool bInRun = false; // // // ofxVec3f upNormal; // ofxVec3f sideNormal; // // // glBegin(GL_TRIANGLE_STRIP); // // // // //glBegin(GL_LINE_STRIP); // for(int j = 0; j < 176-1; j++) { // int n0 = (j + i * 176); // int n1 = ((j+1) + i * 176); // // // // // // // //for(int i = 0; i < n-1; i++) { // // make left/bottom vertex // // // ofxVec3f diff = points[n1].pos - points[n0].pos; // diff.normalize(); // // //dofLineShader.setUniform("nextVertex", points[n1].pos.x, points[n1].pos.y, points[n1].pos.z); // // // //glVertexAttrib1f(side, -1); // //dofLineShader.setAttribute("nextVertex", 1.0f, 0.0f, 0.0f); // // v[0] = points[n0].color.x; // v[1] = points[n0].color.y; // v[2] = points[n0].color.z; // v[3] = 1.0; // // //ofSetColor(points[n].color.x*255.0,points[n].color.y*255.0,points[n].color.z*255.0, 160); // //glColor4fv(v); // // // // // glNormal3f(1,0,0); // glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); // glVertex3f(points[n0].pos.x, points[n0].pos.y, points[n0].pos.z); // // // //dofLineShader.setAttribute("sideAA", 1.0f); // glNormal3f(-1,0,0); // glColor4f(points[n0].color.x,points[n0].color.y,points[n0].color.z,1); // //glColor4fv(v); // //glTexCoord3f(points[n1].pos.x, points[n1].pos.y, points[n1].pos.z); // //dofLineShader.setUniform("sideAA", 3.0f); // //make right/top vertex // //glVertexAttrib1f(side, +1); // //glVertexAttrib3f(nextVertex, points[i+1].x, points[i+1].y, points[i+1].z); // glVertex3f(points[n0].pos.x, points[n0].pos.y, points[n0].pos.z); // // //} // // // // //// // a ////// b c d ////// e //// //// ofxVec3f ptsa[5]; //// ofxVec3f ptsb[5]; //// //// ofxVec3f pta; pta.set(points[n0].pos.x - pointSet.midPointSmoothed.x, points[n0].pos.y - pointSet.midPointSmoothed.y, points[n0].pos.z - pointSet.midPointSmoothed.z); //// ofxVec3f ptb; ptb.set(points[n1].pos.x - pointSet.midPointSmoothed.x, points[n1].pos.y - pointSet.midPointSmoothed.y, points[n1].pos.z - pointSet.midPointSmoothed.z); //// //// //printf("%f %f %f %f %f %f \n", pta.x, pta.x, pta.z, ptb.x, ptb.y, ptb.z); //// //// ofxVec3f diff = ptb-pta; //// diff.normalize(); //// ofxVec3f up; //// up.set(0,1,0); //// ofxVec3f side; //// side.set(0,0,1); //// //// //// ofxVec3f oldUpNormal; //// ofxVec3f oldSideNormal; //// if (j != 0){ //// oldUpNormal = upNormal; //// oldSideNormal = sideNormal; //// } //// //// ofxVec3f upNormal = diff.getCrossed(up); //// ofxVec3f sideNormal = diff.getCrossed(side); //// if (j == 0){ //// oldUpNormal = upNormal; //// oldSideNormal = sideNormal; //// } //// //// //// ptsa[0] = pta + upNormal *0.0; //// ptsa[1] = pta + sideNormal*0.0; //// ptsa[2] = pta; //// ptsa[3] = pta - sideNormal *0.0; //// ptsa[4] = pta - upNormal *0.0; //// //// //// ptsb[0] = ptb + upNormal *0.0; //// ptsb[1] = ptb + sideNormal*0.0; //// ptsb[2] = ptb; //// ptsb[3] = ptb - sideNormal *0.0; //// ptsb[4] = ptb - upNormal *0.0; //// //// //draw two quads. use color to represent which direction to distort this point! //// //// // ////// glBegin(GL_LINES); ////// glVertex3f(pta.x, pta.y, pta.z); ////// glVertex3f(ptb.x, ptb.y, ptb.z); ////// ////// glEnd(); //// //// glBegin(GL_QUADS); //// //// glNormal3f(oldSideNormal.x, oldSideNormal.y, oldSideNormal.z); //// glVertex3f(ptsa[1].x, ptsa[1].y, ptsa[1].z); //// //// glNormal3f(-oldSideNormal.x, -oldSideNormal.y, -oldSideNormal.z); //// glVertex3f(ptsa[3].x, ptsa[3].y, ptsa[3].z); //// //// glNormal3f(-sideNormal.x, -sideNormal.y, -sideNormal.z); //// glVertex3f(ptsb[3].x, ptsb[3].y, ptsb[3].z); //// //// glNormal3f(sideNormal.x, sideNormal.y, sideNormal.z); //// glVertex3f(ptsb[1].x, ptsb[1].y, ptsb[1].z); //// //// //// glEnd(); // // // //glBegin(GL_QUADS); //// //// glNormal3f(oldUpNormal.x, oldUpNormal.y, oldUpNormal.z); //// glVertex3f(ptsa[0].x, ptsa[0].y, ptsa[0].z); //// //// glNormal3f(-oldUpNormal.x, -oldUpNormal.y, -oldUpNormal.z); //// glVertex3f(ptsa[4].x, ptsa[4].y, ptsa[4].z); //// //// //// glNormal3f(-upNormal.x, -upNormal.y, -upNormal.z); //// glVertex3f(ptsb[4].x, ptsb[4].y, ptsb[4].z); //// //// glNormal3f(upNormal.x, upNormal.y, upNormal.z); //// glVertex3f(ptsb[0].x, ptsb[0].y, ptsb[0].z); //// //// glEnd(); //// // // // // //// //// //float pctz = ( points[n].pos.z - pointSet.bottom.z) / (pointSet.top.z - pointSet.bottom.z); //// //pctz = powf(pctz, 3.0); //// //int clr = ofMap(pctz, 0,1,50, 255); //// //// if (points[n].bVisibleThisFrame == true){ //// ofSetColor(200,200,200,100); //// glVertex3f(points[n].pos.x - pointSet.midPointSmoothed.x, points[n].pos.y - pointSet.midPointSmoothed.y, points[n].pos.z - pointSet.midPointSmoothed.z); //// //// } else { //// ofSetColor(200,200,200,100); //// glVertex3f(points[n].pos.x - pointSet.midPointSmoothed.x, points[n].pos.y - pointSet.midPointSmoothed.y, points[n].pos.z - pointSet.midPointSmoothed.z); //// //// //// } // // } // //glEnd(); // glEnd(); // // } dofLineShader.end(); //-------- ofEnableAlphaBlending(); ofSetColor(255,255,255,50); if (control.bDrawBox) ofxLineBox(pointSet.midpt.x - pointSet.midPointSmoothed.x, pointSet.midpt.y - pointSet.midPointSmoothed.y, pointSet.midpt.z- pointSet.midPointSmoothed.z, pointSet.top.x-pointSet.bottom.x, pointSet.top.y-pointSet.bottom.y, pointSet.top.z -pointSet.bottom.z); glPopMatrix(); glDisable(GL_DEPTH); glDisable(GL_DEPTH_TEST); panel.draw(); //flow.draw(176*3, 144*3); }
void ofx2DFormMapping::draw(bool show_source) { ofSetColor(42); ofFill(); ofDrawRectangle(this->getPosition().x, this->getPosition().y, this->getWidth(), this->getHeight()-2); ofxPanel::draw(); if(show_source) { //ofDrawRectangle(mapping_rect_src); if(source_bg) { ofSetColor(255,60); source_bg->draw( mapping_rect_src.x, mapping_rect_src.y, mapping_rect_src.width, mapping_rect_src.height); } else { ofSetColor(0,0,0,100); ofFill(); ofDrawRectangle(mapping_rect_src); } } ofEnableAlphaBlending(); ofSetLineWidth(2); //draw dst if(!direct_edit) { mapping_front.begin(); ofClear(0,0,0,0); ofTranslate(mapping_margin, mapping_margin); ofPushMatrix(); ofTranslate(-mapping_rect_dst.getPosition()); //ZOOM TRANSLATION translation_dst = zoom_point-zoom_point_scaled+zoom_point_offset; if(translation_dst.x > 0) translation_dst.x = 0; if(translation_dst.y > 0) translation_dst.y = 0; if(translation_dst.x < -addZoom(mapping_rect_dst.getWidth())+mapping_rect_dst.getWidth()) translation_dst.x = -addZoom(mapping_rect_dst.getWidth())+mapping_rect_dst.getWidth(); if(translation_dst.y < -addZoom(mapping_rect_dst.getHeight())+mapping_rect_dst.getHeight()) translation_dst.y = -addZoom(mapping_rect_dst.getHeight())+mapping_rect_dst.getHeight(); ofTranslate(translation_dst); ofSetColor(255,160); mapping_bg->draw( mapping_rect_dst.x, mapping_rect_dst.y, addZoom(mapping_rect_dst.width), addZoom(mapping_rect_dst.height)); } for (unsigned int i = 0; i < shapes.size(); i++) { // //draw dst rectangles // ofNoFill(); // ofSetColor(80,130,150); // ofBeginShape(); // for(unsigned int j = 0; j < shapes[i].dst.size(); j++) { // ofVertex(shapes[i].dst[j]); // } // ofEndShape(true); //draw shape lines and fillings for(int j = 0; j < 2; j++) { if(j == 0) { ofFill(); ofSetColor(shapes[i].color,40); } else { ofNoFill(); if(direct_edit) { ofSetColor(255); } else { ofSetColor(shapes[i].color,255); } } if(!(j == 0 && direct_edit)) { ofBeginShape(); for(unsigned int j = 0; j < shapes[i].polyline.size(); j++) { ofVertex(addZoom(shapes[i].polyline[j].x-mapping_rect_dst.x)+mapping_rect_dst.x, addZoom(shapes[i].polyline[j].y-mapping_rect_dst.y)+mapping_rect_dst.y); } ofEndShape(true); } } //draw dragging points ofSetColor(255,255,255,200); if(parent_projector->getMappingObject(i)->editable) { for(unsigned int j = 0; j < shapes[i].polyline.size(); j++) { if (shapes[i].polyline[j].bOver) ofFill(); else ofNoFill(); ofDrawCircle(addZoom(shapes[i].polyline[j]-mapping_rect_dst.getPosition())+mapping_rect_dst.getPosition(),6); } } } if(!direct_edit) { ofPopMatrix(); mapping_front.end(); mapping_front.draw(mapping_rect_dst.getPosition()-ofPoint(mapping_margin, mapping_margin), mapping_front.getWidth(), mapping_front.getHeight()); } //draw src for (unsigned int i = 0; i < shapes.size(); i++) { ofNoFill(); ofSetColor(shapes[i].color,255); ofBeginShape(); for(unsigned int j = 0; j < shapes[i].src.size(); j++) { ofVertex(shapes[i].src[j].x, shapes[i].src[j].y); } ofEndShape(true); //draw dragging points ofSetColor(255,255,255,200); if(parent_projector->getMappingObject(i)->editable) { for(unsigned int j = 0; j < shapes[i].src.size(); j++) { if (shapes[i].src[j].bOver) ofFill(); else ofNoFill(); if(j%2==0) ofDrawCircle(shapes[i].src[j].x, shapes[i].src[j].y,6); } } } }