main.cpp File Reference

Main program for converting MaterialX documents to and from Protobuf format. More...

#include "materialx_serializer.h"
#include <MaterialXCore/Document.h>
#include <MaterialXFormat/XmlIo.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>
#include <filesystem>

Functions
std::string	writeFile (const std::string &input_path, const std::string &output_folder, const std::string &suffix, const std::string &content, bool debug_print, bool binary_mode=false)
	Write content to a file.
std::pair< bool, std::vector< std::string > >	compareMtlxDocuments (mx::DocumentPtr doc1, mx::DocumentPtr doc2)
	Compare two MaterialX documents for equivalence.
std::string	toLower (const std::string &str)
	Convert string to lowercase.
bool	endsWith (const std::string &str, const std::string &suffix)
	Check if string ends with suffix.
void	printUsage (const char *program_name)
int	main (int argc, char *argv[])

Detailed Description

Main program for converting MaterialX documents to and from Protobuf format.

Function Documentation

compareMtlxDocuments()

std::pair< bool, std::vector< std::string > > compareMtlxDocuments	(	mx::DocumentPtr	doc1,
		mx::DocumentPtr	doc2 )

Compare two MaterialX documents for equivalence.

Parameters

doc1	First document
doc2	Second document

Returns

Pair of (is_same, differences)

                                                                                                 {
    mx::ElementEquivalenceOptions options;
    std::string message;
    bool is_same = doc1->isEquivalent(doc2, options, &message);
    
    std::vector<std::string> differences;
    if (!is_same && !message.empty()) {
        differences.push_back(message);
        std::cout << "Differences found between MaterialX documents:" << std::endl;
        std::cout << message << std::endl;
    }
    
    std::cout << "Documents are equivalent: " << (is_same ? "true" : "false") << std::endl;
    return {is_same, differences};
}

endsWith()

bool endsWith	(	const std::string &	str,
		const std::string &	suffix )

Check if string ends with suffix.

                                                             {
    if (suffix.size() > str.size()) return false;
    return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}

main()

int main	(	int	argc,
		char *	argv[] )

                                 {
    if (argc < 2) {
        printUsage(argv[0]);
        return 1;
    }
    
    // Parse arguments
    std::string input_file;
    bool write_json = false;
    bool convert_back = false;
    bool write_mermaid = false;
    std::string output_folder;
    int debug_pb_doc = 0;
    
    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        
        if (arg == "-h" || arg == "--help") {
            printUsage(argv[0]);
            return 0;
        } else if (arg == "-j" || arg == "--json") {
            write_json = true;
        } else if (arg == "-cb" || arg == "--convert_back") {
            convert_back = true;
        } else if (arg == "-wm" || arg == "--write_mermaid") {
            write_mermaid = true;
        } else if (arg == "-of" || arg == "--output_folder") {
            if (i + 1 < argc) {
                output_folder = argv[++i];
            } else {
                std::cerr << "Error: --output_folder requires an argument" << std::endl;
                return 1;
            }
        } else if (arg == "-dbg" || arg == "--debug_pb_doc") {
            if (i + 1 < argc) {
                debug_pb_doc = std::atoi(argv[++i]);
            } else {
                std::cerr << "Error: --debug_pb_doc requires an argument" << std::endl;
                return 1;
            }
        } else if (arg[0] != '-') {
            input_file = arg;
        } else {
            std::cerr << "Unknown option: " << arg << std::endl;
            printUsage(argv[0]);
            return 1;
        }
    }
    
    if (input_file.empty()) {
        std::cerr << "Error: No input file specified" << std::endl;
        printUsage(argv[0]);
        return 1;
    }
    
    try {
        std::string input_lower = toLower(input_file);
        bool convert_from_mtlx = endsWith(input_lower, ".mtlx");
        bool convert_from_protobuf = endsWith(input_lower, ".mxpb");
        
        MaterialXDocument pb_doc;
        bool has_pb_doc = false;
        
        // Protobuf to MaterialX conversion
        if (convert_from_protobuf) {
            std::cout << "Reading Protobuf file: " << input_file << std::endl;
            
            // Read binary file
            std::ifstream in_stream(input_file, std::ios::binary);
            if (!in_stream) {
                std::cerr << "Error: Failed to open input file: " << input_file << std::endl;
                return 1;
            }
            
            std::ostringstream buffer;
            buffer << in_stream.rdbuf();
            std::string data = buffer.str();
            in_stream.close();
            
            pb_doc = Util::fromString(data);
            has_pb_doc = true;
            
            // Convert to MaterialX
            ProtobufToMaterialX converter;
            const Version& pb_version = pb_doc.schema_version();
            std::cout << "Converting Protobuf document using schema version "
                      << pb_version.major() << "." << pb_version.minor() << "." << pb_version.patch()
                      << " and MaterialX " << mx::getVersionString() << "..." << std::endl;
            
            mx::DocumentPtr doc = converter.convert(pb_doc);
            
            // Write out MaterialX file
            std::string new_doc_string = mx::writeToXmlString(doc);
            writeFile(input_file, output_folder, "_from_pb.mtlx", new_doc_string, true);
        }
        
        // MaterialX to Protobuf conversion
        if (convert_from_mtlx) {
            std::cout << "Reading MaterialX file: " << input_file << std::endl;
            
            mx::DocumentPtr doc = mx::createDocument();
            mx::readFromXmlFile(doc, input_file);
            
            // Convert and save
            MaterialXToProtobuf converter;
            std::cout << "Converting MaterialX document to Protobuf format..." << std::endl;
            pb_doc = converter.convert(doc);
            has_pb_doc = true;
            
            std::string content = Util::toString(pb_doc);
            writeFile(input_file, output_folder, ".mxpb", content, true, true);
            
            // Convert back to MaterialX
            if (convert_back) {
                ProtobufToMaterialX converter2;
                mx::DocumentPtr new_doc = converter2.convert(pb_doc);
                
                auto [is_same, messages] = compareMtlxDocuments(doc, new_doc);
                
                std::string new_doc_string = mx::writeToXmlString(new_doc);
                writeFile(input_file, output_folder, "_converted.mtlx", new_doc_string, true);
            }
        }
        
        // Additional outputs
        if (has_pb_doc) {
            if (write_mermaid) {
                std::string mermaid_code = Util::generateMermaidDiagram(pb_doc);
                writeFile(input_file, output_folder, "_diagram.mmd", mermaid_code, true);
            }
            
            if (write_json) {
                std::string json_str = Util::toJson(pb_doc, 2);
                writeFile(input_file, output_folder, ".json", json_str, true);
            }
            
            if (debug_pb_doc > 0) {
                std::cout << std::string(80, '*') << std::endl;
                if (debug_pb_doc == 1) {
                    Util::debugInspectSimple(pb_doc);
                } else if (debug_pb_doc == 2) {
                    Util::debugInspectCompact(pb_doc);
                } else if (debug_pb_doc == 3) {
                    Util::debugInspect(pb_doc);
                }
                std::cout << std::string(80, '*') << std::endl;
            }
        }
        
        if (!convert_from_mtlx && !convert_from_protobuf) {
            std::cerr << "Error: Input file must have .mtlx or .mxpb extension" << std::endl;
            return 1;
        }
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

printUsage()

void printUsage

(

const char *

program_name

)

                                          {
    std::cout << "Usage: " << program_name << " <inputFile> [options]\n"
              << "\nOptions:\n"
              << "  -j, --json             Output JSON representation of the Protobuf document\n"
              << "  -cb, --convert_back    Convert back to MaterialX after Protobuf conversion\n"
              << "  -wm, --write_mermaid   Output Mermaid diagram of the Protobuf document\n"
              << "  -of, --output_folder   Output folder for converted files\n"
              << "  -dbg, --debug_pb_doc   Enable debug output (1=simple, 2=compact, 3=full)\n"
              << "  -h, --help             Show this help message\n"
              << std::endl;
}

toLower()

std::string toLower

(

const std::string &

str

)

Convert string to lowercase.

                                        {
    std::string result = str;
    std::transform(result.begin(), result.end(), result.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return result;
}

writeFile()

std::string writeFile	(	const std::string &	input_path,
		const std::string &	output_folder,
		const std::string &	suffix,
		const std::string &	content,
		bool	debug_print,
		bool	binary_mode = false )

Write content to a file.

Parameters

input_path	Original input file path
output_folder	Output folder (optional)
suffix	Suffix to append to filename
content	Content to write
debug_print	Whether to print debug messages
binary_mode	Whether to write in binary mode

Returns

Output file path

                                               {
    fs::path input_file(input_path);
    std::string base_name = input_file.stem().string();
    std::string output_file = base_name + suffix;
    
    if (!output_folder.empty()) {
        fs::path output_path(output_folder);
        output_file = (output_path / output_file).string();
    } else {
        fs::path parent_path = input_file.parent_path();
        output_file = (parent_path / output_file).string();
    }
    
    if (debug_print) {
        std::cout << "Writing file: " << output_file << std::endl;
    }
    
    std::ios_base::openmode mode = std::ios::out;
    if (binary_mode) {
        mode |= std::ios::binary;
    }
    
    std::ofstream out_stream(output_file, mode);
    if (!out_stream) {
        throw std::runtime_error("Failed to open file for writing: " + output_file);
    }
    
    out_stream.write(content.c_str(), content.size());
    out_stream.close();
    
    return output_file;
}