cli version for sbsp export

Author: Coreforge

.github/workflows/cmake.yml

@@ -62,6 +62,7 @@ jobs:
         name: infiniteExplorer
         path: |
           ${{github.workspace}}/build/infiniteExplorer.exe
+          ${{github.workspace}}/build/infiniteExplorerCLI.exe
           ${{github.workspace}}/build/detex_LICENSE
       
     - name: Upload a Build Artifact (no FUSE)
@@ -72,4 +73,5 @@ jobs:
         name: infiniteExplorer_noFUSE
         path: |
           ${{github.workspace}}/build2/infiniteExplorer.exe
+          ${{github.workspace}}/build2/infiniteExplorerCLI.exe
           ${{github.workspace}}/build2/detex_LICENSE

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "yttrium"]
 	path = 3D/yttrium
 	url = [email protected]:Coreforge/yttrium.git
+[submodule "argparse"]
+	path = argparse
+	url = https://github.com/p-ranav/argparse

CMakeLists.txt

@@ -15,6 +15,7 @@ set(INFINITE_OODLE_DLL oo2core_8_win64.dll)
 set(FUSE ON)
 
 option(YTTRIUM_3D_VIEWER "Build the 3D viewer" ON)
+option(BUILD_CLI_VERSION "Build CLI" ON)
 
 
 ############################################################################
@@ -156,6 +157,10 @@ endif()
 
 target_include_directories(infiniteExplorer PUBLIC .)
 
+if(BUILD_CLI_VERSION)
+	add_subdirectory(argparse/)
+	include(cli/CMakeLists.txt)
+endif()
 
 
 

ModuleDisplayManager.cpp

@@ -152,6 +152,7 @@ void ModuleDisplayManager::loadPathRecursive(std::string path){
 
 	if (dirHandle == INVALID_HANDLE_VALUE) {
 		logger->log(LOG_LEVEL_WARNING,"Could not open %s\n", path.c_str());
+		return;
 	}
 
 	do {
@@ -197,6 +198,7 @@ void ModuleDisplayManager::loadPathRecursive(std::string path){
 	if(!dir){
 		// something went wrong opening the directory
 		logger->log(LOG_LEVEL_WARNING,"Failed to open %s\n",path.c_str());
+		return;
 	}
 	struct dirent* ent;
 	ent = readdir(dir);

argparse

@@ -0,0 +1,21 @@
+add_executable(infiniteExplorerCLI)
+
+target_link_libraries(infiniteExplorerCLI assimp)
+set_property(TARGET infiniteExplorerCLI PROPERTY CXX_STANDARD 20)
+
+# CLI source files
+
+target_sources(infiniteExplorerCLI PRIVATE ${CMAKE_CURRENT_LIST_DIR}/main.cpp)
+
+# the exporter code from the 3D folder has to be added separately, since it's compiled into the main executable
+target_sources(infiniteExplorerCLI PRIVATE 3D/ExporterBase.cpp)
+target_sources(infiniteExplorerCLI PRIVATE 3D/AssImpExporter.cpp)
+
+if(WIN32)
+	target_sources(infiniteExplorerCLI PRIVATE res/Icon.rc)
+endif()
+
+target_include_directories(infiniteExplorerCLI PUBLIC .)
+
+target_link_libraries(infiniteExplorerCLI Infinite)
+target_link_libraries(infiniteExplorerCLI argparse)

cli/CMakeLists.txt

@@ -0,0 +1,260 @@
+#include <argparse/argparse.hpp>
+#include <cstdio>
+#include <iostream>
+#include <string>
+#include <string.h>
+#include <vector>
+
+#include "main.h"
+
+#include <libInfinite/logger/ConsoleLogger.h>
+#include <libInfinite/tags/TagManager.h>
+
+#include <glm/gtc/quaternion.hpp>
+#include <glm/gtx/euler_angles.hpp>
+#include <glm/gtx/transform.hpp>
+
+#include <3D/AssImpExporter.h>
+
+
+#ifdef _WIN64
+#include <windows.h>
+#include <fileapi.h>
+//#include <direct.h>
+
+//#warning WIN64 detected
+#endif
+
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+int main(int argc, char* argv[]){
+	argparse::ArgumentParser parser("infinteExplorerCLI");
+
+	parser.add_argument("-d","--deploy").help("Path which is searched for module files")
+			.default_value<std::vector<std::string>>({}).append();
+	int verbosity = 0;
+	parser.add_argument("-V", "--verbose").help("increase logging verbosity").action([&](const auto &) {++verbosity;}).
+			append().default_value(false).implicit_value(true).nargs(0);
+
+	parser.add_argument("-i", "--globalid").help("global ID of the main tag to load. This is an unsigned 32bit number").scan<'i',uint32_t>();
+
+	parser.add_argument("-e", "--export").help("Export data from the tag. Currently only SBSP").default_value(false).implicit_value(true);
+
+	parser.add_argument("-o", "--output").help("Output path").default_value("--");
+
+	try{
+		parser.parse_args(argc, argv);
+	} catch(const std::runtime_error& err){
+		std::cerr << err.what() << std::endl;
+		std::cerr << parser;
+		return -1;
+	}
+
+	FILE* loggerfile;
+
+	if(parser.get<std::string>("-o") == "--"){
+		loggerfile = stderr;
+	} else {
+		loggerfile = stdout;
+	}
+
+	int generalLogLevel = std::max(LOG_LEVEL_ERROR - verbosity,0);
+	ConsoleLogger generalLogger(generalLogLevel, "", loggerfile);
+
+	int libInfLogLevel = std::max(LOG_LEVEL_ERROR - verbosity,0);
+	ConsoleLogger libInfLogger(libInfLogLevel,"[libInfinite] ", loggerfile);
+	ModuleManager modman(&libInfLogger);
+	TagManager tagman(&modman,&libInfLogger);
+
+	for(auto path : parser.get<std::vector<std::string>>("-d")){
+		loadPathRecursive(path, &libInfLogger, modman);
+	}
+
+	if(modman.modules.size() == 0){
+		generalLogger.log(LOG_LEVEL_CRITICAL, "No modules loaded! Aborting\n");
+		return -1;
+	}
+	generalLogger.log(LOG_LEVEL_INFO,"Loaded %d modules\n",modman.modules.size());
+	modman.buildNodeTree();
+
+	uint32_t globalId = 0;
+	bool globalIdSet = false;
+	if(auto id = parser.present<uint32_t>("--globalid")){
+		globalId = *id;
+		globalIdSet = true;
+	}
+
+	// check if this global ID exists, and get the associated item
+	if(modman.assetIdItems.contains(globalId) && globalIdSet){
+		if(parser.get<bool>("-e")){
+			Tag* tag = tagman.getTag(globalId);
+			if(modman.assetIdItems[globalId]->tagType == 'sbsp'){
+				if(exportBSP(dynamic_cast<sbspHandle*>(tag), parser.get<std::string>("-o"), &generalLogger)){
+					return -1;
+				}
+			}
+		}
+	} else if(globalIdSet) {
+		generalLogger.log(LOG_LEVEL_CRITICAL, "That global ID doesn't exist!\n");
+		return -1;
+	}
+
+}
+
+int exportBSP(sbspHandle* handle, std::string out, Logger* logger){
+	if(handle == nullptr){
+		logger->log(LOG_LEVEL_CRITICAL, "No BSP tag handle to export!\n");
+		return -1;
+	}
+	AssImpExporter exporter;
+	exporter.setLogger(logger);
+	exporter.newScene();
+
+	int c = handle->getGeoInstanceCount();
+	int f = 0;
+	int i;
+	for(i = 0; i < c; i++){
+		auto inst = handle->getGeoInstanceInfo(i);
+		if(inst.geo == nullptr){
+			// later, maybe add an error here (maybe like source?), but for now, just skip it
+			continue;
+		}
+		if(inst.mesh_flags_override & MESH_FLAGS_OVERRIDE_MESH_IS_CUSTOM_SHADOW_CASTER){
+			// just don't to anything with shadowcasters for now. Other wizards are allowed though.
+			continue;
+		}
+		f++;
+
+		auto meshdata = inst.geo->getMeshData(inst.meshIndex);
+
+		glm::mat3 meshrot_mat(meshdata.forward, meshdata.left, meshdata.up);
+		glm::mat4 meshposmat = glm::translate(meshdata.position);
+		glm::mat4 meshscalemat = glm::scale(meshdata.scale);
+		glm::mat4 meshtransform = meshposmat * glm::mat4(meshrot_mat) * meshscalemat;
+
+
+		glm::mat3 rot_mat(inst.forward, inst.left, inst.up);
+		//glm::mat3 rot_mat(glm::vec3(inst.up.x,inst.forward.x,inst.left.x), glm::vec3(inst.up.y,inst.forward.y,inst.left.y), glm::vec3(inst.up.z,inst.forward.z,inst.left.z));
+		//glm::mat3 rot_mat(inst.up, inst.forward, inst.left);
+		glm::mat4 bigrotmat(rot_mat);
+		//bigrotmat = glm::transpose(bigrotmat);
+		glm::vec3 rotation = glm::eulerAngles(glm::quat_cast(rot_mat));
+		rotation = glm::degrees(rotation);
+		glm::vec4 rotatedPos = glm::rotate(glm::radians(-90.0f), glm::vec3(1.0,0.0,0.0)) * glm::vec4(inst.position,1.0f);
+		//globalWindowPointer->viewer3D.addRenderGeo(&inst.geo->geoHandle, inst.meshIndex, inst.position, bigrotmat, -inst.scale); // glm::vec3(rotatedPos.x,rotatedPos.y,rotatedPos.z)
+		exporter.addRenderGeo(&inst.geo->geoHandle, inst.meshIndex, inst.position, rot_mat, inst.scale,"owo");
+	}
+	logger->log(LOG_LEVEL_INFO, "%d Instances in total, %d included in export (shadowcasters are excluded)\n", i, f);
+	exporter.exportScene(out);
+	return 0;
+}
+// duplicate code, since this is currently in ModuleDisplayManager, which is only used in the GUI
+
+void loadPathRecursive(std::string path, Logger* logger, ModuleManager& modMan){
+
+	// this has to be done differently on POSIX-compliant systems and /windows/ ...sigh
+
+#ifdef _WIN64
+	// windows version
+	WIN32_FIND_DATA find;
+	HANDLE dirHandle;
+
+	std::string searchPath = path + "/*";
+
+	dirHandle = FindFirstFile(searchPath.c_str(), &find);
+
+	if (dirHandle == INVALID_HANDLE_VALUE) {
+		logger->log(LOG_LEVEL_WARNING,"Could not open %s\n", path.c_str());
+		return;
+	}
+
+	do {
+		std::string cPath = path + "\\" + find.cFileName;
+		//printf("Found %s\n",cPath.c_str());
+		if (!(strncmp(find.cFileName, ".", 2) && strncmp(find.cFileName, "..", 3))) {
+			// . or .., skip those
+			continue;
+		}
+
+		if (find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+			// is a directory
+			//printf("This is a directory\n");
+			loadPathRecursive(cPath, logger, modMan);
+
+			// don't do the other stuff, which is only for files
+			continue;
+		}
+
+		// this is only for files
+
+		std::string name(find.cFileName);
+
+		// all of this can just be copied from the posix version
+		if (name.size() < 7) {
+			// name is too short
+			continue;
+		}
+		if (name.substr(name.size() - 7, 7) == ".module") {
+			// extension should match
+			if (modMan.addModule(cPath.c_str())) {
+				// the module couldn't be loaded
+				logger->log(LOG_LEVEL_ERROR,"Failed to load module %s, skipping!\n", cPath.c_str());
+			}
+		}
+
+
+	} while (FindNextFile(dirHandle,&find));
+#else
+	// the posix version
+	DIR* dir;
+	dir = opendir(path.c_str());	// open the current directory
+	if(!dir){
+		// something went wrong opening the directory
+		logger->log(LOG_LEVEL_WARNING,"Failed to open %s\n",path.c_str());
+		return;
+	}
+	struct dirent* ent;
+	ent = readdir(dir);
+	struct stat buf;
+	while(ent){
+		// for every entry
+		std::string cPath = path + "/" + ent->d_name;
+		if(stat(cPath.c_str(),&buf)){
+			// something went wrong with stat
+			// report the error and just skip this entry
+			logger->log(LOG_LEVEL_WARNING,"Failed to stat %s!\n",cPath.c_str());	// warning because it might not be an actual issue
+			goto next;	// skip to the next entry
+			continue;
+		}
+		if(S_ISDIR(buf.st_mode)){
+			// another directory, check that one too
+			if(strncmp(ent->d_name,".",2) && strncmp(ent->d_name,"..",3)){
+				//printf("Looking in %s\n",cPath.c_str());
+				loadPathRecursive(cPath, logger, modMan);
+			}
+
+		}
+		if(S_ISREG(buf.st_mode)){
+			// regular file, but that doesn't mean it's a module
+			// first check the file extension (.module, the last 7 characters of the name)
+			std::string name(ent->d_name);
+			if(name.size() < 7){
+				// name is too short
+				goto next;
+			}
+			if(name.substr(name.size() - 7, 7) == ".module"){
+				// extension should match
+				if(modMan.addModule(cPath.c_str())){
+					// the module couldn't be loaded
+					logger->log(LOG_LEVEL_ERROR,"Failed to load module %s, skipping!\n",cPath.c_str());
+				}
+			}
+		}
+		next:
+		ent = readdir(dir);	// next entry
+	}
+#endif
+}

cli/main.cpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <string>
+#include <libInfinite/module/ModuleManager.h>
+#include <libInfinite/tags/handles/sbspHandle.h>
+
+void loadPathRecursive(std::string path, Logger* logger, ModuleManager& modMan);
+int exportBSP(sbspHandle* handle, std::string out, Logger* logger);