TIL_MakeTexture.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        TIL_MakeTexture.h (TIL Library, C++)
 *
 * COMMENTS:
 */

#ifndef __TIL_MakeTexture__
#define __TIL_MakeTexture__

#include "TIL_API.h"

#include <PXL/PXL_OCIO.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>

class FS_DiskCache;

class TIL_API TIL_MakeTexture
{
public:
    enum SRGB_MODE
    {
        SRGB_DISABLE,   // No sRGB conversions
        SRGB_FORCE,     // Always apply SRGB convresion
        SRGB_AUTO       // Use the file type information for sRGB
    };

    TIL_MakeTexture()
        : myOutputFormat()      // Defaults to determining from file extension
        , myFilter()
        , myAOV()
        , mySRGBMode(SRGB_AUTO)
        , myOCIO()
        , mySanitize(true)
        , myStoreColorSpace(true)
        , myDeepSource(false)
    {
    }

    virtual ~TIL_MakeTexture();

    UT_NON_COPYABLE(TIL_MakeTexture)

    static void                          initDiskCache();
    static const UT_StringHolder        &fastRemap(const UT_StringRef &name,
                                                bool force);
    static UT_StringHolder               remapFile(const UT_StringHolder &name,
                                                bool force);
    static bool                          clearRemapCache(bool out_of_date);
    static FS_DiskCache                 &diskCache();

    struct TIL_API CacheErrorFiles
        : public UT_NonCopyable
    {
        CacheErrorFiles();
        ~CacheErrorFiles();
        const UT_Set<UT_StringHolder>   *myFiles;
    };

    /// Number of cached files found and used
    static int64                         cacheFilesFound();
    /// Number of local files created
    static int64                         cacheLocalCreated();
    /// Number of temp files created
    static int64                         cacheTempCreated();
    /// Number of errors while trying to create cache files
    static CacheErrorFiles               cacheErrorFiles();

    // Defaults to computing the output format from the file extension on the
    // output file.
    void setOutputFormat(const UT_StringHolder &v) { myOutputFormat = v; }
    void setFilter(const UT_StringHolder &f) { myFilter = f; }
    void setAOV(const UT_StringHolder &s) { myAOV = s; }
    void setSRGBMode(SRGB_MODE mode) { mySRGBMode = mode; };
    void setOCIO(const UT_StringRef &sspace, const UT_StringRef &infile,
            const UT_StringRef &dspace, const UT_StringRef &outfile,
            bool allowparse);
    void setWrapModes(const UT_StringHolder &s, const UT_StringHolder &t)
    {
        mySWrapMode = s;
        myTWrapMode = t;
    }
    void setSanitize(bool v) { mySanitize = v; }
    void setStoreColorSpace(bool v) { myStoreColorSpace = v; }

    // Perform the texture map creation
    bool        makeTexture(const UT_StringRef &infile,
                            const UT_StringRef &outfile,
                            int tile_width=64,
                            int tile_height=64) const;

    bool        deepSource() const { return myDeepSource; }

    template <typename... Args>
    void        message(const char *fmt, const Args &...args) const
    {
        UT_WorkBuffer   tmp;
        tmp.format(fmt, args...);
        doMessage(tmp.buffer());
    }
    template <typename... Args>
    void        warning(const char *fmt, const Args &...args) const
    {
        UT_WorkBuffer   tmp;
        tmp.format(fmt, args...);
        doWarning(tmp.buffer());
    }
    template <typename... Args>
    void        error(const char *fmt, const Args &...args) const
    {
        UT_WorkBuffer   tmp;
        tmp.format(fmt, args...);
        doError(tmp.buffer());
    }

protected:
    virtual void        doMessage(const char *msg) const {}
    virtual void        doWarning(const char *msg) const {}
    virtual void        doError(const char *msg) const {}

private:
    // Compute the OCIO color space associated.  This uses the @c sspace token
    // if it's defined (and not "default").  Otherwise, it will inspect the
    // image file to determine it's color space (when not in @c write_mode).
    // The @c allowparse will enable/disable OCIO filename color space parsing.
    UT_StringHolder     computeOCIOSpace(const UT_StringRef &sspace,
                                        const UT_StringRef &filename,
                                        bool write_mode,
                                        bool allowparse) const;

    UT_StringHolder     myOutputFormat;
    UT_StringHolder     myOutputSpace;
    UT_StringHolder     myFilter;
    UT_StringHolder     myAOV;
    PXL_OCIO::PHandle   myOCIO;
    UT_StringHolder     mySWrapMode;
    UT_StringHolder     myTWrapMode;
    SRGB_MODE           mySRGBMode;
    bool                mySanitize;
    bool                myStoreColorSpace;
    mutable bool        myDeepSource;
};

#endif