// oF < 0.8.1 does not have ofShader::getShaderSource, so we just cut // out some of the necessary code from ofShader to get the source in the // same way as ofShader::load did in version a90a782 (2014, April 10th.) // // Note that in this legacy mode, we don't support shader includes (as // ofShader does in 0.8.1). bool ofxFXObject::load(string path){ string vertName = path + ".vert"; string fragName = path + ".frag"; string frag = ""; string vert = ""; if (fragName.empty() == false){ ofBuffer buffer = ofBufferFromFile(fragName); frag = buffer.getText(); } if (vertName.empty() == false){ ofBuffer buffer = ofBufferFromFile(vertName); vert = buffer.getText(); } if (frag.empty() && vert.empty()){ ofLog(OF_LOG_ERROR, "Could not load shader from file " + path); return false; } bool loaded = setCode(frag, vert); if (loaded) shaderFilePath = path; return loaded; }
// --------------------------------------------------------------------------------------------------------------------------------------------------- // bool ofxAutoReloadedShader::load(string vertName, string fragName, string geomName) { unload(); ofShader::setGeometryOutputCount(geometryOutputCount); ofShader::setGeometryInputType(geometryInputType); ofShader::setGeometryOutputType(geometryOutputType); // hackety hack, clear errors or shader will fail to compile GLuint err = glGetError(); lastTimeCheckMillis = ofGetElapsedTimeMillis(); setMillisBetweenFileCheck( 2 * 1000 ); enableWatchFiles(); loadShaderNextFrame = false; vertexShaderFilename = vertName; fragmentShaderFilename = fragName; geometryShaderFilename = geomName; vertexShaderFile.clear(); fragmentShaderFile.clear(); geometryShaderFile.clear(); vertexShaderFile = ofFile( ofToDataPath( vertexShaderFilename ) ); fragmentShaderFile = ofFile( ofToDataPath( fragmentShaderFilename ) ); geometryShaderFile = ofFile( ofToDataPath( geometryShaderFilename ) ); ofBuffer vertexShaderBuffer = ofBufferFromFile( ofToDataPath( vertexShaderFilename ) ); ofBuffer fragmentShaderBuffer = ofBufferFromFile( ofToDataPath( fragmentShaderFilename ) ); ofBuffer geometryShaderBuffer = ofBufferFromFile( ofToDataPath( geometryShaderFilename ) ); fileChangedTimes.clear(); fileChangedTimes.push_back( getLastModified( vertexShaderFile ) ); fileChangedTimes.push_back( getLastModified( fragmentShaderFile ) ); fileChangedTimes.push_back( getLastModified( geometryShaderFile ) ); if( vertexShaderBuffer.size() > 0 ) { setupShaderFromSource(GL_VERTEX_SHADER, vertexShaderBuffer.getText() ); } if( fragmentShaderBuffer.size() > 0 ) { setupShaderFromSource(GL_FRAGMENT_SHADER, fragmentShaderBuffer.getText()); } #ifndef TARGET_OPENGLES if( geometryShaderBuffer.size() > 0 ) { setupShaderFromSource(GL_GEOMETRY_SHADER_EXT, geometryShaderBuffer.getText()); } #endif bindDefaults(); return linkProgram(); }
bool UIShader::reloadShader(string _fragPath, string _vertPath, string _geomPath){ ofShader::unload(); // hackety hack, clear errors or shader will fail to compile GLuint err = glGetError(); fragFile.clear(); fragFilename = ofToDataPath( _fragPath ); fragFile = ofFile( fragFilename ); fragChangedTimes = getLastModified( fragFile ); ofBuffer fragBuffer = ofBufferFromFile( fragFilename ); if( fragBuffer.size() > 0 ){ setupShaderFromSource(GL_FRAGMENT_SHADER, fragBuffer.getText()); } if (_vertPath != ""){ vertFile.clear(); vertFilename = ofToDataPath(_vertPath); vertFile = ofFile( vertFilename ); vertChangedTimes = getLastModified( vertFile ); ofBuffer vertBuffer = ofBufferFromFile( vertFilename ); if( vertBuffer.size() > 0 ){ setupShaderFromSource(GL_VERTEX_SHADER, vertBuffer.getText()); } bVertex = true; } if (_geomPath != ""){ geomFile.clear(); geomFilename = ofToDataPath(_geomPath); geomFile = ofFile( geomFilename ); geomChangedTimes = getLastModified( geomFile ); ofBuffer geomBuffer = ofBufferFromFile( geomFilename ); if( geomBuffer.size() > 0 ){ setupShaderFromSource(GL_GEOMETRY_SHADER, geomBuffer.getText()); } setGeometryInputType(geomInType); setGeometryOutputType(geomOutType); setGeometryOutputCount(geomOutCount); bGeometry = true; } lastTimeCheckMillis = ofGetElapsedTimeMillis(); if (linkProgram()){ extractUniforms(fragBuffer.getText()); return true; } else { return false; } }
Compiler::Compiler(ProcessTaskQueue& taskQueue, const std::string& pathToTemplates, const std::string& openFrameworksDir): _taskQueue(taskQueue), _pathToTemplates(pathToTemplates), _projectFileTemplate(ofBufferFromFile(ofToDataPath(_pathToTemplates + "/main.tmpl")).getText()), _classTemplate(ofBufferFromFile(ofToDataPath(_pathToTemplates + "/class.tmpl")).getText()), _openFrameworksDir(openFrameworksDir) { }
//-------------------------------------------------------------- void ofxEasyFboGlitch::draw(ofFbo _fbo,float _drawX,float _drawY,float _drawW,float _drawH){ fbo.begin(); ofSetColor(255); ofBackground(0); _fbo.draw(0,0,fboW,fboH); fbo.end(); if(glitchReset){ reader.readToPixels(fbo, pix); glitchImg.setFromPixels(pix); glitchReset=false; } string breakImgName="glitch.jpg"; glitchImg.saveImage(breakImgName,imgQuality); ofBuffer file= ofBufferFromFile(breakImgName); int fileSize=file.size(); char *buffer = file.getBinaryBuffer(); int whichByte=(int)ofRandom(fileSize); int whichBit =ofRandom(8); char bitMask = 1<< whichBit; buffer[whichByte] |= bitMask; ofBufferToFile(breakImgName,file); glitchImg.loadImage(breakImgName); if (ofRandom(1)<glitchResetProbability) { glitchReset=true; } glitchImg.draw(_drawX, _drawY, _drawW,_drawH); }
//-------------------------------------------------------------- void testApp::setup() { ofBackgroundHex(0xff72a1); ofSetFrameRate(30); nextLetterTime = ofGetElapsedTimeMillis(); lineCount = 0; letterCount = 0; // this is our buffer to stroe the text data ofBuffer buffer = ofBufferFromFile("ohplaces.txt"); if(buffer.size()) { // we now keep grabbing the next line // until we reach the end of the file while(buffer.isLastLine() == false) { // move on to the next line string line = buffer.getNextLine(); // copy the line to draw later // make sure its not a empty line if(line.empty() == false) { seussLines.push_back(line); } // print out the line cout << line << endl; } } }
void ofApp::setupFinderItems(){ // file -> buffer ofBuffer buffer = ofBufferFromFile("finderItems.txt"); // buffer -> vec2f if(buffer.size()) { while(buffer.isLastLine() == false) { string line = buffer.getNextLine(); if(line.empty() == false) { vector<string> words = ofSplitString(line, " "); FinderItem tmpItem = FinderItem(ofVec2f(ofToFloat(words[3]), ofToFloat(words[4]))); items.push_back(tmpItem); } } } // load end // debug info cout << "FinderItems size:" << items.size() << endl; for (int i=0; i<items.size(); i++) { cout << "item[" << i << "] " << items[i]._p.x << ":" << items[i]._p.y << endl; } }
//-------------------------------------------------------------- void ofApp::setup(){ ofBackground(100); ofSetColor(255); //Load TMX file ofBuffer buffer = ofBufferFromFile("example.tmx"); map->ParseText(buffer.getText()); //Check error if (map->HasError()) { printf("error code: %d\n", map->GetErrorCode()); printf("error text: %s\n", map->GetErrorText().c_str()); system("PAUSE"); return map->GetErrorCode(); } //Debug info printDebugInfo(); //Load images for (int i = 0; i < map->GetNumTilesets(); ++i) { //tileSheet.loadImage("tmw_desert_spacing.png"); tileSheets.push_back(ofImage()); (tileSheets.back()).loadImage( map->GetTileset(i)->GetImage()->GetSource().c_str() ); } }
//-------------------------------------------------------------- void testApp::setup(){ ofSetWindowTitle("Ailove-Instagram-Stat"); ofBackground(0); min_lat = 1e8; min_lng = 1e8; max_lat =-1e8; max_lng =-1e8; ofBuffer b = ofBufferFromFile("stat.csv"); b.getNextLine(); while (!b.isLastLine()) { string s = b.getNextLine(); int p = s.find(", "); if (p !=-1) { float lat = ofToFloat(s.substr(0, p)); float lng = ofToFloat(s.substr(p+2)); if(min_lat > lat) min_lat = lat; if(min_lng > lng) min_lng = lng; if(max_lat < lat) max_lat = lat; if(max_lng < lng) max_lng = lng; points.push_back(ofPoint(lat, lng)); } } img.allocate(4096, 4096,OF_IMAGE_COLOR_ALPHA); unsigned int* p1 = (unsigned int*) img.getPixels(); memset(p1, 0 , 4096*4096*4); lat_s = 4095.0/(max_lat - min_lat); lng_s = 4095.0/(max_lng - min_lng); for (int i=0; i<points.size(); i++) { ofPoint& p = points[i]; unsigned int px = (p.x-min_lat)*lat_s; unsigned int py = (p.y-min_lng)*lng_s; p1[px+4096*py] += 1; } img.saveImage("map.png"); // calc integral for(unsigned int i=1; i<4096; i++) { p1[i ] = p1[ i-1 ] + p1[i ]; p1[i*4096] = p1[(i-1)*4096] + p1[i*4096]; } for(unsigned int i=1; i<4096; i++) { for(unsigned int j=1; j<4096; j++) { p1[i+j*4096] = p1[(i-1) + j *4096] + p1[ i +(j-1)*4096] - p1[(i-1) +(j-1)*4096] + p1[ i + j *4096] ; } } img.update(); //splitRect(ofRectangle(0,0,4096,4096)); exportRectsAsJson(); }
void ofxBvh::load(string path) { path = ofToDataPath(path); string data = ofBufferFromFile(path).getText(); const size_t HIERARCHY_BEGIN = data.find("HIERARCHY", 0); const size_t MOTION_BEGIN = data.find("MOTION", 0); if (HIERARCHY_BEGIN == string::npos || MOTION_BEGIN == string::npos) { ofLogError("ofxBvh", "invalid bvh format"); return; } parseHierarchy(data.substr(HIERARCHY_BEGIN, MOTION_BEGIN)); parseMotion(data.substr(MOTION_BEGIN)); currentFrame = frames[0]; int index = 0; updateJoint(index, currentFrame, root); frame_new = false; }
void GlitchRect::update() { if (tempo < 100) { tempo = 100; } if (amp < 0) { amp = 0; } int icoin = int(coin); //if (int(ofRandom(icoin)) % icoin == 0) { if (int(ofGetElapsedTimef()*1000) % tempo < ofGetFrameRate()){ scale = ofRandom(2.0, 6.0); clipImage.grabScreen(pos.x + width/2 - width/scale/2, pos.y + height/2 - height/scale/2, width/scale, height/scale); clipImage.saveImage(compressedFilename, quality); ofBuffer file = ofBufferFromFile(compressedFilename, true); int fileSize = file.size(); char * buffer = file.getBinaryBuffer(); synth->set("lpf", amp*2000 + 80); for (int i = 0; i < ofRandom(1, 4); i++) { int whichByte = (int) ofRandom(fileSize * glitchStart, fileSize); int whichBit = ofRandom(8); char bitMask = 1 << whichBit; buffer[whichByte] |= bitMask; } ofBufferToFile(compressedFilename, file, true); clipImage.loadImage(compressedFilename); } }
//-----// void testApp::loadCalibration(){ ofBuffer buf = ofBufferFromFile("calibration", false); string s = buf.getNextLine(); skHratio = ofToFloat(s); s = buf.getNextLine(); skVratio = ofToFloat(s); s = buf.getNextLine(); skelHoffset = ofToFloat(s); s = buf.getNextLine(); skelVoffset = ofToFloat(s); s = buf.getNextLine(); spdWings = ofToFloat(s); s = buf.getNextLine(); hgtWings = ofToFloat(s); s = buf.getNextLine(); sclWings = ofToFloat(s); int _x = ofToInt(buf.getNextLine()); int _y = ofToInt(buf.getNextLine()); vout.move(_x,_y); }
void baseScene::loadCode( string fileName ){ ofBuffer buffer = ofBufferFromFile(fileName); code = ""; code += "// artwork by " + originalArtist + "\n"; code += "// re-coded by " + author + "\n"; code += "\n"; for (auto line : buffer.getLines()){ code += line; code += "\n"; } // Remove trailing newlines and spaces code.erase(std::find_if(code.rbegin(), code.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), code.end()); dataPath = ofFilePath::removeTrailingSlash(ofFilePath::getEnclosingDirectory(fileName)); bAnimateScene = true; bHasEndSet = false; if (ofFile(dataPath+"/paramsRecording.xml").exists()) { float duration; loadMidi(recData, &duration, dataPath+"/paramsRecording.xml"); cout << "got " << recData.size() << " events " << duration << endl; if (duration > 0) { setSceneEnd(duration); } } }
void ofApp::setupParameters() { //set up OSC controllable parameters from params.txt (which is in Max's goofy coll format for now) params.setName("params"); string params_text = ofBufferFromFile(ofToDataPath("../../src/params.txt")).getText(); vector<string> params_lines = ofSplitString(params_text, "\n"); if(params_lines.size()==1) params_lines = ofSplitString(params_text, "\r"); for(auto line:params_lines){ vector<string> param_tokens = ofSplitString(line, " "); if(param_tokens.size()<3) break; string param_name = param_tokens[1]; float param_val = atof(param_tokens[2].c_str()); params.add(ofParameter<float>().set(param_name, param_val)); cout<<"added OSC parameter "<<param_name<<" with initial value "<<param_val<<endl; } //set up parameters which are not floats and/or have callbacks separately for now //params.add(seed.set("seed",0)); //seed.addListener(this, &ofApp::initParams); params.add(forward_graph->params); //I don't really understand the role of ofxGui in managing ofParameters/ofParameterGroups, something to return to gui.setup(params); sync.setup((ofParameterGroup&)gui.getParameter(),local_port,remote_host,remote_port); }
Project::Project(const std::string& path): _path(path), _isLoaded(false) { // this is not efficient at all! I am just keeping these FileTemplate loads in the project // constructor because it makes the most sense architecure wise. _classFileTemplate = ofBufferFromFile(ofToDataPath("Resources/Templates/SketchTemplates/class.tmpl")).getText(); load(_path, getName()); }
void ofApp::setup() { pugi::xml_document doc; std::string buffer = ofBufferFromFile("message.xml").getText(); pugi::xml_parse_result result = doc.load(buffer.c_str()); if (result) { pugi::xml_node messageNode = doc.child("message"); ofLogNotice("ofApp::setup") << " To: " << messageNode.child("to").text().as_string(); ofLogNotice("ofApp::setup") << " From: " << messageNode.child("from").text().as_string(); ofLogNotice("ofApp::setup") << "Subject: " << messageNode.child("subject").text().as_string(); ofLogNotice("ofApp::setup") << " Body: " << messageNode.child("body").text().as_string(); } else { ofLogError("ofApp::setup") << "XML [" << buffer << "] parsed with errors."; ofLogError("ofApp::setup") << "Error description: " << result.description(); ofLogError("ofApp::setup") << "Error offset: " << result.offset << " (error at [..." << (result.offset) << "]"; ofLogNotice("ofApp::setup") << " Body: " << result.description(); } }
void ofApp::setup(){ // Comment this out... ------------------------- ofBuffer file = ofBufferFromFile("api_key.txt"); string apiKey = file; // --------------------------------------------- // ...and replace the apiKey variable with your own api key: -------------------------------- string apiUrl = "http://api.wunderground.com/api/" + apiKey + "/conditions/forecast10day/q/NY/New_York.json"; // ------------------------------------------------------------------------------------------ // /conditions/ returns the current weather only // /forecast1oday/ returns forecast for: current day's periods + next 10 days // Paste the url into firefox to better visualize the JSON response! if (!response.open(apiUrl)){ cout << "Failed to parse JSON" << endl; }else{ cout << "JSON loaded successfully" << endl; cout << "************************" << endl; // ofxJSON is doing all the heavy lifting of parsing the JSON // and allowing us to navigate through it. // City name is under response > current_observation > display_location > city cout << response["current_observation"]["display_location"]["city"].asString() << endl; // Current observation is under response > current_observation > temp_c or temp_f cout << "temperature in celsius now is: " << response["current_observation"]["temp_c"].asFloat() << endl; cout << "temperature in farenheit now is: " << response["current_observation"]["temp_f"].asFloat() << endl; } }
void ofApp::loadData(){ string data = ofBufferFromFile("bytebeat.txt").getText(); lastBeat = data; if (data.substr(0, 1) == "d" && bytebeats.size()>0) { int n = atoi(data.substr(1, data.length()).c_str()); if (n < bytebeats.size()) { bytebeats.erase(bytebeats.begin() + n); } } else { BytebeatGenerator *bg = new BytebeatGenerator(bufferSize, nChannels); bg->height = ofGetHeight(); bg->setup(); bg->time = time; bg->beat = data; bytebeats.push_back(bg); } /* data = data.substr(0, data.length()-1); vector<string> beatStr = split(data, ';'); bytebeats.clear(); for (int i = 0; i < beatStr.size(); i++) { BytebeatGenerator *bg = new BytebeatGenerator(bufferSize, nChannels); bg->height = ofGetHeight() / beatStr.size(); bg->setup(); bg->time = time; bg->beat = beatStr[i] + ";"; bytebeats.push_back(bg); } */ }
//-------------------------------------------------------------- void testApp::update(){ source.grabFrame(); pixels = source.getPixels(); // FFT stuff string compressedFilename = "compressed2.jpg"; img.saveImage(compressedFilename, quality); ofBuffer file = ofBufferFromFile(compressedFilename); int fileSize = file.size(); char * buffer = file.getBinaryBuffer(); int whichByte = (int) ofRandom(fileSize); int whichBit = ofRandom(20); char bitMask = 1 << whichBit; buffer[whichByte] |= bitMask; ofBufferToFile(compressedFilename, file); img.loadImage(compressedFilename); //end FFT stuff }
void Cinema::load(){ ofDirectory dir("cinema/"); dir.listDir(); vector<string> dirs; for(int i=0;i<dir.size();i++){ string d = dir.getPath(i); if(d.find("DB")!=string::npos){ vector<string> vids; vector<ofVideoPlayer*> ps; ofDirectory dir2(d); dir2.listDir(); for(int j=0;j<dir2.size();j++){ vector<double> scene; vector<string> movs; string vidpath = dir2.getPath(j); string origVidPath = vidpath; if(dir2.getName(j)[0] != '.' && (vidpath.find(".mov")!=string::npos || vidpath.find(".mp4")!=string::npos || vidpath.find(".avi")!=string::npos || vidpath.find(".3gp")!=string::npos || vidpath.find(".gif")!=string::npos || vidpath.find(".webm")!=string::npos || vidpath.find(".mkv")!=string::npos)){ vids.push_back(vidpath); playerPaths.push_back(vidpath); ofVideoPlayer* p = new ofVideoPlayer; playerIntensities.push_back(0); ps.push_back(p); string txtPath = vidpath; ofStringReplace(txtPath, ".mov", ".txt"); ofStringReplace(txtPath, ".mp4", ".txt"); ofStringReplace(txtPath, ".mkv", ".txt"); ofStringReplace(txtPath, ".webm", ".txt"); ofStringReplace(txtPath, ".avi", ".txt"); ofStringReplace(txtPath, ".gif", ".txt"); string t = ofBufferFromFile(txtPath).getText(); if(t.compare("")){ vector<string > splitted = ofSplitString(t, "\n"); for(int x=0;x<splitted.size();x++){ vector<string> line = ofSplitString(splitted[x]," "); scene.push_back(ofToDouble(line[0])); if(line.size()>1) movs.push_back((line[1])); else movs.push_back(" "); } ofFile vf(vidpath) ; string absoluteVidPath = vf.getAbsolutePath(); playerScenes[absoluteVidPath] = scene; playerScenesMovements[origVidPath] = movs; } } } strdb.push_back(vids); } } }
void ofxCcv::setup(string network) { string imagenetFilename = ofToDataPath(network); convnet = ccv_convnet_read(0, imagenetFilename.c_str()); ofBuffer buffer = ofBufferFromFile("image-net-2012.words"); for(auto line : buffer.getLines()) { words.push_back(line); } }
//-------------------------------------------------------------- void ofApp::recExportPressed(){ ofBuffer buf = ofBufferFromFile(tempAudio, true); string tempPath = "audio_" + ofToString(int(frames)) + "_" + ofToString(int(frameRate)) + ".wav"; ofFileDialogResult saveFileResult = ofSystemSaveDialog(tempPath, "Save your file"); if (saveFileResult.bSuccess){ bool fileWritten = ofBufferToFile(saveFileResult.filePath, buf); } }
//-------------------------------------------------------------- void ofApp::update(){ for (int i = 0; i < bytebeats.size(); i++) { bytebeats[i]->update(); } if (lastBeat != ofBufferFromFile("bytebeat.txt").getText()) { loadData(); } }
//-------------------------------------------------------------- bool ofShader::setupShaderFromFile(GLenum type, string filename) { ofBuffer buffer = ofBufferFromFile(filename); if(buffer.size()) { return setupShaderFromSource(type, buffer.getText()); } else { ofLog(OF_LOG_ERROR, "Could not load shader of type " + nameForType(type) + " from file " + filename); return false; } }
//-------------------------------------------------------------- void ofApp::setup(){ ofBackground(40, 100, 40); // open an outgoing connection to HOST:PORT sender.setup(HOST, PORT); imgAsBuffer = ofBufferFromFile("sendImageTest.jpg", true); }
//-------------------------------------------------------------- vector <ofDefaultVertexType> ofApp::loadPoints(const std::string& file) { vector <ofDefaultVertexType> pts; vector <string> ptsStr = ofSplitString(ofBufferFromFile(file).getText(), ","); for(int i=0; i<ptsStr.size(); i+=2) { float x = ofToFloat(ptsStr[i]); float y = ofToFloat(ptsStr[i+1]); pts.push_back(ofDefaultVertexType(x, y, 0)); } return pts; }
void ofApp::loadUUIDList(){ ofBuffer buffer = ofBufferFromFile("uuidList.txt"); string line; while (true){ line = buffer.getNextLine(); vector < string > str = ofSplitString(line, " "); uuidMapping[str[1]] = ofToInt(str[0]); if (buffer.isLastLine()) break; } }
void LedsManager::readLedsPosition() { int lineNumber = 0; int id = 0; bool upwards = false; for(int i = 1; i <= NUM_CHANNELS; i++) { string led_section_path = LEDS_LIST_PATH + "leds_" + ofToString(i) + ".txt"; ofBuffer buffer = ofBufferFromFile(led_section_path); if(buffer.size()) { while(buffer.isLastLine() == false) { string line = buffer.getNextLine(); ofPoint ledPosition; if(parseLedLine(line,ledPosition)) { if(ledPosition.z == 0) { upwards = !upwards; if (!upwards) { id = lineNumber + STRIP_SIZE - 1; } else{ id = lineNumber; } } else { createLed(ledPosition, id); if(upwards){ id++; } else{ id--; } lineNumber++; } } } } } }
void VisionRequestItem::setImage(const std::string& uri) { if (uri.substr(0, 5).compare("gs://") == 0) { _json["image"].clear(); _json["image"]["source"]["gcs_image_uri"] = uri; } else { setImage(ofBufferFromFile(uri)); } }
//-------------------------------------------------------------- void Interface::load( int index ) { string fileName = "presets/preset" + ofToString( index ) + ".txt"; string text = string( ofBufferFromFile( fileName ) ); vector<string> list = ofSplitString( text, " " ); if ( list.size() == slider.size() ) { for (int i=0; i<slider.size(); i++) { *slider[i].value = ofToFloat( list[i] ); } } }