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_UniquePtr.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_WorkBuffer.h>
#include <IMG/IMG_Metadata.h>

class FS_DiskCache;
class IMG_File;
class IMG_Stat;

class TIL_API TIL_MakeTexture
    : public UT_NonCopyable
{
public:
    static constexpr exint      DEFAULT_CACHE_SIZE = 2 * 1024;  // In MB
    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)
        , myLinearizeMips(linearizeMipDefault())
        , myConstantRes(0)
        , myStripOpaqueAlpha(false)
        , myDeepSource(false)
        , myMetadata(nullptr)
    {
    }

    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 setMetadata(UT_UniquePtr<IMG_Metadata> md) { myMetadata = std::move(md); }
    void setSanitize(bool v) { mySanitize = v; }
    void setStoreColorSpace(bool v) { myStoreColorSpace = v; }
    void setConstantRes(int res) { myConstantRes = res; }
    void setStripOpaqueAlpha(bool f) { myStripOpaqueAlpha = f; }
    void setLinearizeMips(bool v) { myLinearizeMips = 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());
    }

    struct      TextureFiles;

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

private:
    static bool linearizeMipDefault();

    bool        makeEXR(TextureFiles &files,
                        const UT_StringRef &infile,
                        const UT_StringRef &outfile,
                        IMG_File *img,
                        int tileWidth,
                        int tileHeight,
                        const UT_StringRef &swrap,
                        const UT_StringRef &twrap) const;
    // 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,
                                        bool is_output) const;

    UT_StringHolder             myOutputFormat;
    UT_StringHolder             myOutputSpace;
    UT_StringHolder             myFilter;
    UT_StringHolder             myAOV;
    PXL_OCIO::PHandle           myOCIO;
    PXL_OCIO::PHandle           myOCIOToLinear;
    PXL_OCIO::PHandle           myOCIOFromLinear;
    UT_StringHolder             mySWrapMode;
    UT_StringHolder             myTWrapMode;
    UT_UniquePtr<IMG_Metadata>  myMetadata;
    SRGB_MODE                   mySRGBMode;
    int                         myConstantRes;
    bool                        myStripOpaqueAlpha;
    bool                        mySanitize;
    bool                        myStoreColorSpace;
    bool                        myLinearizeMips;
    mutable bool                myDeepSource;
};

#endif