PolygonCruncherInterface.h

Go to the documentation of this file.

//! @file PolygonCruncherInterface.h
//! @brief Defines some class for batch optimization and scene conversion for CSceneOptimizer
#ifndef POLYGONCRUNCHER_INTERFACE_H
#define POLYGONCRUNCHER_INTERFACE_H
 
#include "common_cpp_type.h"
#include "3DType.h"
#include "PolygonCruncherConfig.h"
#include "PolygonCruncherType.h"
#include "3DScene.h"
#include "BatchTools.h"
 
#if defined(MOOTOOLS_PRODUCT_BUILD)
#include "PolygonCruncherPrivate.h"
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
#include "DeiCommand.h"
#include "CruncherCommands.h"
 
class COptimizerWnd;
class CCruncherSheet;
#endif
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
 
class C3DScene;
class C3DFaceList;
class C3DPointList;
class C3DObject;
class C3DPatch;
class C3DSceneNode;
class CSceneOptimizer;
class CMultiresolutionObject;
class C3DExtObject;
class BatchCruncherOptions;
 
//! @class CruncherProgressInfo
//! @brief This class provides information about computation progress to the different progress callback.
//! @details It is called during the different optimization steps giving a chance to provide some feedback to the user or to cancel the operation.
class DLLFUNCTION CruncherProgressInfo
{
    friend CSceneOptimizer;
 
protected:
    void Init();
 
public:
    //! @enum ProgressState
    //! CruncherProgressInfo::GetState returns optimization operation currently in progress;\n
    //! This gives information about what the optimizer is doing.\n
    //! You can set userCancel to true to stop the operation.
    typedef enum ProgressState
    {
        STATE_UNDEFINED = 0,
        INIT_OPTIMIZATION = 1,
        OPTIMIZE_NODE,
        INIT_MULTIRES_NODE,
        MATERIAL_CHANGES,
        CREATEMR,
        MAGICCRUNCHER,
        BATCH_INFO,
        BATCH_INFO_LOG_FAILS,
    } ProgressState;
 
    typedef enum LogLevel
    {
        MACRO_RESULT_UNDEFINED = 0,
        MACRO_RESULT_OK = 1,
        MACRO_RESULT_WARNING = 2,
        MACRO_RESULT_ERROR = 3,
    } LogLevel;
 
    CruncherProgressInfo();
    CruncherProgressInfo(const CXString& txt, LogLevel logLevel, bool replaceLine, ProgressState state = BATCH_INFO);
 
    int GetPos() const { return pos; }
    int GetMin() const { return min; }
    int GetMax() const { return max; }
    const CXString& GetText() const { return txt; }
    ProgressState GetState() const { return progressState; }
    LogLevel GetLogLevel() const { return logLevel; }
    bool ReplaceLastLogLine() const { return replaceLastLogLine; }
    bool GetCancelState() const { return userCancel; }
    xThreadID GetMainOptimizerThreadID() const { return mainThreadID; }
 
public:
    mutable bool userCancel;
    bool doubleBarMode;
    xThreadID mainThreadID;
    CXString txt;
    int curmesh, meshnbr;
    int min, max;
    int pos;
    ProgressState progressState;
    LogLevel logLevel;
 
    // Log info (when CruncherProgress = CRUNCHER_PROGRESS_BATCH_INFO)
    bool replaceLastLogLine;
};
 
//! @enum PolygonCruncherObjectCreatorFlags
//! Defines the conversion mode to prepare the scene for the CSceneOptimizer. The mode depends on the usage of the optimizer:
//! * DEFAULT_OPTIMIZATION means that an object is created and optimize once for all with given optimization flags.\n
//! This flag matches for static and dynamic optimization. cf. #OPTIMIZATION and #OPTIMIZATION_DYNAMIC
//! * INTERACTIVE_OPTIMIZATION means that the object might be optimized several time with several optimization flags
//! This flag matches for interactive optimization. cf. #OPTIMIZATION_INTERACTIVE
//! * MULTIRESOLUTION_DATA means that we create a CMultiresolutionObject from a saved multiresolution data (C3DExtObject::SetMultiresolutionData)
typedef enum PolygonCruncherObjectCreatorFlags
{
    DEFAULT_OPTIMIZATION_OBJECT = 1,
    INTERACTIVE_OPTIMIZATION_OBJECT,
    MULTIRESOLUTION_DATA_OBJECT,
} PolygonCruncherObjectCreatorFlags;
 
// DLL delay loading required constructor and destructor to be defined.
// Otherwise it can't link for a unexplained reason.
 
//! @class C3DPolygonCruncherObjectCreator
//! @brief This class converts an usual C3DScene to a C3DScene containing object that can be used by CSceneOptimizer.
//! @details The class is provided to C3DScene::Copy.
//! Use the PolygonCruncherObjectCreatorFlags accordingly to the type of optimization you want to perform.
class DLLFUNCTION C3DPolygonCruncherObjectCreator : public C3DObjectCreator
{
public:
    C3DPolygonCruncherObjectCreator(PolygonCruncherObjectCreatorFlags creationFlag);
    virtual ~C3DPolygonCruncherObjectCreator();
 
    C3DObject* GetNewPolygonalObject(); //!< Creates a C3DObject with the appropriate required face list and point list classes.
 
protected:
    PolygonCruncherObjectCreatorFlags creationMode;
 
    C3DBaseObject* ConvertToType(const C3DSceneNode* refnode, const C3DBaseObject* refobject);
    C3DBaseObject* GetNewObjectFrom(const C3DBaseObject* object, bool& emptyCopy);
 
    C3DFaceList* GetNewFaceList();
    C3DPointList* GetNewPointList();
    C3DPatch* GetNewPatchObject();
};
 
class CStdioFileEx;
class CBatchOptimizer;
 
//! @class BatchCruncherOptions
//! @brief This class allows to perform batch optimization, which means process a set of files.
//! @details BatchCruncherOptions is construct using a CCustomData filled with the BatchCruncherOptions::Parameters properly initialized.
//! Some methods allows to define the batch folder or the file to be process during optimization.\n
//!
//! The options are then provided to CBatchOptimizer object and a call to CBatchOptimizer::Batch starts the batch.
class DLLFUNCTION BatchCruncherOptions
{
    friend CBatchOptimizer;
public:
    //! @enum Parameters
    //! The following information fill a CCustomData in order to call the batch module remotely.
    //! The CCustomData is provided through BatchCruncherOptions::data and provided through DoBatchOptimization
    typedef enum Parameters
    {
        CRUNCHER_SRCMODE_PARAM = MAKE_CUSTOM_ID('S', 'R', 'M', 'D'), //!< UInt, 0: a set of files, 1: the current directory, 2: a selected dir, default: 1. Cf. BatchSrcMode
        CRUNCHER_SRCFILES_PARAM = MAKE_CUSTOM_ID('S', 'R', 'F', 'I'), //!< String Array, define the set of file to optimize
        CRUNCHER_SRCDIR_PARAM = MAKE_CUSTOM_ID('S', 'R', 'D', 'I'), //!< String, a full path to the current directory (CRUNCHER_SRCMODE_PARAM=1)
        CRUNCHER_SRCSUBDIR_PARAM = MAKE_CUSTOM_ID('S', 'R', 'S', 'D'), //!< Bool, used if CRUNCHER_SRCMODE_PARAM != 0, false: the files contained in CRUNCHER_SRCDIR_PARAM are optimized, true: the files contained in CRUNCHER_SRCDIR_PARAM and subfolders are optimized, default: true
        CRUNCHER_SRCKINDOF_PARAM = MAKE_CUSTOM_ID('K', 'I', 'N', 'D'), //!< UInt, 0: All 3d files are optimized, 1: only provided extensions are optimized, 2: only not provided extensions are optimized, default: 0
        CRUNCHER_SRCEXT_PARAM = MAKE_CUSTOM_ID('E', 'X', 'T', 'E'), //!< String, only if CRUNCHER_SRCKINDOF_PARAM != 0, a set of extension separated by ; (ie: .3ds; .dxf)
        CRUNCHER_OPTIMIZE_PREDEFINED_LEVEL_NBR = 5, //!< The number of predefined level
        CRUNCHER_OPTIMIZE_LEVEL1 = MAKE_CUSTOM_ID('L', 'E', 'V', '1'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=0, value from 0 to 100, default: 25 (remove 25% of the vertices)
        CRUNCHER_OPTIMIZE_LEVEL2 = MAKE_CUSTOM_ID('L', 'E', 'V', '2'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=0, value from 0 to 100, default: 50
        CRUNCHER_OPTIMIZE_LEVEL3 = MAKE_CUSTOM_ID('L', 'E', 'V', '3'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=0, value from 0 to 100, default: 65
        CRUNCHER_OPTIMIZE_LEVEL4 = MAKE_CUSTOM_ID('L', 'E', 'V', '4'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=0, value from 0 to 100, default: 75
        CRUNCHER_OPTIMIZE_LEVEL5 = MAKE_CUSTOM_ID('L', 'E', 'V', '5'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=0, value from 0 to 100, default: 90
        CRUNCHER_OPTIMIZE_LEVEL_NBR = MAKE_CUSTOM_ID('L', 'E', 'V', 'N'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=1, the number of LOD to generate 
        CRUNCHER_OPTIMIZE_START_LEVEL = MAKE_CUSTOM_ID('L', 'E', 'V', 'S'), //!< UInt, only if CRUNCHER_OPTIMIZE_LEVEL_MODE=1, the ratio of the first LOD to generate, default: 50
        CRUNCHER_OPTIMIZE_LEVEL_MODE = MAKE_CUSTOM_ID('L', 'E', 'V', 'M'), //!< UInt, 0: predefined ratio (CRUNCHER_OPTIMIZE_LEVEL1 to CRUNCHER_OPTIMIZE_LEVEL5) 1: Automatic % (starting at CRUNCHER_OPTIMIZE_START_LEVEL) 2:MagicCruncher (combined with CRUNCHER_OPTIMIZE_MAGICCRUNCHER_SIMILARITY and CRUNCHER_OPTIMIZE_MAGICCRUNCHER_FAST), default: 1
        CRUNCHER_OPTIMIZE_MAGICCRUNCHER_SIMILARITY = MAKE_CUSTOM_ID('M', 'C', 'S', 'M'), //!< UInt: value from 0 to 2, 0: roughly similar, 1: similar, 2: very similar
        CRUNCHER_OPTIMIZE_MAGICCRUNCHER_FAST = MAKE_CUSTOM_ID('M', 'C', 'F', 'S'), //!< UInt, 0: faster magicCruncher, 1: normal (default) process, 1 : accurate process that try to reach the number of points closer to the similarity threshold condition
        CRUNCHER_OPTIMIZE_MODE = MAKE_CUSTOM_ID('M', 'O', 'D', 'E'), //!< UInt, 0: Crunch borders, 1: Protect borders, 2: Exclude Borders, Default: 1
        CRUNCHER_OPTIMIZE_PROGRESSIVE_RATIO = MAKE_CUSTOM_ID('P', 'G', 'R', 'T'), //!< Bool, use progressive ratio when the scene has several objects, default: true
        CRUNCHER_OPTIMIZE_CORNER_MODE = MAKE_CUSTOM_ID('C', 'R', 'M', 'D'), //!< UInt, 0: Don't care corners, 1: preserve corners, 2: protect corners, 3: exclude corners, default: 0
        CRUNCHER_OPTIMIZE_HIDDEN_NODE = MAKE_CUSTOM_ID('H', 'D', 'N', 'D'), //!< Bool, import and optimize hidden node, default: true
        CRUNCHER_OPTIMIZE_MERGE_POINTS = MAKE_CUSTOM_ID('M', 'R', 'G', 'P'), //!< Bool, enable merge of confused points, default: false
        CRUNCHER_OPTIMIZE_MERGE_POINTS_THRESHOLD = MAKE_CUSTOM_ID('M', 'R', 'P', 'T'), //!< Float, confused points distance threshold, default: 0.0f
        CRUNCHER_OPTIMIZE_MERGE_FACES = MAKE_CUSTOM_ID('M', 'R', 'G', 'F'), //!< Bool, merge coplanar faces, default: false
        CRUNCHER_OPTIMIZE_MERGE_FACES_THRESHOLD = MAKE_CUSTOM_ID('M', 'R', 'F', 'T'), //!< Float, coplanar faces threshold angle, default: 0.0f
        CRUNCHER_OPTIMIZE_MATERIAL_FRONTIER = MAKE_CUSTOM_ID('K', 'P', 'M', 'A'), //!< Bool, protect material boundaries if any, default: true
        CRUNCHER_OPTIMIZE_MATERIAL_FRONTIER_MODE = MAKE_CUSTOM_ID('M', 'A', 'M', 'D'), //!< UInt, only if CRUNCHER_OPTIMIZE_MATERIAL_FRONTIER=true, otherwise 0: preserve frontier boundaries, 1: protect frontier boundaries, 2: exclude frontier boundaries
        CRUNCHER_OPTIMIZE_FAVORITE_COMPACITY = MAKE_CUSTOM_ID('C', 'O', 'M', 'P'), //!< Bool, preserve face compacity, default: true
        CRUNCHER_OPTIMIZE_LIMIT_RATIO = MAKE_CUSTOM_ID('L', 'M', 'R', 'T'), //!< Bool, limit ratio and avoid to generate an invalid mesh, default: true
        CRUNCHER_OPTIMIZE_LOCK_POINT = MAKE_CUSTOM_ID('L', 'K', 'P', 'T'), //!< Bool, lock point position, default: false
        CRUNCHER_OPTIMIZE_PREVENT_FLIP = MAKE_CUSTOM_ID('F', 'L', 'I', 'P'), //!< Bool, prevent face flipping, default: true
        CRUNCHER_OPTIMIZE_KEEP_VC = MAKE_CUSTOM_ID('K', 'P', 'V', 'C'), //!< Bool, keep vertex colors if any, default: false
        CRUNCHER_OPTIMIZE_VC_MODE = MAKE_CUSTOM_ID('V', 'C', 'M', 'D'), //!< UInt, only if CRUNCHER_OPTIMIZE_KEEP_VC=true, otherwise 0: preserve VC boundaries, 1: protect VC boundaries, 2: exclude VC boundaries
        CRUNCHER_OPTIMIZE_TOLERANCE_VC = MAKE_CUSTOM_ID('T', 'L', 'V', 'C'), //!< UInt, a threshold value from 0 to 255 corresponding to the difference allowed for RGB values on an edge, default: 128 
        CRUNCHER_OPTIMIZE_KEEP_UV = MAKE_CUSTOM_ID('K', 'P', 'U', 'V'), //!< Bool, keep UVs if any, default: true
        CRUNCHER_OPTIMIZE_UV_MODE = MAKE_CUSTOM_ID('U', 'V', 'M', 'D'), //!< UInt, only if CRUNCHER_OPTIMIZE_KEEP_UV=true, otherwise 0: preserve UV boundaries, 1: protect UV boundaries, 2: exclude UV boundaries
        CRUNCHER_OPTIMIZE_TOLERANCE_UV = MAKE_CUSTOM_ID('T', 'L', 'U', 'V'), //!< Float, a threshold value from 0 to 1.0 corresponding to the difference allowed for UVs values on an edge, default: 128 
        CRUNCHER_OPTIMIZE_KEEP_NORMALS = MAKE_CUSTOM_ID('K', 'P', 'N', 'R'), //!< Bool, keep normals if any, default: false
        CRUNCHER_OPTIMIZE_NORMAL_MODE = MAKE_CUSTOM_ID('N', 'R', 'M', 'D'), //!< UInt, only if CRUNCHER_OPTIMIZE_NORMAL_MODE=true, otherwise 0: preserve normal breaks, 1: protect normal breaks, 2: exclude normal breaks
        CRUNCHER_OPTIMIZE_NORMAL_THRESHOLD = MAKE_CUSTOM_ID('N', 'R', 'T', 'H'), //!< Float, a threshold value from 0 to 90.0 corresponding to the normal angle in degree for normals values between faces under which no break is detected, default: 10.0f 
        CRUNCHER_OPTIMIZE_SYMETRY_MODE = MAKE_CUSTOM_ID('S', 'Y', 'M', 'E'), //!< UInt, 0: no symmetry taken into account, 1: XY symmetry mode, 2: YZ symmetry mode, 3: XZ symmetry mode
        CRUNCHER_OPTIMIZE_SYMETRY_TOLERANCE = MAKE_CUSTOM_ID('S', 'Y', 'T', 'L'), //!< UInt, a tolerance value from 0 to 100 related to point position for considering that two points are symmetric
        CRUNCHER_OPTIMIZE_CONVERT_ONLY = MAKE_CUSTOM_ID('C', 'V', 'O', 'L'), //!< Bool, if true no optimization if performed. The file is read and simply converted without any processing. default: false
        CRUNCHER_DSTNAME_MODE = MAKE_CUSTOM_ID('N', 'A', 'M', 'E'), //!< UInt, 0: ouput files are numbered from 1, 1: output files are numbered using the % ratio value, default: 0
        CRUNCHER_DSTPREFIX_PARAM = MAKE_CUSTOM_ID('D', 'S', 'P', 'X'), //!< String: a prefix to add to the source filename (ie.: optimized_)
        CRUNCHER_DSTSUFFIX_PARAM = MAKE_CUSTOM_ID('D', 'S', 'S', 'X'), //!< String: a suffix to add to the source filename (ie.: _optimized)
        CRUNCHER_DSTMODE_PARAM = MAKE_CUSTOM_ID('D', 'S', 'M', 'D'), //!< UInt: 0: output file are created in the same folder than the source, 1: output files are created in a sub folder of the source file folder, 2: output files are created in a selected directory. Cf. BatchDstMode
        CRUNCHER_DSTSUBDIR_PARAM = MAKE_CUSTOM_ID('D', 'S', 'S', 'D'), //!< String, used internally when CRUNCHER_DSTMODE_PARAM = 1, contains a subdir folder name in a relative form (ie: .\result)
        CRUNCHER_DSTNEWDIR_PARAM = MAKE_CUSTOM_ID('D', 'S', 'N', 'D'), //!< String, contains the sub folder name when CRUNCHER_DSTMODE_PARAM = 1 in a relative form, or contains the destination folder name when CRUNCHER_DSTMODE_PARAM = 2 in a relative form (relative to source folder) or in an absolute form
        CRUNCHER_DSTRECREATEDIR_PARAM = MAKE_CUSTOM_ID('D', 'S', 'R', 'D'), //!< Bool, used when CRUNCHER_DSTMODE_PARAM = 2 and if CRUNCHER_SRCSUBDIR_PARAM=true, recreates the source folders tree in the destination folder
        CRUNCHER_DSTRENAME_PARAM = MAKE_CUSTOM_ID('D', 'S', 'R', 'E'), //!< Bool, rename the destination file in order to newer overwrite a file, default = true
        CRUNCHER_DSTUPDATE_MODE = MAKE_CUSTOM_ID('U', 'P', 'D', 'M'), //!< Bool, the output file use update mode, which try to kept a maximum information, default = false
        CRUNCHER_DSTLOG_NAME = MAKE_CUSTOM_ID('D', 'S', 'L', 'G'), //!< String, log file name path in a relative form (dependent of the destination folder), or in an absolute short, default: empty, meaning no log file is generated
        CRUNCHER_DSTLOG_AUTORENAME = MAKE_CUSTOM_ID('L', 'G', 'R', 'N'), //!< Bool, auto rename the log file name, default: false
        //      CRUNCHER_NOUI = MAKE_CUSTOM_ID('N', 'O', 'U', 'I'), //!< Bool, if set to true it prevents to display any kind of dialog and it guaranties that no user interaction is required during the process
        //      CRUNCHER_AUTOCLOSE = MAKE_CUSTOM_ID('A', 'T', 'C', 'L'), //!< Bool, if set the optimization process automatically close at exit
 
                // 
                // The output format is defined by additional parameters which are described in FormatSelectionParameters (DlgFormatSelection.h)
                // If nothing specified, the optimized file is output using the input format or wavefront format if input format cannot be generated
                //
                // These one are privates tag, use for specific purposes
        CRUNCHER_ALBUMFILES_PARAM = MAKE_CUSTOM_ID('A', 'L', 'F', 'I'), //!< String Array, private, define a second set of files used when album mode is defined.
        CRUNCHER_SELDIR_PARAM = MAKE_CUSTOM_ID('S', 'E', 'D', 'I'), //!< String, a full path to a selected directory (CRUNCHER_SRCMODE_PARAM=2), mainly use in an interactive context to store two different paths (one dependent of the application path, the other dependent of a user defined path)
 
#ifdef PLY_ALPHA_FEATURE
        CRUNCHER_OPTIMIZE_STRENGTH = MAKE_CUSTOM_ID('M', 'O', 'S', 'G'),
        CRUNCHER_CORNER_STRENGTH = MAKE_CUSTOM_ID('C', 'R', 'S', 'G'),
        CRUNCHER_OPTIMIZE_MATERIAL_FRONTIER_STRENGTH = MAKE_CUSTOM_ID('M', 'A', 'S', 'G'),
        CRUNCHER_OPTIMIZE_SMALL_FACE_FIRST = MAKE_CUSTOM_ID('S', 'L', 'F', 'T'),
        CRUNCHER_OPTIMIZE_WEIGHT_MAP = MAKE_CUSTOM_ID('W', 'G', 'M', 'P'),
#endif
    } Parameters;
 
 
    //! @enum DefaultValues
    //! A set of default values for some parameters of the optimization
    typedef enum DefaultValues
    {
        DEFAULT_NORMAL_ANGLE = 10, //!< 10 degree
        DEFAULT_VC_TOLERANCE = 128, //!< 128 (intermediate between 0..255)
        DEFAULT_UV_TOLERANCE = 0, //!< no tolerance
        DEFAULT_SYMETRY_TOLERANCE = 1, //!< nearly exact symetry
        DEFAULT_MERGEPOINTS_TOLERANCE = 0, //!< Points should be confused
        DEFAULT_MERGEFACES_TOLERANCE = 0, //!< faces must be coplanar
    } DefaultValues;
 
    //! @enum BatchCruncherOptionsFlags
    //! Specific options for the batch optimization
    typedef enum BatchCruncherOptionsFlags
    {
        BATCH_CRUNCHER_DEFAULT = 0x00,
 
        //! @name These options give control on the way the batch module is used
        //! @{
        BATCH_HANDLE_SCENE_DELETION = 0x01, //!< The batch handles the scene deletion internally
        BATCH_NO_SPLASH = 0x02, //!< No splash screen is displayed when opening the batch module
        BATCH_NO_LOGWINDOW = 0x04, //!< No log window
        BATCH_NO_DIALOG = 0x08, //!< No dialog, predefined settings must be provided in data field
        BATCH_LOG_AUTOCLOSE = 0x10, //!< The log window closes itself at the end of the process...
        BATCH_NO_CANCEL_BY_ESCAPTE = 0x100, //!< By default the base class cancel the batch by pressing escape
 
        //! @}
 
        //! @name These options give control on the Polygon Cruncher batch dialog
        //! @{
        BATCH_NO_MODE_CHOICE = 0x100, //!< Don't show any mode choice
        BATCH_NO_CURRENT_DIRECTORY_CHOICE = 0x200, //!< Don't show current directory mode
        BATCH_ENABLE_FILE_SELECTION = 0x400, //!< Allow to select files
        BATCH_ALBUM_MODE = 0x800, //!< Replace current directory by current album
 
        //! @}
    } BatchCruncherOptionsFlags;
 
    typedef enum
    {
        CRUNCHER_BATCH_PREFS1 = MAKE_CUSTOM_ID('C', 'R', 'N', 'C'),
        CRUNCHER_BATCH_PREFS2 = MAKE_CUSTOM_ID('B', 'A', 'T', 'C'),
    } BatchEnum;
 
    BatchCruncherOptions(CCustomData& batchSettingsData, unsigned int flags = BATCH_CRUNCHER_DEFAULT);
 
#ifdef __WINDOWS__
    bool InitFromCommandLine(int argc, wchar_t* argv[]);
#else
    bool InitFromCommandLine(int argc, char* argv[]);
#endif
 
    // Can be used to define the initial folder, file or files to optimize
    void SetCurrentFolder(const CXString& folder);
    CXString GetCurrentFolder() const;
    void SetFileToOptimize(const CXString& file);
    void SetFilesToOptimize(const CXStringArray& files, bool albumSet = false);
 
    // Load and save previous preferences
    void SetPreferencesFilePath(const CXString& preffile);
    CXString GetPreferencesFilePath() const;
    void PrefsLoadBatchOptions();
    void PrefsSaveBatchOptions() const;
 
    const CCustomData& GetSettingsData() const { return *(cmddata); }
    unsigned int GetFlags() { return flags; }
 
protected:
    unsigned int flags; // Options flags (BatchCruncherOptionsFlags)
    CXString preferencePath;
    CCustomData* cmddata; // Data provided to call the batch module remotely
};
 
typedef C3DScene* (*LoadCruncherBatchCallback)(const CXString& filename, CSceneImportOptions& options, CXString& resultTxt, void* data); //!< A callback for loading a 3D file specified by its filename and giving some options. It returns the loaded scene. resultTxt can returns some textual information about the load operation.
typedef bool (*SaveCruncherBatchCallback)(bool freeSceneOnly, const CFileNameSpec& filename, CSceneExportOptions& options, C3DScene* optimizedResult, CXString& resultTxt, void* data); //!< A callback for saving a to file using some options and the provided scene. If freeSceneOnly, then the scene must be released using C3DScene::Delete(). resultTxt can returns some textual information about the load operation.
typedef bool (*CruncherProgressCallback)(unsigned int cruncherProgressFlags, const CruncherProgressInfo& info, void* data); //!< Progress callback. cruncherProgressFlags is a combination of CruncherProgress flags which inform about the useful data to retrieve in CruncherProgressInfo.
 
//! @class CBatchOptimizer
//! @brief CBatchOptimizer allows to perform batch optimization providing BatchCruncherOptions settings and calling CBatchOptimizer::Batch.
//! @details It is possible to provide different kind of callback for handling an user progress bar or provide a customized load / save 3d file mechanism.
class DLLFUNCTION CBatchOptimizer
{
public:
    //! @enum BatchState
    //! The batch running state which is provided to CBatchOptimizer::OnBatchStateChanged
    typedef enum BatchState XEnumType(unsigned int)
    {
        BATCH_INACTIVE = 0,
            BATCH_INIT_BEFORE_BATCH, //!< A place to set a first initialization. info is a bool set to true by default. If set to false GetBatchInfoHelper is not initialized with the providing settings (useful for specific purpose if overidding settings by dialog user choices for example)
            BATCH_BEFORE_OPEN_LOG_FILE, //!< info is a const pointer to the log filename
            BATCH_AFTER_OPEN_LOG_FILE,
            BATCH_START_BATCH, //!< The batch will start to load file and process them. The following event sequence will occurs each time a file is processed.
            BATCH_PRELOAD_FILE,
            BATCH_POSTLOAD_FILE, //!< info is a bool that allow to know if load succeed or fails
            BATCH_PREPROCESS,
            BATCH_POSTPROCESS,
            BATCH_PREOPTIMIZE,
            BATCH_POSTOPTIMIZE,
            BATCH_PREMAGICCRUNCHER,
            BATCH_POSTMAGICCRUNCHER,
            BATCH_PRESAVE_SCENE,
            BATCH_POSTSAVE_SCENE,  // info is a bool that allow to know if save succeed or fails
            BATCH_FREE_SCENE,
            BATCH_END_BATCH, //!< The batch is over, all file have been processed
    } BatchState;
 
private:
    const BatchCruncherOptions* settings;
    BatchState state;
 
    // Callback for loading and saving file if needed
    SaveCruncherBatchCallback saveCallback; // Callback for saving scene
    LoadCruncherBatchCallback loadCallback; // Callback for loading scene
    CruncherProgressCallback progressCallback;
    void* callbackData;
 
    //CXStringArray selfiles;
    //CXStringArray albumfiles;
    CXString optimizedFilePath;
 
    CXString prevLogLine;
    void* logCallbackData;
    CStdioFileEx* logFile;
 
    // These variable are valid during the batch
    BatchInfo batchInfoHelper; // This is a helper used during the batch process and initialized before the batch process using the provided settings, or dialog user settings
    unsigned int outputFormatMode, outputFormat, inputFormat;
    CHashTable<CXString> hashExt;
    CHashTable<CXString> fileWritten;
 
    xWndHandle pParentWindow; // A possible parent window
 
public:
    CBatchOptimizer(const BatchCruncherOptions& settings, xWndHandle parentWindow = NULL); //!< Initialize an optimization batch providing specific settings through BatchCruncherOptions
    virtual ~CBatchOptimizer() {};
 
    const CCustomData& GetSettingsData() const { return *(settings->cmddata); }
    void SetSettingsData(const CCustomData& settingsData);
    unsigned int GetFlags() const { return settings->flags; } //!< Return BatchCruncherOptionsFlags flags
    xWndHandle GetParentWindow() const { return pParentWindow; } //!< optional parent window for overidden classes
    CStdioFileEx* GetLogFile() const { return logFile; } //!< return the log file
 
    BatchInfo& GetBatchInfoHelper(bool initFromSettings = false); //!< Can be used by dialog to get folder from settings. If initFromSettings set, the batchinfo is initialized from BatchCruncherOptions
 
    //!< @name Batch callbacks
    void SetCallbackData(void* data); //!< Sets an opaque pointer which is provided in the different callbacks
    void SetProgressCallback(CruncherProgressCallback callback); //!< Provides a progress callback to provide feedback to user
    void SetLoadCallback(LoadCruncherBatchCallback callback); //!< Provides a callback for loading files which can be used instead of the default callback.
    void SetSaveCallback(SaveCruncherBatchCallback callback); //!< Provides a callback for saving files which can be used instead of the default callback. The callback is repeatedly called for the same loaded scene, depending on the requested optimization ratio for the batch operation.
 
    CXString GetCurrentOptimizedFilePath() const { return optimizedFilePath; } //!< Returns the currently processed file
    BatchState GetBatchState() const { return state; }  //!< Returns the current batch state
 
    virtual bool CheckCancel(); //!< Override to handle cancel on the process. Returning true will cancel the operation cancel 
    virtual void OnBatchStateChanged(BatchState state, void* info) {};  //!< Override this method to catch some different step in the batch
 
    virtual void Log(const CXString& loginfo, bool replacePrevLine = false); //!< Override this method to catch different log information
    virtual bool Batch(); //!< Start the batch using the provided BatchCruncherOptions settings.
 
protected:
    virtual bool DoBatch(); // Begin the batch itself
 
    void SetBatchState(BatchState state, void* info = NULL);
 
    void InitBeforeBatch(); // Send BATCH_INIT_BEFORE_BATCH
    void InitOutputFormatParams(const CFileNameSpec& filename);
    bool FileMatch(const CXString& name);
 
    bool LoadFiles(const CXString& dir);
    bool LoadFileToCallback(const CXStringArray& files);
    bool SaveScene(bool freeScene, const CXString& name, C3DScene* scene, int iscene = 0, double ratio = 0, int scenenbr = 0);
 
    static C3DScene* DefaultLoadSceneCallback(const CXString& filename, CSceneImportOptions& options, CXString& resultTxt, void* data);
    static bool DefaultSaveSceneCallback(bool freeSceneOnly, const CFileNameSpec& filename, CSceneExportOptions& options, C3DScene* sceneResult, CXString& resultTxt, void* data);
    static bool DefaultProgressCallback(unsigned int progresstype, const CruncherProgressInfo& progressInfo, void* data);
};
 
#define CRUNCHER_CRASH_FILE_KEY _T("CurrentOptimizedFile")
 
#ifdef MOOTOOLS_AUTODESK
// No specifics
bool DoBatchOptimization(CBatchOptimizer& options);
#endif
 
#if defined(MOOTOOLS_PRODUCT_BUILD)
#if defined(MOOTOOLS_MFC_PRODUCT_BUILD)
typedef struct _CruncherInfo
{
    COptimizerWnd* pWindow;
    CSceneOptimizer* pOptimizer;
    CCruncherSheet* pSheet;
    unsigned int flags;
 
    _CruncherInfo()
    {
        pWindow = NULL;
        pOptimizer = NULL;
        pSheet = NULL;
        flags = 0;
    };
} CruncherInfo;
 
DLLFUNCTION HINSTANCE CruncherResourceHandle();
DLLFUNCTION CruncherInfo* InitOptimizer(C3DScene*, CFileNameSpec& fileSpec, CWnd* pDisableWindow, unsigned int flags);
DLLFUNCTION void StartOptimizer(CruncherInfo*, float);
DLLFUNCTION C3DScene* GetOptimizerResult(CruncherInfo*);
DLLFUNCTION void StopOptimizer(CruncherInfo*, CWnd* pEnableWindow);
DLLFUNCTION bool DoBatchOptimization(CBatchOptimizer& options);
#endif // MOOTOOLS_MFC_PRODUCT_BUILD
#endif
 
// Debug
#ifndef MOOTOOLS_NO_DEBUG_HANDLER
void SetCurrentOptimizedFile(const CXString& file = CXString());
DLLFUNCTION void SetupCruncherCrashHandler(bool install);
#else
#define SetCurrentOptimizedFile(...) __noop
#endif
 
END_MOOTOOLS_NAMESPACE
 
#endif // POLYGONCRUNCHER_INTERFACE_H