respack.cpp

/*\file respack.cpp
 * \brief Implementation for resource packer
 */
#include "respack.h"
#include <stdarg.h>

/*!\brief Constructor
 * \param Unitname Name of output files
 * \param Classname Name of resource class
 */
ResPack::ResPack(const std::string &Unitname,const std::string &Classname){
    unitname=Unitname;
    classname=Classname;
}

/*!\brief Deconstructor
 *
 * Free's allocated data
 */
ResPack::~ResPack(){
    for(unsigned i=0;i<data.size();i++){
        delete [] data[i].data;
    }
}

/*!\brief Generates code to encapsulate resource
 * \param Resource Resource to encapsulate
 * \return String with generated code
 */
std::string ResPack::CreateImplementation(const resource_t &Resource){
    std::string r;
    r+=classname+"::blob "+classname+"::"+Resource.name+"(){\n";
    r+="    const static uint8_t "+Resource.name+"_buffer[]={";
    for(unsigned i=0;i<Resource.size;i++){
        if(i%20==0){
            r+="\n        ";
        }
        r+=Format("0x%02x,",Resource.data[i]);
    }
    r=r.substr(0,r.size()-1)+"};\n";
    r+="    blob object;\n";
    r+="    object.data="+Resource.name+"_buffer;\n";
    r+="    object.size="+Format("%d",Resource.size)+";\n";
    r+="    return object;\n";
    r+="}\n";
    return r;
}

/*!\brief Generates code to encapsulate loaded resources
 * \return String with generated implementation code
 */
std::string ResPack::CreateImplementation(){
    // Includes
    std::string r;
    r+="#include \""+unitname+".h\"\n\n";

    // Resource constructor
    r+=classname+"::resource::resource(const std::string &Name,const size_t &Size){\n";
    r+="    name=Name;\n";
    r+="    size=Size;\n";
    r+="}\n\n";

    // Resource enumerator
    r+="std::vector<"+classname+"::resource> "+classname+"::Enumerate(){\n";
    r+="    std::vector<"+classname+"::resource> resources;\n";
    for(unsigned i=0;i<data.size();i++){
        r+="    resources.push_back(resource(\""+data[i].name+"\","+Format("%d",data[i].size)+"));\n";
    }
    r+="    return resources;\n";
    r+="}\n\n";

    // Resource implementations
    for(unsigned i=0;i<data.size();i++){
        r+=CreateImplementation(data[i])+"\n";
    }
    return r;
}

/*!\brief Generates code to encapsulate resource
 * \param Resource Resource to encapsulate
 * \return String with generated header code
 */
std::string ResPack::CreateHeader(const resource_t &Resource){
    return "blob "+Resource.name+"();";
}

/*!\brief Generates code to encapsulate loaded resource
 * \return String with generated code
 */
std::string ResPack::CreateHeader(){
    // Create headerguard and includes
    std::string r;
    std::string hg=unitname;
    for(unsigned i=0;i<hg.size();i++) hg[i]=toupper(hg[i]);
    r+="#ifndef _"+hg+"_H_\n";
    r+="#define _"+hg+"_H_\n\n";
    r+="#include <stdint.h>\n";
    r+="#include <string>\n";
    r+="#include <vector>\n";
    r+="\n";

    // Create resource class
    r+="class "+classname+"{\n";
    r+="    public:\n";
    r+="        // Structure for enumerating resources\n";
    r+="        struct resource{\n";
    r+="            resource(const std::string &Name,const size_t &Size);\n";
    r+="            std::string name;\n";
    r+="            size_t size;\n";
    r+="        };\n\n";
    r+="        // Structure for encapsulating resources\n";
    r+="        struct blob{\n";
    r+="            const uint8_t *data=0;\n";
    r+="            size_t size=0;\n";
    r+="        };\n";
    r+="\n";
    r+="        // Resources\n";
    for(unsigned i=0;i<data.size();i++){
        r+="        static "+CreateHeader(data[i])+"\n";
    }
    r+="\n";
    r+="        // Resource enumerator\n";
    r+="        static std::vector<resource> Enumerate();\n";
    r+="};\n";
    r+="\n";

    // Terminate headerguard
    r+="#endif\n";
    return r;
}

/*!\brief Formats a string
 * \param Input String with formatting
 * \return Formatted string
 */
std::string ResPack::Format(const std::string &Input,...){
    const int size=1024;
    char buffer[size];
    va_list arg;
    va_start(arg,Input);
    int len=vsnprintf(buffer,size,Input.c_str(),arg);
    va_end(arg);
    if(len>=0){
        return std::string(buffer,len);
    }
    else{
        return "";
    }
}

/*!\brief Parses file basename (No folder or extension) from path
 * \param Path Pathname to parse
 * \return File basename
 */
std::string ResPack::ParseName(const std::string &Path){
    size_t i=Path.rfind('/',Path.length());
    if(i!=std::string::npos){
        std::string filename=Path.substr(i+1,Path.length()-i);
        size_t lastindex=filename.find_last_of(".");
        return filename.substr(0,lastindex).c_str();
    }
    size_t lastindex=Path.find_last_of(".");
    return Path.substr(0,lastindex).c_str();
}

/*!\brief Parses file extension from path
 * \param Path Pathname to parse
 * \return File extension as a string
 */
std::string ResPack::ParseExt(const std::string &Path){
    size_t limit=Path.find_last_of("/");
    if(limit==std::string::npos) limit=0;
    size_t p=Path.rfind('.');
    if(p!=std::string::npos && p>=limit){
        return Path.substr(p+1,Path.length()-p).c_str();
    }
    return "";
}

/*!\brief Add resource to encapsulate
 * \param Path Pathname to resource
 * \return True upon success
 */
bool ResPack::AddResource(const std::string &Path){
    bool retval=false;
    FILE *fd=fopen(Path.c_str(),"rb");
    if(fd){
        // Read data from file
        fseek(fd,0,SEEK_END);
        size_t size=ftell(fd);
        fseek(fd,0,SEEK_SET);
        resource_t res;
        res.data=new uint8_t[size+1];
        res.size=size;
        if(res.data){
            if(fread(res.data,1,size,fd)==size){
                // Create an asset name
                std::string n=ParseName(Path);
                std::string e=ParseExt(Path);
                // TODO: Internal replace function
                //n.replace(".","_");
                //e.replace(".","_");
                res.name=e.size()?n+"_"+e:n;

                // Stash asset
                data.push_back(res);
                retval=true;
            }
            else{
                delete [] res.data;
            }
        }
        fclose(fd);
    }
    if(retval){
        //TODO: Optionally compress data
    }
    return retval;
}

#ifndef NOMAIN
int main(int argc,char *argv[]){
    // Parse parameters
    std::string uname="resources";
    std::string cname="Resources";
    bool print=false;
    std::vector<std::string> resources;
    for(int i=1;i<argc;i++){
        if(!strcmp(argv[i],"--uname") || !strcmp(argv[i],"-u")){
            uname=argv[++i];
        }
        else if(!strcmp(argv[i],"--cname") || !strcmp(argv[i],"-c")){
            cname=argv[++i];
        }
        else if(!strcmp(argv[i],"--print") || !strcmp(argv[i],"-p")){
            print=true;
        }
        else if(!strcmp(argv[i],"--help") || !strcmp(argv[i],"-h")){
            printf("Resource packer\n");
            printf("Vegard Fiksdal\n");
            printf("\n");
            printf("Usage: %s [OPTIONS] [RESOURCES]\n",argv[0]);
            printf("\n");
            printf("Options:\n");
            printf("\t-u|--uname NAME\tSet unit name (Default=\"resources\")\n");
            printf("\t-c|--cname NAME\tSet class name (Default=\"Resources\")\n");
            printf("\t-p|--print\tPrint output instead of writing to file\n");
            printf("\t-h|--help\tThis helpfull screen\n");
            printf("\n");
            return 0;
        }
        else if(argv[i][0]=='-'){
            printf("Invalid parameter: %s\n",argv[i]);
            printf("Use %s -h for usage instructions\n",argv[0]);
            return -1;
        }
        else{
            resources.push_back(argv[i]);
        }
    }

    // Check for resources to pack
    if(resources.size()==0){
        printf("No resources to process!\n");
        printf("Use %s -h for usage instructions\n",argv[0]);
        return -1;
    }

    // Check for duplicates
    for(unsigned i=0;i<resources.size();i++){
        for(unsigned j=0;j<resources.size();j++){
            if(i!=j && resources[i]==resources[j]){
                printf("Dupicate resources: %s\n",resources[i].c_str());
                return -1;
            }
        }
    }

    // Pack resources
    ResPack respack(uname,cname);
    for(unsigned i=0;i<resources.size();i++){
        if(!respack.AddResource(resources[i])){
            printf("Failed to load resource %s\n",resources[i].c_str());
            return -1;
        }
    }

    // Output results
    std::string header=respack.CreateHeader();
    std::string implementation=respack.CreateImplementation();
    if(print){
        printf("%s\n",header.c_str());
        printf("%s\n",implementation.c_str());
    }
    else{
        FILE *hfd=fopen((uname+".h").c_str(),"wb");
        if(!hfd){
            printf("Failed to open %s.h for writing!\n",uname.c_str());
            return -1;
        }
        FILE *ifd=fopen((uname+".cpp").c_str(),"wb");
        if(!ifd){
            printf("Failed to open %s.cpp for writing!\n",uname.c_str());
            fclose(hfd);
            return -1;
        }
        if(fwrite(header.c_str(),1,header.size(),hfd)!=header.size()){
            printf("Failed write to header file %s.h\n",uname.c_str());
            fclose(hfd);
            fclose(ifd);
            return -1;
        }
        if(fwrite(implementation.c_str(),1,implementation.size(),ifd)!=implementation.size()){
            printf("Failed write to implementation file %s.cpp\n",uname.c_str());
            fclose(hfd);
            fclose(ifd);
            return -1;
        }
        fclose(hfd);
        fclose(ifd);
    }
    return 0;
}
#endif