ofToDataPath simplification

libs/openFrameworks/gl/ofCubeMap.cpp

@@ -383,30 +383,33 @@ bool ofCubeMap::load( ofCubeMapSettings aSettings ) {
 			// figure out the number of mip maps //
 			data->maxMipLevels = log2(data->settings.preFilterRes) + 1;
 
-			std::string encFolder = data->settings.cacheDirectory;
+			of::filesystem::path encFolder = data->settings.cacheDirectory;
 			if( !encFolder.empty() ) {
 				if( !ofDirectory::doesDirectoryExist( ofFilePath::removeTrailingSlash( data->settings.cacheDirectory ))) {
-					#if !defined(TARGET_OPENGLES)
+#if !defined(TARGET_OPENGLES)
 					if(!ofDirectory::createDirectory( data->settings.cacheDirectory )) {
 						ofLogWarning("ofCubeMap :: load : unable to create directory: ") << data->settings.cacheDirectory;
 					}
-					#endif
+#endif
 				} else {
 
 				}
 				// encFolder = ofFilePath::addTrailingSlash( data->settings.cacheDirectory ).string();
-				encFolder = ofFilePath::addTrailingSlash( data->settings.cacheDirectory );
+				//				encFolder = ofFilePath::addTrailingSlash( data->settings.cacheDirectory );
+
 			}
-			std::string baseName = ofFilePath::getBaseName( data->settings.filePath );
-			std::string cacheIrrName = baseName+"_irr_"+ofToString(data->settings.irradianceRes,0)+".exr";
-			std::string cachePrefilterName = baseName+"_pre_"+ofToString(data->settings.preFilterRes,0)+".exr";
+
+			// TODO: change everything to of::filesystem
+			of::filesystem::path baseName = ofFilePath::getBaseName( data->settings.filePath );
+			of::filesystem::path cacheIrrName = baseName / ("_irr_"+ofToString(data->settings.irradianceRes,0) + ".exr");
+			of::filesystem::path cachePrefilterName = baseName / ("_pre_"+ofToString(data->settings.preFilterRes,0)+".exr");
 
 			bool bHasCachedIrr = false;
 			bool bHasCachedPre = false;
 			if( data->settings.useCache && !data->settings.overwriteCache ) {
-				bHasCachedIrr = _loadIrradianceMap(encFolder+cacheIrrName);
+				bHasCachedIrr = _loadIrradianceMap(encFolder / cacheIrrName);
 				ofLogVerbose("ofCubeMap :: _loadIrradianceMap: ") << bHasCachedIrr;
-				bHasCachedPre = _loadPrefilterMap(encFolder+cachePrefilterName);
+				bHasCachedPre = _loadPrefilterMap(encFolder / cachePrefilterName);
 				ofLogVerbose("ofCubeMap :: _loadPrefilterMap: ") << bHasCachedPre;
 			}
 
@@ -418,12 +421,12 @@ bool ofCubeMap::load( ofCubeMapSettings aSettings ) {
 
 			if( !bHasCachedIrr ) {
 				ofLogVerbose("ofCubeMap :: going to create irradiance map");
-				_createIrradianceMap(cubeFid,bMakeCache, encFolder+cacheIrrName);
+				_createIrradianceMap(cubeFid,bMakeCache, encFolder / cacheIrrName);
 			}
 
 			if( !bHasCachedPre ) {
 				ofLogVerbose("ofCubeMap :: going to create pre filtered cube map");
-				_createPrefilteredCubeMap(cubeFid, srcCubeFSize,bMakeCache,encFolder+cachePrefilterName );
+				_createPrefilteredCubeMap(cubeFid, srcCubeFSize,bMakeCache,encFolder / cachePrefilterName );
 			}
 
 			glDeleteTextures(1, &cubeFid );
@@ -737,7 +740,7 @@ void ofCubeMap::_equiRectToCubeMap( GLuint& aCubeTexId, ofTexture& aSrcTex, int
 }
 
 //--------------------------------------------------------------
-void ofCubeMap::_createIrradianceMap(GLuint aSrcCubeFid, bool aBMakeCache, std::string aCachePath) {
+void ofCubeMap::_createIrradianceMap(GLuint aSrcCubeFid, bool aBMakeCache, of::filesystem::path aCachePath) {
 	if(data->bIrradianceAllocated) {
 		return;
 	}
@@ -878,7 +881,7 @@ void ofCubeMap::_createIrradianceMap(GLuint aSrcCubeFid, bool aBMakeCache, std::
 }
 
 //--------------------------------------------------------------
-bool ofCubeMap::_loadIrradianceMap(std::string aCachePath) {
+bool ofCubeMap::_loadIrradianceMap(of::filesystem::path aCachePath) {
 
 	if(data->bIrradianceAllocated) {
 		return false;
@@ -937,7 +940,7 @@ bool ofCubeMap::_loadIrradianceMap(std::string aCachePath) {
 }
 
 //--------------------------------------------------------------
-void ofCubeMap::_createPrefilteredCubeMap(GLuint aSrcCubeFid, int aSrcRes, bool aBMakeCache, std::string aCachePath) {
+void ofCubeMap::_createPrefilteredCubeMap(GLuint aSrcCubeFid, int aSrcRes, bool aBMakeCache, of::filesystem::path aCachePath) {
 	if(data->bPreFilteredMapAllocated) {
 		return;
 	}
@@ -1095,7 +1098,7 @@ void ofCubeMap::_createPrefilteredCubeMap(GLuint aSrcCubeFid, int aSrcRes, bool
 }
 
 //--------------------------------------------------------------
-bool ofCubeMap::_loadPrefilterMap( std::string aCachePath ) {
+bool ofCubeMap::_loadPrefilterMap( of::filesystem::path aCachePath ) {
 	if(data->bPreFilteredMapAllocated) {
 		return false;
 	}

libs/openFrameworks/gl/ofCubeMap.h

@@ -125,11 +125,11 @@ class ofCubeMap {
 	GLuint _createFloatCubeMap(ofTexture& aSrcTex, int aSrcRes);
 	void _equiRectToCubeMap( GLuint& aCubeTexId, ofTexture& aSrcTex, int aSrcRes, bool aBConvertToNonFloat );
 
-	void _createIrradianceMap(GLuint aSrcCubeFid, bool aBMakeCache, std::string aCachePath);
-	bool _loadIrradianceMap(std::string aCachePath);
+	void _createIrradianceMap(GLuint aSrcCubeFid, bool aBMakeCache, of::filesystem::path aCachePath);
+	bool _loadIrradianceMap( of::filesystem::path aCachePath );
 
-	void _createPrefilteredCubeMap(GLuint aSrcCubeFid, int aSrcRes, bool aBMakeCache, std::string aCachePath);
-	bool _loadPrefilterMap( std::string aCachePath );
+	void _createPrefilteredCubeMap(GLuint aSrcCubeFid, int aSrcRes, bool aBMakeCache, of::filesystem::path aCachePath);
+	bool _loadPrefilterMap( of::filesystem::path aCachePath );
 
 	static void _createBrdfLUT();
 

libs/openFrameworks/utils/ofFileUtils.cpp

@@ -26,24 +26,23 @@ namespace{
 	bool enableDataPath = true;
 
 	//--------------------------------------------------
-//	MARK: - near future
-//	of::filesystem::path defaultDataPath(){
-	std::string defaultDataPath(){
-	#if defined TARGET_OSX
-		try{
-			return of::filesystem::canonical(ofFilePath::getCurrentExeDir() / of::filesystem::path("../../../data/")).string();
-		}catch(...){
-			return (ofFilePath::getCurrentExeDir() / of::filesystem::path("../../../data/")).string();
-		}
-	#elif defined TARGET_ANDROID
-		return string("sdcard/");
-	#else
-		try{
-            return of::filesystem::canonical(ofFilePath::join(ofFilePath::getCurrentExeDir(),  "data/")).make_preferred().string();
-        }catch(...){
-			return (ofFilePath::getCurrentExeDir() / of::filesystem::path("data/")).string();
-		}
-	#endif
+	of::filesystem::path defaultDataPath(){
+#if defined TARGET_OSX
+
+	// three levels up because is a directory with path App.app/Contents/MacOS/App
+	of::filesystem::path data = ofFilePath::getCurrentExeDir().parent_path().parent_path().parent_path() / "data";
+	if (!of::filesystem::is_directory(data)) {
+		// bundle data folder inside app
+		// one level up : MacOS/../Resources/data
+		data = ofFilePath::getCurrentExeDir().parent_path() / "Resources/data";
+	}
+	return data;
+
+#elif defined TARGET_ANDROID
+	return { "sdcard/" };
+#else
+	return (ofFilePath::getCurrentExeDir() / "data");
+#endif
 	}
 
 	//--------------------------------------------------
@@ -1679,8 +1678,7 @@ string ofFilePath::addLeadingSlash(const of::filesystem::path& _path){
 }
 
 //------------------------------------------------------------------------------------------------------------
-//	MARK: - near future
-//of::filesystem::path ofFilePath::addTrailingSlash(const of::filesystem::path & _path){
+//	MARK: - Remove this function after FS transition
 std::string ofFilePath::addTrailingSlash(const of::filesystem::path & _path){
 #if OF_USING_STD_FS && !OF_USE_EXPERIMENTAL_FS
 	if(_path.string().empty()) return "";
@@ -1776,7 +1774,9 @@ std::string ofFilePath::getEnclosingDirectory(const of::filesystem::path & _file
 	if(bRelativeToData){
 		fp = ofToDataPath(fp);
 	}
-	return addTrailingSlash(fp.parent_path());
+
+//	return addTrailingSlash(fp.parent_path());
+	return fp.parent_path().string();
 }
 
 //------------------------------------------------------------------------------------------------------------
@@ -1854,10 +1854,9 @@ string ofFilePath::getCurrentExePath(){
 }
 
 //------------------------------------------------------------------------------------------------------------
-// MARK: - near future
-//of::filesystem::path ofFilePath::getCurrentExeDir(){
-std::string ofFilePath::getCurrentExeDir(){
-	return ofFilePath::getEnclosingDirectory(ofFilePath::getCurrentExePath(), false);
+of::filesystem::path ofFilePath::getCurrentExeDir(){
+	auto exePath = of::filesystem::path(getCurrentExePath());
+	return exePath.parent_path();
 }
 
 //------------------------------------------------------------------------------------------------------------
@@ -1927,22 +1926,9 @@ void ofSetDataPathRoot(const of::filesystem::path& newRoot){
 }
 
 //--------------------------------------------------
-// MARK: - near future
 //of::filesystem::path ofToDataPath(const of::filesystem::path & path, bool makeAbsolute){
 std::string ofToDataPath(const of::filesystem::path & path, bool makeAbsolute){
-	if (makeAbsolute && path.is_absolute()) {
-//		return path;
-		return path.string();
-	}
-
-	if (!enableDataPath) {
-//		return path;
-		return path.string();
-	}
-
-	bool hasTrailingSlash = !path.empty() && path.generic_string().back()=='/';
-
-	// if our Current Working Directory has changed (e.g. file open dialog)
+// if our Current Working Directory has changed (e.g. file open dialog)
 #ifdef TARGET_WIN32
 	if (defaultWorkingDirectory() != of::filesystem::current_path()) {
 		// change our cwd back to where it was on app load
@@ -1952,72 +1938,18 @@ std::string ofToDataPath(const of::filesystem::path & path, bool makeAbsolute){
 		}
 	}
 #endif
-
-	// this could be performed here, or wherever we might think we accidentally change the cwd, e.g. after file dialogs on windows
+	// FIXME: change to direct returns when return type is fs::path
+	of::filesystem::path outPath;
 	const auto & dataPath = dataPathRoot();
-	of::filesystem::path inputPath(path);
-	of::filesystem::path outputPath;
-
-	// if path is already absolute, just return it
-	if (inputPath.is_absolute()) {
-		try {
-			auto outpath = of::filesystem::canonical(inputPath).make_preferred();
-			if(of::filesystem::is_directory(outpath) && hasTrailingSlash){
-				return ofFilePath::addTrailingSlash(outpath);
-			}else{
-				return outpath.string();
-				// return outpath;
-			}
-		}
-		catch (...) {
-			return inputPath.string();
-			// return inputPath;
-		}
-	}
-
-	// here we check whether path already refers to the data folder by looking for common elements
-	// if the path begins with the full contents of dataPathRoot then the data path has already been added
-	// we compare inputPath.toString() rather that the input var path to ensure common formatting against dataPath.toString()
-	auto dirDataPath = dataPath;
-	// also, we strip the trailing slash from dataPath since `path` may be input as a file formatted path even if it is a folder (i.e. missing trailing slash)
-	dirDataPath = ofFilePath::addTrailingSlash(dataPath);
-
-	auto relativeDirDataPath = ofFilePath::makeRelative(of::filesystem::current_path(), dataPath);
-	relativeDirDataPath = ofFilePath::addTrailingSlash(relativeDirDataPath);
-
-	// FIXME: this can be simplified without using string conversion
-	// if (inputPath.string().find(dirDataPath.string()) != 0 && inputPath.string().find(relativeDirDataPath.string())!=0) {
-	if (inputPath.string().find(dirDataPath.string()) != 0 && inputPath.string().find(relativeDirDataPath)!=0) {
-		// inputPath doesn't contain data path already, so we build the output path as the inputPath relative to the dataPath
-		if(makeAbsolute){
-			outputPath = dirDataPath / inputPath;
-		}else{
-			outputPath = relativeDirDataPath / inputPath;
-		}
+	if (makeAbsolute) {
+		outPath = dataPath / path;
 	} else {
-		// inputPath already contains data path, so no need to change
-		outputPath = inputPath;
-	}
-
-	// finally, if we do want an absolute path and we don't already have one
-	if(makeAbsolute){
-		// then we return the absolute form of the path
-		try {
-			auto outpath = of::filesystem::canonical(of::filesystem::absolute(outputPath)).make_preferred();
-			if(of::filesystem::is_directory(outpath) && hasTrailingSlash){
-				return ofFilePath::addTrailingSlash(outpath);
-			}else{
-//				return outpath;
-				return outpath.string();
-			}
+		if (!path.is_absolute()) {
+			auto exeDir = ofFilePath::getCurrentExeDir();
+			outPath = of::filesystem::relative(dataPath / path, ofFilePath::getCurrentExeDir());
+		} else {
+			outPath = path;
 		}
-		catch (std::exception &) {
-		   return of::filesystem::absolute(outputPath).string();
-			// return of::filesystem::absolute(outputPath);
-		}
-	}else{
-		// or output the relative path
-//		return outputPath;
-		return outputPath.string();
 	}
+	return outPath.string();
 }

libs/openFrameworks/utils/ofFileUtils.h

@@ -314,8 +314,7 @@ class ofFilePath{
 	///
 	/// \param path directory path
 	/// \returns path + slash
-//	MARK: - near future
-//	static of::filesystem::path addTrailingSlash(const of::filesystem::path& path);
+//	MARK: - remove after fs transition
 	static std::string addTrailingSlash(const of::filesystem::path& path);
 
 	/// Remove a path's trailing slash (if found),
@@ -437,9 +436,7 @@ class ofFilePath{
 	/// Mac: the Contents/MacOS folder within the application's .app bundle
 	///
 	/// \returns current executable directory
-//	MARK: - near future
-//	static of::filesystem::path getCurrentExeDir();
-	static std::string getCurrentExeDir();
+	static of::filesystem::path getCurrentExeDir();
 
 	/// Get the absolute path to the user's home directory.
 	///