textureCompress.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
// FILE: textureCompress.cpp //////////////////////////////////////////////////////
// Author: Matthew D. Campbell, Dec 2002
 
// SYSTEM INCLUDES ////////////////////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN  // only bare bones windows stuff wanted
//#include <afxwin.h>
#include <windows.h>
#include <lmcons.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "resource.h"
#include <map>
#include <string>
#include <set>
#include <cstdarg>
#include <io.h>
#include <sys/stat.h>
#include <sys/utime.h>
 
static const char *nodxtPrefix[] = {
    "zhca",
    "caust",
    NULL,
};
 
static const char *nodxtAnywhere[] = {
    "userinterface",
    "controlbar",
    "commandbar",
    NULL,
};
 
#define LOG(x) logStuff x
static void logStuff(const char *fmt, ...)
{
    static char buffer[1024];
    va_list va;
    va_start( va, fmt );
    _vsnprintf(buffer, 1024, fmt, va );
    buffer[1023] = 0;
    va_end( va );
 
    puts(buffer);
    ::MessageBox(NULL, buffer, "textureCompress", MB_OK);
}
 
#ifndef NDEBUG
 
class DebugMunkee
{
public:
    DebugMunkee(const char *fname = "debugLog.txt") { m_fp = fopen(fname, "w"); }
    ~DebugMunkee() { if (m_fp) fclose(m_fp); m_fp = NULL; }
 
    FILE *m_fp;
};
 
static DebugMunkee *theDebugMunkee = NULL;
 
#define DEBUG_LOG(x) debugLog x
static void debugLog(const char *fmt, ...)
{
    static char buffer[1024];
    va_list va;
    va_start( va, fmt );
    _vsnprintf(buffer, 1024, fmt, va );
    buffer[1023] = 0;
    va_end( va );
 
    OutputDebugString( buffer );
    puts(buffer);
    if (theDebugMunkee)
        fputs(buffer, theDebugMunkee->m_fp);
}
 
#else
 
#define DEBUG_LOG(x) {}
 
#endif // NDEBUG
 
 
static void usage(const char *progname)
{
    if (!progname)
        progname = "textureCompress";
    LOG (("Usage: %s sourceDir destDir cacheDir outFile dxtOutFile\n", progname));
}
 
class FileInfo
{
public:
    FileInfo() {}
    ~FileInfo() {}
 
    void set( const WIN32_FIND_DATA& info );
 
    std::string filename;
    time_t creationTime;
    time_t accessTime;
    time_t modTime;
    DWORD attributes;
    DWORD filesize;    // only care about 32 bits for our purposes
 
protected:
};
 
struct FileInfoComparator
{
    bool operator()(const FileInfo& a, const FileInfo& b) const
    {
        return a.filename < b.filename;
    }
};
 
//-------------------------------------------------------------------------------------------------
 
typedef std::set<FileInfo, FileInfoComparator> FileInfoSet;
 
//-------------------------------------------------------------------------------------------------
 
class Directory
{
public:
    Directory(const std::string& dirPath);
    ~Directory() {}
 
    FileInfoSet* getFiles( void );
    FileInfoSet* getSubdirs( void );
 
protected:
    std::string m_dirPath;
 
    FileInfoSet m_files;
    FileInfoSet m_subdirs;
};
 
//-------------------------------------------------------------------------------------------------
 
static void TimetToFileTime( time_t t, FILETIME& ft )
{
    LONGLONG ll = Int32x32To64(t, 10000000) + 116444736000000000;
    ft.dwLowDateTime = (DWORD) ll;
    ft.dwHighDateTime = ll >>32;
}
 
static time_t FileTimeToTimet( const FILETIME& ft )
{
    LONGLONG ll = (ft.dwHighDateTime << 32) + ft.dwLowDateTime - 116444736000000000;
    ll /= 10000000;
    return (time_t)ll;
}
 
//-------------------------------------------------------------------------------------------------
 
void FileInfo::set( const WIN32_FIND_DATA& info )
{
    filename = info.cFileName;
    for (int i=0; i<filename.size(); ++i)
    {
        char c[2] = { tolower(info.cFileName[i]), 0 };
        filename.replace(i, 1, c, 1);
    }
    creationTime = FileTimeToTimet(info.ftCreationTime);
    accessTime = FileTimeToTimet(info.ftLastAccessTime);
    modTime = FileTimeToTimet(info.ftLastWriteTime);
    attributes = info.dwFileAttributes;
    filesize = info.nFileSizeLow;
 
    struct stat origStat;
    stat( filename.c_str(), &origStat);
    modTime = origStat.st_mtime; // use stat(), since the LONGLONG code is unpredictable
 
    //DEBUG_LOG(("FileInfo::set(): fname=%s, size=%d, modTime=%d\n", filename.c_str(), filesize, modTime));
}
 
//-------------------------------------------------------------------------------------------------
 
Directory::Directory( const std::string& dirPath ) : m_dirPath(dirPath)
{
    WIN32_FIND_DATA         item;  // search item
    HANDLE                          hFile;  // handle for search resources
    char                                currDir[ MAX_PATH ];
 
    // sanity
    if( !m_dirPath.length() )
    {
        return;
    }
 
    // save the current directory
    GetCurrentDirectory( MAX_PATH, currDir );
 
    // switch into the directory provided
    if( SetCurrentDirectory( m_dirPath.c_str() ) == 0 )
    {
        return;
    }
 
    // go through each item in the output directory
    bool done = false;
    hFile = FindFirstFile( "*", &item);
    if( hFile == INVALID_HANDLE_VALUE )
    {
        done = true;
    }
 
    FileInfo info;
 
    while (!done)
    {
        // if this is a subdirectory keep the name around till the end
        if( item.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
        {
            if ( strcmp( item.cFileName, "." ) && strcmp( item.cFileName, ".." ) )
            {
                info.set(item);
                m_subdirs.insert( info );
            }
        }
        else
        {
            info.set(item);
            m_files.insert( info );
        }
 
        if ( FindNextFile( hFile, &item ) == 0 )
        {
            done = true;
        }
    }
 
    // close search
    FindClose( hFile );
 
    // restore the working directory to what it was when we started here
    SetCurrentDirectory( currDir );
}
 
FileInfoSet* Directory::getFiles( void )
{
    return &m_files;
}
 
FileInfoSet* Directory::getSubdirs( void )
{
    return &m_subdirs;
}
 
//-------------------------------------------------------------------------------------------------
 
// strtrim ====================================================================
//=============================================================================
static char* strtrim(char* buffer)
{
    if (buffer != NULL) {
        //  Strip leading white space from the string.
        char * source = buffer;
        while ((*source != 0) && ((unsigned char)*source <= 32))
        {
            source++;
        }
 
        if (source != buffer)
        {
            strcpy(buffer, source);
        }
 
        //  Clip trailing white space from the string.
        for (int index = strlen(buffer)-1; index >= 0; index--)
        {
            if ((*source != 0) && ((unsigned char)buffer[index] <= 32))
            {
                buffer[index] = '\0';
            }
            else
            {
                break;
            }
        }
    }
 
    return buffer;
}
 
//-------------------------------------------------------------------------------------------------
typedef std::set<std::string> StringSet;
 
//-------------------------------------------------------------------------------------------------
void eraseCachedFiles(const std::string& sourceDirName, const std::string& targetDirName, const std::string& cacheDirName,
                                            StringSet& cachedFilesToErase)
{
    StringSet::const_iterator sit;
    for (sit = cachedFilesToErase.begin(); sit != cachedFilesToErase.end(); ++sit)
    {
        std::string src = cacheDirName;
        src.append("\\");
        src.append(*sit);
 
        DEBUG_LOG(("Erasing cached file: %s\n", src.c_str()));
        DeleteFile(src.c_str());
    }
}
 
//-------------------------------------------------------------------------------------------------
void copyCachedFiles(const std::string& sourceDirName, const std::string& targetDirName, const std::string& cacheDirName,
                                         StringSet& cachedFilesToCopy)
{
    StringSet::const_iterator sit;
    for (sit = cachedFilesToCopy.begin(); sit != cachedFilesToCopy.end(); ++sit)
    {
        std::string src = cacheDirName;
        src.append("\\");
        src.append(*sit);
 
        std::string dest = targetDirName;
        dest.append("\\");
        dest.append(*sit);
 
        DEBUG_LOG(("Copying cached file: %s\n", src.c_str()));
        if (_chmod(dest.c_str(), _S_IWRITE | _S_IREAD) == -1)
        {
            DEBUG_LOG(("Cannot chmod '%s'\n", dest.c_str()));
        }
        CopyFile(src.c_str(), dest.c_str(), FALSE);
    }
}
 
//-------------------------------------------------------------------------------------------------
void compressOrigFiles(const std::string& sourceDirName, const std::string& targetDirName, const std::string& cacheDirName,
                                             StringSet& origFilesToCompress, const std::string& dxtOutFname)
{
    char tmpPath[_MAX_PATH] = "C:\\temp\\";
    char tmpFname[_MAX_PATH] = "C:\\temp\\tmp.txt";
    GetTempPath(_MAX_PATH, tmpPath);
    GetTempFileName(tmpPath, "tex", 0, tmpFname);
    HANDLE h = CreateFile(tmpFname, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
    if (!h)
    {
        DEBUG_LOG(("Could not create temp file '%s'!  Unable to compress textures!\n", tmpFname));
    }
 
    StringSet::const_iterator sit;
    for (sit = origFilesToCompress.begin(); sit != origFilesToCompress.end(); ++sit)
    {
        std::string tmp = sourceDirName;
        tmp.append("\\");
        tmp.append(*sit);
        tmp.append("\n");
        DEBUG_LOG(("Compressing file: %s", tmp.c_str()));
        DWORD len;
        WriteFile(h, tmp.c_str(), tmp.length(), &len, NULL);
    }
    CloseHandle(h);
 
    std::string commandLine;
    commandLine = "\\projects\\rts\\build\\nvdxt -list ";
    commandLine.append(tmpFname);
    commandLine.append(" -24 dxt1c -32 dxt5 -full -outdir ");
    commandLine.append(cacheDirName);
    commandLine.append(" > ");
    commandLine.append(dxtOutFname);
 
    DEBUG_LOG(("Compressing textures with command line of '%s'\n", commandLine.c_str()));
    int ret = system(commandLine.c_str());
    DEBUG_LOG(("system(%s) returned %d\n", commandLine.c_str(), ret));
    DeleteFile(tmpFname);
 
    // now copy compressed file to target dir
    for (sit = origFilesToCompress.begin(); sit != origFilesToCompress.end(); ++sit)
    {
        std::string orig = sourceDirName;
        orig.append("\\");
        orig.append(*sit);
 
        struct stat origStat;
        stat( orig.c_str(), &origStat);
 
        struct _utimbuf utb;
        utb.actime = origStat.st_atime;
        utb.modtime = origStat.st_mtime;
 
        std::string src = cacheDirName;
        src.append("\\");
        src.append(*sit);
        src.replace(src.size()-4, 4, ".dds");
 
        _utime(src.c_str(), &utb);
 
        std::string dest = targetDirName;
        dest.append("\\");
        dest.append(*sit);
        dest.replace(dest.size()-4, 4, ".dds");
 
        DEBUG_LOG(("Copying new file from %s to %s\n", src.c_str(), dest.c_str()));
 
        if (_chmod(dest.c_str(), _S_IWRITE | _S_IREAD) == -1)
        {
            DEBUG_LOG(("Cannot chmod '%s'\n", dest.c_str()));
        }
        BOOL ret = CopyFile(src.c_str(), dest.c_str(), FALSE);
        if (!ret)
        {
            DEBUG_LOG(("Could not copy file!\n"));
        }
 
        _utime(dest.c_str(), &utb);
    }
}
 
//-------------------------------------------------------------------------------------------------
void copyOrigFiles(const std::string& sourceDirName, const std::string& targetDirName, const std::string& cacheDirName,
                                     StringSet& origFilesToCopy)
{
    StringSet::const_iterator sit;
    for (sit = origFilesToCopy.begin(); sit != origFilesToCopy.end(); ++sit)
    {
        std::string src = sourceDirName;
        src.append("\\");
        src.append(*sit);
 
        std::string dest = targetDirName;
        dest.append("\\");
        dest.append(*sit);
 
        if (_chmod(dest.c_str(), _S_IWRITE | _S_IREAD) == -1)
        {
            DEBUG_LOG(("Cannot chmod '%s'\n", dest.c_str()));
        }
        BOOL res = CopyFile(src.c_str(), dest.c_str(), FALSE);
        DEBUG_LOG(("Copying file: %s returns %d\n", src.c_str(), res));
    }
}
 
//-------------------------------------------------------------------------------------------------
static void scanDir( const std::string& sourceDirName, const std::string& targetDirName, const std::string& cacheDirName, const std::string& dxtOutFname )
{
    DEBUG_LOG(("Scanning '%s'\n", sourceDirName.c_str()));
    Directory sourceDir(sourceDirName);
 
    DEBUG_LOG(("Scanning '%s'\n", targetDirName.c_str()));
    Directory targetDir(targetDirName);
 
    DEBUG_LOG(("Scanning '%s'\n", cacheDirName.c_str()));
    Directory cacheDir(cacheDirName);
 
    FileInfoSet *sourceFiles = sourceDir.getFiles();
    FileInfoSet *cacheFiles = cacheDir.getFiles();
    FileInfoSet *targetFiles = targetDir.getFiles();
 
    StringSet cachedFilesToErase;
    StringSet cachedFilesToCopy;
    StringSet origFilesToCompress;
    StringSet origFilesToCopy;
 
    DEBUG_LOG(("Emptying targetDir\n"));
    for (FileInfoSet::iterator targetIt = targetFiles->begin(); targetIt != targetFiles->end(); ++targetIt)
    {
        FileInfo f = *targetIt;
        std::string fname = f.filename;
        f.filename.replace(f.filename.size()-4, 4, ".tga");
        FileInfoSet::iterator fit = sourceFiles->find(f);
        if (fit == sourceFiles->end())
        {
            // look for pre-existing dds files too
            f.filename.replace(f.filename.size()-4, 4, ".dds");
            FileInfoSet::iterator ddsfit = sourceFiles->find(f);
            if (ddsfit == sourceFiles->end())
            {
                fname.insert(0, "\\");
                fname.insert(0, targetDirName);
                DEBUG_LOG(("Deleting now-removed file '%s'\n", fname.c_str()));
                DeleteFile(fname.c_str());
            }
        }
    }
 
    for (FileInfoSet::iterator cacheIt = cacheFiles->begin(); cacheIt != cacheFiles->end(); ++cacheIt)
    {
        FileInfo f = *cacheIt;
        int len = f.filename.size();
        if (len < 5)
        {
            cachedFilesToErase.insert(f.filename);
            continue;
        }
        std::string fname = f.filename;
        f.filename.replace(len-4, 4, ".tga");
        FileInfoSet::iterator fit = sourceFiles->find(f);
        if (fit != sourceFiles->end())
        {
            FileInfo sf = *fit;
            if (f.modTime < sf.modTime)
            {
                cachedFilesToErase.insert(fname);
            }
            else
            {
                f.filename = fname; // back to .dds
                FileInfoSet::iterator it = targetFiles->find(f);
                if (it == targetFiles->end())
                    cachedFilesToCopy.insert(fname);
            }
        }
        else
        {
            cachedFilesToErase.insert(fname);
        }
    }
 
    for (FileInfoSet::iterator sourceIt = sourceFiles->begin(); sourceIt != sourceFiles->end(); ++sourceIt)
    {
        FileInfo f = *sourceIt;
 
        std::string fname = f.filename;
        const char *s = fname.c_str();
        int index = 0;
        const char *check = nodxtPrefix[0];
        bool shouldSkip = false;
        while (check)
        {
            if (fname.find(check) == 0)
            {
                shouldSkip = true;
                break;
            }
            check = nodxtPrefix[++index];
        }
 
        index = 0;
        check = nodxtAnywhere[0];
        while (check && !shouldSkip)
        {
            if (fname.find(check) != fname.npos)
            {
                shouldSkip = true;
                break;
            }
            check = nodxtAnywhere[++index];
        }
 
        if (!shouldSkip)
        {
            // check for preexisting .dds files so we can just copy them
            if (fname.find(".dds") != fname.npos)
            {
                shouldSkip = true;
            }
        }
 
        if (shouldSkip)
        {
            origFilesToCopy.insert(s);
        }
        else
        {
            int len = f.filename.size();
            f.filename.replace(len-4, 4, ".dds");
            FileInfoSet::iterator fit = cacheFiles->find(f);
            if (fit != cacheFiles->end())
            {
                FileInfo cf = *fit;
                if (cf.modTime < f.modTime)
                {
                    origFilesToCompress.insert(fname);
                }
            }
            else
            {
                origFilesToCompress.insert(fname);
            }
        }
    }
 
    // now dump our files
    eraseCachedFiles (sourceDirName, targetDirName, cacheDirName, cachedFilesToErase);
    copyCachedFiles  (sourceDirName, targetDirName, cacheDirName, cachedFilesToCopy);
    copyOrigFiles    (sourceDirName, targetDirName, cacheDirName, origFilesToCopy);
    compressOrigFiles(sourceDirName, targetDirName, cacheDirName, origFilesToCompress, dxtOutFname);
}
 
//-------------------------------------------------------------------------------------------------
#define USE_WINMAIN
#ifdef USE_WINMAIN
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
    /*
    ** Convert WinMain arguments to simple main argc and argv
    */
    int argc = 1;
    char * argv[20];
    argv[0] = NULL;
 
    char * token = strtok(lpCmdLine, " ");
    while (argc < 20 && token != NULL)
    {
        argv[argc++] = strtrim(token);
        token = strtok(NULL, " ");
    }
#else
int main(int argc, const char **argv)
{
#endif // USE_WINMAIN
 
    if (argc != 6)
    {
        usage(argv[0]);
    }
    else
    {
        const char *sourceDir = argv[1];
        const char *targetDir = argv[2];
        const char *cacheDir  = argv[3];
 
#ifndef NDEBUG
        theDebugMunkee = new DebugMunkee(argv[4]);
#endif
 
        //setUpLoadWindow();
        scanDir(sourceDir, targetDir, cacheDir, argv[5]);
        //setLoadWindowText("Writing to file...");
        //printSet( noAlphaChannel, "No Alpha Channel" );
        //printSet( noAlpha, "Not Using Alpha Channel" );
        //printSet( hasAlpha, "Using Alpha Channel" );
        //tearDownLoadWindow();
 
#ifndef NDEBUG
        delete theDebugMunkee;
        theDebugMunkee = NULL;
#endif
    }
 
    return 0;
}