Io3dmgr.h

Go to the documentation of this file.

//! @file Io3dmgr.h
//! @brief 3D import / export classes definitions
//! 
//////////////////////////////////////////////////////////////////////////////////////////
 
#ifndef IO3DMGR_H
#define IO3DMGR_H
 
#include "IoCommon.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//////////////////////////////////////////////////////////////////////////////////////////
//! @name Common import/export options
//! @{
#define COMMON_IMPORT_COPY_EMBED_TO_DIR MAKE_CUSTOM_ID('C', 'Y', 'E', 'M') //!< String: a path where to copy the embedded textures (use by FBX/SKP/GLTF). When use the embeded media are extracted and not deleted. Otherwise embeded content is extracted on scene opening and deleted when scene is released
#define COMMON_IMPORT_FROM_MEMORY_DATA MAKE_CUSTOM_ID('I', 'M', 'M', 'D') //!< Binary: a memory block containing the data file that is used for parsing (GLTF/SKP). Note, that the filename is required because it defined the memory block format as well as a path that can be useful for textures, or default name.
#define COMMON_EXPORT_TO_MEMORY MAKE_CUSTOM_ID('E', 'X', 'M', 'M') //!< Bool: false by default, set to true if you require an export to a memory data block (GLTF). Once output performed, the memory data block can be retrieved thourgh the parser options COMMON_EXPORT_MEMORY_DATA. filename is required as it defined the output format.
#define COMMON_EXPORT_MEMORY_DATA MAKE_CUSTOM_ID('E', 'M', 'M', 'D') //!< Binary: a memory data block that is used for parsing the specific file format instead of the provided filename. Note, that the filename is required as it defined the memory block format as well as a a file path that can be used for textures, or default name.
 
//! @}
 
//! @name FBX import / export options
//! @{
#define FBX_EXPORT_OPTION_EMBEDDED_MEDIA MAKE_CUSTOM_ID('E', 'M', 'B', 'D') //!< Bool: Write optionBoolean options for embedded media. If set to true, FBX will embed media when writting
#define FBX_IO_OPTION_PASSWORD MAKE_CUSTOM_ID('P', 'S', 'W', 'D') //!< CXString: String that contains a password to read/write the fbx
#define FBX_EXPORT_OPTION_SAVE_MATID MAKE_CUSTOM_ID('M', 'T', 'I', 'D') //!< Unsigned int: Save material ID in properties (not used)
#define FBX_EXPORT_OPTION_FBX_VERSION MAKE_CUSTOM_ID('F', 'X', 'V', 'S') //!< Unsigned int (FbxExportVersion): The fbx target version to use
#define FBX_EXPORT_OPTION_FBX_ASCII MAKE_CUSTOM_ID('F', 'X', 'I', 'I') //!< bool: set to true to export in ASCII
#define FBX_EXPORT_CONVERT_MATERIAL_TO_STANDARD MAKE_CUSTOM_ID('C', 'V', 'S', 'T') //!< bool: true convert pbr material to standard material
#define FBX_EXPORT_KEEP_PBR_FORMAT MAKE_CUSTOM_ID('K', 'P', 'P', 'B') //!< bool: keep the input PBR format if defined (max or Maya)
#define FBX_EXPORT_PBR_FORMAT MAKE_CUSTOM_ID('C', 'V', 'P', 'B') //!< UInt: 0: 3ds max PBR format, 1: Maya PBR format
 
//! @enum FbxExportVersion
//! Defines the FBX file version to use with FBX_EXPORT_OPTION_FBX_VERSION
typedef enum  FbxExportVersion XEnumType(unsigned int)
{
    FBX_2010 = 2010,
    FBX_2011 = 2011,
    FBX_2012 = 2012,
    FBX_2013 = 2013,
    FBX_2014 = 2014,
    FBX_2016 = 2016,
    FBX_2018 = 2018,
    FBX_2019 = 2019,
    FBX_2020 = 2020,
    FBX_MOST_RECENT = 0, //!< The native fbx version of the Fbx SDK
    FBX_DEFAULT_VERSION = FBX_MOST_RECENT,
} FbxExportVersion;
 
//! @}
 
//! @name JT import / export options
//! @{
#define JT_IO_OPTION_SIEMENS_ID MAKE_CUSTOM_ID('S', 'I', 'E', 'M') //!< Unsigned Integer that contains a password to register siemens toolkit. If not defined, evaluation scheme is used, meaning that the parser will fails once evaluation period is over
#define JT_IO_OPTION_FLAGS MAKE_CUSTOM_ID('J', 'T', 'F', 'G') //!< Unsigned int : flags for control on import / export, Cf. JTIoFlags
#define JT_IMPORT_OPTION_SPECIFIC_LOD MAKE_CUSTOM_ID('S', 'L', 'O', 'D') //!< Unsigned int : define a specific LOD to load
 
//! @enum JTIoFlags
//! Use these flags to keep control on the JT import / export process using settings JT_IO_FLAGS through CSceneExportOptions::GetData / CSceneImportOptions::GetData
typedef enum  JTIoFlags XEnumType(unsigned int)
{
    JT_UNDEFINED_FLAGS = 0x00,
 
    // Import options
    JT_IMPORT_CONCATENATE = 0x01, //!< Concatenate meshes that are part of the same assembly
    JT_IMPORT_LOAD_LOD = 0x02, //!< Load a specific lod meshes, which is defined by JT_IO_SPECIFIC_LOD
 
    // Private flags do not use these flags
    JT_PRIVATE_FLAGS = 0xFF000000,
    JT_UPDATE_STORE = 0x01000000,
    JT_DO_UPDATE = 0x02000000,
} JTIoFlags;
 
//! @}
 
//! @name Sketchup import / export options
//! @{
#define SKP_IMPORT_TRIANGULATE MAKE_CUSTOM_ID('T', 'R', 'I', 'A') //!< Bool: always uses internal sketchup trianguler
#define SKP_IMPORT_FORCE_AFFINE_UV MAKE_CUSTOM_ID('A', 'F', 'U', 'V') //!< Bool: true by default - Reduce the number of texture by considering that all transformation are affine. Provide the parameter with false to get an accurate projection which might result in a large texture file amount.
#define SKP_IMPORT_FORCE_TEXTURE_FORMAT MAKE_CUSTOM_ID('T', 'X', 'T', 'F') //!< Unsigned int: 0 (default): native sketchup texture format. 1: texture are converted to PNG format. 2: Texture are converted to JPG format (transparency loss)
#define SKP_IMPORT_COLLAPSE_LIVECOMPONENT MAKE_CUSTOM_ID('L', 'V', 'C', 'L') //!< Bool: Concatenate live component sub hierarchy to a single node
#define SKP_IMPORT_COLLAPSE_DEFINITION MAKE_CUSTOM_ID('S', 'M', 'Y', 'D') //!< Bool: collapse definition
#define SKP_IMPORT_COLLAPSE_GROUP MAKE_CUSTOM_ID('S', 'M', 'Y', 'G') //!< Bool: collapse group
#define SKP_IMPORT_SKIP_CURVE MAKE_CUSTOM_ID('S', 'K', 'C', 'R') //!< Bool: skip curves
#define SKP_IMPORT_TRACK_SKPID MAKE_CUSTOM_ID('S', 'K', 'T', 'K') //!< Bool: track skp ids to know what id is in mootools object
#define SKP_EXPORT_VERSION MAKE_CUSTOM_ID('S', 'K', 'V', 'R') //!< UInt: version to export: 
 
//! @enum SkpExportVersion
//! Defines the Sketchup file version to use with SKP_EXPORT_VERSION
typedef enum  SkpExportVersion XEnumType(unsigned int)
{
    SKP_2013 = 2013,
        SKP_2014 = 2014,
        SKP_2015 = 2015,
        SKP_2016 = 2016,
        SKP_2017 = 2017,
        SKP_2018 = 2018,
        SKP_2019 = 2019,
        SKP_2020 = 2020,
        SKP_2021 = 2021,
        SKP_MOST_RECENT = 0, // The native skp version of the SKP SDK
        SKP_DEFAULT_VERSION = SKP_MOST_RECENT,
} SkpExportVersion;
 
//! @}
 
//! @name GLTF import / export options
//! @{
#define GLTF_IMPORT_WELD_POINTS MAKE_CUSTOM_ID('W', 'E', 'L', 'D') //!< Bool: weld points at import
#define GLTF_EXPORT_OPTION_EMBEDDED_MEDIA MAKE_CUSTOM_ID('E', 'M', 'B', 'D') //!< Bool: Write optionBoolean options for embedded media. If set to true, GLTF will embed media when writting
#define GLTF_EXPORT_JPEG_COMPRESSION MAKE_CUSTOM_ID('J', 'G', 'C', 'M') //!< UInt: JPEG compression factor
#define GLTF_EXPORT_JPEG_MODE MAKE_CUSTOM_ID('J', 'G', 'M', 'D') //!< UInt: false (0): native texture format, 1 : JPG except if transparencies or normal map, 2: JPG except if normal map, 3 : always Jpeg.
 
//! @}
 
//! @name Wavefront import / export options
//! @{
#define OBJ_IO_FILE_ENCODING MAKE_CUSTOM_ID('W', 'V', 'E', 'N') // UInt: encoding file mode when reading / writing (0: utf8, 1: unicode, 2: ansi), default: 0 under Windows/linux. 2: only available on Windows. If a UTF8/Unicode BOM character is found, the file is read accordingly whatever the mode
 
//! @}
 
// Private settings
#define PRIVATE_IO_SPECIFIC_OPTIONS MAKE_CUSTOM_ID('S', 'P', 'C', 'I') // String: a key for defining particular option (private usage)
 
//! @}
 
class C3DIo;
 
//! @class CSceneImportOptions 
//! @brief This class is used to provide some specific options when loading scene file
class DLL_3DFUNCTION CSceneImportOptions : public CIoOptions
{
    friend C3DIo;
 
public:
    //! User control on importation (one or more SCENE_IMPORT_FLAGS)
    longuint flags;
 
    // Data used internally (filled by the parsers)
    unsigned int swapmode;
    UP_AXIS_MODE axismode;
    longuint neededflags;
    longuint defaultflags;
    
    CSceneImportOptions(unsigned int flags = SCENE_IMPORT_DEFAULT);
    
protected:
    virtual void InheritFromDefault(const CSceneImportOptions& defaultOptions); // Some parsers have constraints. Inherits theses constraints from the defaultOptions of the parser
    virtual void InitFromSavedPrefs(const CCustomData& data); // Load settings from a saved preference file
    virtual const CCustomData& SaveToSavedPrefs(); // Converts settings to be saved to preference file
};
 
//! @class CSceneExportOptions 
//! @brief This class is used to provide some specific options when exporting a 3D scene
class DLL_3DFUNCTION CSceneExportOptions : public CIoOptions
{
    friend C3DScene;
    friend C3DIo;
 
private:
    CHashMap<CXString, CXString, CXString> textureMap; // Map to avoid duplicating the same texture
    CHashTable<CXString> textureNames; // used textured names for generating single name
    C3DScene *sceneToDelete; // TODO: made deprecated in futur
 
    CXString CheckNames(bool makeUnique, const CXString& inname, CHashTable<CXString>& names, unsigned int size, unsigned int options, xStringEncoding encoding, const CXString& defaultName);
 
public:
    //! User control on exportation
    //! Combination of SCENE_EXPORT_FLAGS provided by the caller.\n
    //! It is used to prepare the scene to be saved. Ie if caller set SCENE_EXPORT_GLOBAL_COORDINATES | SCENE_EXPORT_TRIANGULATE then a triangulated scene with global coordinates will be saved.\n
    //! When calling C3DIo::Save with options not NULL, provided flags are used completed with the parser specified neededflags
    longuint flags; 
 
    //! @name Data used internally (filled by the parsers and option dialogs)
    //! @{
    unsigned int swapmode;
    UP_AXIS_MODE axismode;
    longuint neededflags; //!< Fill by the parser. A combination of SCENE_EXPORT_FLAGS that are absolutely required.
    longuint defaultflags; //!< Fill by the parser. A combination of SCENE_EXPORT_FLAGS that could be used or are better to use, but are not mandatory.
    UNIT_MODE targetunit; //!< define the I/O required unit
    
    //! @}
    
    int ptsLimit, faceLimit; //!< Max number of point & face supported by the I/O
 
    //! @name The following options are used when a name SCENE_EXPORT_MAKE_UNIQUE_NAME is defined
    //! @{
    unsigned int nameLimit; //!< Default: 0 (inactive). Max number of characters for node names. Use SCENE_OPTIONS_MAKE_NAME to define the limit.
    unsigned int materialNameLimit; //!< Default: 0 (inactive). Max number of characters for node names. Use SCENE_OPTIONS_MAKE_NAME to define the limit.
    xStringEncoding nameEncoding; //!< Default: xStringDefaultEncoding. Force name to have a specific encoding which guarantee that the texture name (for example ASCII text) will be the same that the file name (which is by default Unicode). Use xStringDefaultEncoding to keep default (unicode)
    CXString filename; //!< The output filename
 
    //! @}
 
    //! @name The following options are used when copying the texture files to a given location (SCENE_EXPORT_COPY_TEXTURES must be set)
    //! @{
    CXString texturePath; //!< To be defined. Target path for texture unless textureLocalPathOnly is set to true. In that case, texture are made local to the target scene path.
    bool textureLocalPathOnly; //!< Default: false. Textures are made local to the target scene path. texturePath is ignored.
    unsigned int textureNameLimit; //!< Default: 0 (inactive). Max number of characters for filename (ie textures when moved). Use SCENE_OPTIONS_MAKE_NAME to define the limit.
    xStringEncoding textureNameEncoding; //!< Default: xStringDefaultEncoding. Force texture name to have a specific encoding which guarantee that the texture name (for example ASCII text) will be the same that the file name (which is by default Unicode). Use xStringDefaultEncoding to keep default (unicode)
 
    //! @}
 
    //! @name Information about the InitExport process which prepares the scene provided to C3DIo::Save before exportation
    //! @{
    CXString previousFilename; //!< The original file path of the scene, which can differs if the file is converted
    bool saveInDifferentPath; //!< Simple way to know if the saved scene is saved in a different location than the original file. That can be helpful to prevent overwrite some original files
    bool saveInDifferentFormat; //!< Simple way to know if the saved scene is saved in a different location than the original file. That can be helpful to prevent overwrite some original files
 
    //! @}
 
    CSceneExportOptions(unsigned int flags = SCENE_EXPORT_DEFAULT);
    static CSceneExportOptions *Create(unsigned int flags = SCENE_EXPORT_DEFAULT); //!< Create and allocate a CSceneExportOptions that can be deleted using Delete(). Use xNew internally.
    bool Delete();
 
    CXString GetUniqueTextureFilename(const CXString& fullTexturePath, const CXString& suffix = CXString(), bool fileMustNotExist = false); //!< Return a name that comply the io specification (name limit, encoding...). The name is always different than the input name, but this can be a file already existing unless fileMustNotExist = true
 
protected:
    virtual void InheritFromDefault(const CSceneExportOptions& defaultOptions); // Some parsers have constraints. Inherits theses constraints from the defaultOptions of the parser
    virtual void InitFromSavedPrefs(const CCustomData& data); // Load settings from a saved preference file
    virtual const CCustomData& SaveToSavedPrefs(); // Converts settings to be saved to preference file
 
    CXString GetPreviousTexturePath(const CXString& fullTexturePath);
};
 
//! @class C3DIo
//! @brief C3DIo class handles reading / writing / updating 3D file.
//! @details File formats are recocognized using the file extension. C3DIo then select accordingly the C3DParser class which has be registered using fileRegisterFile to handle the file format.
//! Some options might be provided to specify particular options using CSceneImportOptions / CSceneExportOptions.\n
//! Cf. #3DIO to get more information on the way to read/write scene
class DLL_3DFUNCTION C3DIo : public CFileIo
{
    private:
        bool prepareDone;
 
        CFileParser *InitParser();
        virtual void CloseParser();
 
    #ifndef MOOTOOLS_NO_UI
        bool LoadOptionsDialog(CSceneImportOptions& options);
        bool SaveOptionsDialog(CSceneExportOptions& options);
#if 0
        IoShowDialog MustShowDialog();
 
#endif // 0
#endif
 
    public:
        C3DIo(const CFileNameSpec&, unsigned int flags, CXWnd *pParent = NULL);
        C3DIo(unsigned int fileclass, unsigned int flags, CXWnd *pParent = NULL);
        virtual ~C3DIo();
 
        const C3DParser *GetParser() const;
        C3DParser *GetParser();
        
        bool GetLoadOptionsPrefs(CSceneImportOptions& options) const; //!< Load some default load options that might have been saved in preferences
        bool GetSaveOptionsPrefs(CSceneExportOptions& options) const; //!< Load some default save options that might have been saved in preferences
 
        static void InitLoadOptionsFromPrefsData(unsigned int fileClass, CSceneImportOptions& options, const CCustomData& savedPrefs); //!< Load some default load options that might have been saved in preferences
        static void InitSaveOptionsFromPrefsData(unsigned int fileClass, CSceneExportOptions& options, const CCustomData& savedPrefs); //!< Load some default load options that might have been saved in preferences
 
        static bool ReleaseParser(bool readingParser, unsigned int parser, void *parserData);
        static bool CanUpdate(unsigned int inputFormat, unsigned int outputFormat); //!< Determine in outputformat can handle inputformat update mode (ie gtlf -> glb)
        static bool CanUpdate(unsigned int fileclass, C3DScene *scene = NULL); //!< Determine if a fileclass is able to update file, and if scene is provided checks that the scene contains the required information to update
 
        bool PrepareReading(CSceneImportOptions *options = NULL);
        bool PrepareSaving(CSceneExportOptions *options = NULL);
 
#ifndef MOOTOOLS_NO_UI
        static CXString GetParametersInfo(const CCustomData& data, unsigned int fileclass, bool loading);
        static bool DisplayFormatDialog(unsigned int fileclass, bool loading, CCustomData *data, CXWnd *pParent);
 
        virtual C3DScene *Read(bool needOptions, CSceneImportOptions *options = NULL, longuint additionalFlags = SCENE_IMPORT_DEFAULT); //!< if options provided, it is used. The dialog can be shown to the user, but the options are not saved to the prefs. If options not specified, additionalFlags allow to set specific flags once the format dialog has been shown to the user and its choice saved to the prefs.
        virtual bool Save(bool needOptions, C3DScene *, CSceneExportOptions *options = NULL, longuint additionalFlags = SCENE_EXPORT_DEFAULT); //!< if options provided, it is used. The dialog can be shown to the user, but the options are not saved to the prefs. If options not specified, additionalFlags allow to set specific flags once the format dialog has been shown to the user and its choice saved to the prefs.
 
 
        C3DScene *Read(CSceneImportOptions *options = NULL)
        {
            return Read(false, options);
        }
 
        bool Save(C3DScene *scene, CSceneExportOptions *options = NULL)
        {
            return Save(false, scene, options);
        }
#else
        virtual C3DScene *Read(CSceneImportOptions *options = NULL);
        virtual bool Save(C3DScene *, CSceneExportOptions *options = NULL);
#endif
};
 
void RegisterIOPlugins();
void FreeIOPlugins();
 
class C3DExportSheet;
 
//! @class C3DParser
//! @brief Class for reading / writing a specific file format. If is called by C3DIo when extension has been recognized to belong to the parser recognized extension.
//! @details Cf. #3DPARSER if you intend to implement your own 3D parser
class DLL_3DFUNCTION C3DParser : public CFileParser
{
    protected:
        C3DScene *ioscene;
 
    public:
        C3DParser(CFileIo& io);
        virtual ~C3DParser() {};
 
        void SetScene(C3DScene *scene) { ioscene = scene; } //!< This is the scene to save. When update or save is called, this scene has been prepared accordingly to the CSceneExportOptions. Before that (ie. when the options dialog is called, the scene is the original input scene to save). Parser should not release this scene
        C3DScene *GetScene() { return ioscene; } //!< When reading, this is the read scene, when saving, this is the input scene or the scene prepared with InitExport
#if 0
        virtual IoShowDialog MustShowDialog()
        {
            return CFileParser::MustShowDialog();
        }
 
#endif // 0
 
        //! @name Reading a 3D file related methods
        //! @{
        virtual void LoadDefaultOptions(CSceneImportOptions& options) const {};
#ifndef MOOTOOLS_NO_UI
        virtual bool LoadOptionsDialog(CSceneImportOptions& options) { return true; }
        virtual CXString GetLoadParametersInfo(CSceneImportOptions& options); //!< Return a string that describe the reading settings
#endif
        virtual C3DScene *Read(const CXString& filename, CSceneImportOptions& options) //!< options might be modified by the parser to specify some CheckoutImport specific requirements (ie. SCENE_IMPORT_KEEP_GUID might be set if GUID are found)
        {
            return NULL;
        };
 
        //! @}
 
        //! @name Writing a 3D scene related methods
        //! @{
        virtual void SaveDefaultOptions(CSceneExportOptions& options) const {};
        virtual void CheckSaveOptions(C3DScene *scene, CSceneExportOptions& options) const {}; //!< Last way to check possible mutual exclusive flags considering the scene before export (ie embed media and copy textures)
#ifndef MOOTOOLS_NO_UI
        virtual bool SaveOptionsDialog(CSceneExportOptions& options); //!< Overrides the default dialog if needed
        virtual CXString GetSaveParametersInfo(CSceneExportOptions& options);  //!< Return a string that describe the saving settings
#endif
        virtual bool Save(const CXString& filename, C3DScene *scene, CSceneExportOptions& options) //!< options might  be modified by the parser (futur usage)
        {
            io->SetIoError(IO_FILE_UNKNOWN_FILE_TYPE);
            return false;
        }
 
        //! @}
 
        //! @name Update mechanism.
        //! 
        //! if parserClass != UNKNOWN_CLASS we are testing if the parser has update ability for the given format.\n
        //! It is the class of the parser that generate parserData. Some parser might register several class, ie for binary and ascii version of the same format.\n
        //! 
        //! CanUpdate must verify that the parserClass is one of the recognized class and if so it can return true, so Update method is allowed to be called.\n
        //! if parserData = NULL && parserClass == UNKNOWN_CLASS, returns true if the parser is able to update, false if not.\n
        //! if parserData != NULL => parserClass != UNKNOWN_CLASS, parserData MUST HAVE BEEN generated by the parser itself, to correctly cast the content of the data.\n
        //! In this case, the parser checks that provided data allows to perform the update.\n
        //! Some parser stores data, but these data does not contains the information needed to perform the update.\n
        //! Ie. Jt parser can contains both temporary texture path to delete once scene closed but also contains data for updating.\n
        //! @{
        virtual bool CanUpdate(unsigned int parserClass = UNKNOWN_CLASS, void *parserData = NULL) const
        {
            return false;
        }
 
        virtual bool Update(const CXString& filename, C3DScene *scene, void *parserScene, CSceneExportOptions& options)
        {
            io->SetIoError(IO_FILE_UNKNOWN_FILE_TYPE);
            return false;
        }
        //! @}
 
        //! @name Parser specific information
        //! Some specific information might be attached to the scene using an opaque pointer and C3DScene::SetParserData.\n
        //! When the scene is destroyed, the C3DParser::ReleaseParser is called with the opaque pointer, so some clean up can be done.\n
        //! For example the information can contain some information about where embed textures were extracted and give a chance to delete the texture file.\n
        //! This can be a pointer to an internal scene for the update mechanism (Collada)\n
        //! This can be some information to release once the scene is destroyed (Kmz)\n
        //! In most of case, this mechanism is used when reading, rarely when saving...
        virtual bool ReleaseParser(bool readingParser, void *parserScene)
        {
            return false;
        }
};
 
END_MOOTOOLS_NAMESPACE
 
#endif /* IO3DMGR_H */