3mfw.hpp

Go to the documentation of this file.

#ifndef _3MFW_HPP_
#define _3MFW_HPP_
#include "def/define.h"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/error_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
//! \defgroup 3mfw_utils 3mf Write Util Functions
//! \brief.
 
//! \class Dtk_3MFWriter 
//! \brief 3MF Writer main class.
//! \brief Exported APIs for 3mf (.3mf) Write Library
class Dtk_3MFWriter
{
public:
     //! \class WriteOptions 
     //! \brief This class provides several options to tune 3mf Writer.\n
     //! It must be provided to _3mfw::InitWrite method.
     //! \code
     //! //...
     //! Dtk_string LogFile = L"MyLogFile.log";
     //! Objw::WriteOptions ObjOptions;
     //! Dtk_ErrorStatus err = Objw::InitWrite( LogFile, ObjOptions);
     //! //...
     //! \endcode
     class WriteOptions
     {
     public:
          Dtk_bool m_OneMeshPerFace;
          //! \BaseConstructor
          WriteOptions()
          {
               m_OneMeshPerFace = DTK_FALSE;
          }
 
          //! \BaseDestructor
          ~WriteOptions()
          {
          }
 
     };
 
     //! \ingroup 3mfw_utils
     //! \brief Constructor : Initialize the writer for a FBX File.
     Dtk_3MFWriter( );
 
     //! \ingroup 3mfw_utils
     //! \brief Destructor,   Save the current work into a FBX file.
     ~Dtk_3MFWriter();
 
     //! \ingroup 3mfw_utils
     //! \brief Initialize the 3mf Writer  
     //! \return dtkNoError if it is OK.
     //! \param [in] inOutputFile : Output file name
     //! \param [in] inLogFile : Log file
     //! \param [in] inOptions : Options
     //! \remark This function is the first call for the writer, it must me called after Dtk_API::StartAPI(...)
     DtkErrorStatus InitWrite( const Dtk_string& inOutputFile, const Dtk_string& inLogFile, const WriteOptions& inOptions );
 
     //! \ingroup 3mfw_utils
     //! \brief Creation of the output file and free the Obj Writer  
     //! \return dtkNoError if it is OK.
     //! \remark used as the last function used for the writer.
     DtkErrorStatus EndWrite();
 
     //! \ingroup 3mfw_utils
     //! \brief Write the entity provided in parameter in a node. 
     //! \param [in] inEntity : The Entity to be written
     //! \return dtkNoError if it is OK.
     //! \remark This function is used to write entities (only Dtk_MeshPtr ) .
     Dtk_ErrorStatus WriteEntity( const Dtk_EntityPtr& inEntity );
 
     //! \ingroup 3mfw_utils
     //! \brief Open a new instance node for internal tree.
     //! \return dtkNoError if ok.
     //! \param [in] inInstanceName : Instance name
     //! \param [in] inProtoID : provide a proto ID if you need to reinstanciate it later. Provide -1 if not.
     //! \param [out] outWasAlreadyInstancied : gives back if this was reinstanciated (same ID given another time), in this case, previous prototype under instance is linker, you should just call CloseLastInstance.
     //! \param [in] inTrans : Matrice to apply on the instance
     //! \param [in] inRgb : Instance color (not yet supported)
     Dtk_ErrorStatus OpenInstance( const Dtk_string& inInstanceName, Dtk_Int64 inProtoID,
                                          Dtk_bool& outWasAlreadyInstancied, const Dtk_transfo& inTrans = Dtk_transfo(), const Dtk_RGB& inRgb = Dtk_RGB() );
     //! \ingroup 3mfw_utils
     //! \brief Close last instance node for internal tree. It should be called as many time as OpenInstance is called.
     //! \return dtkNoError if ok.
     Dtk_ErrorStatus CloseLastInstance();
 
private:
     // Anticopy methods.
     Dtk_3MFWriter( const Dtk_3MFWriter& )
     {
     }
     Dtk_3MFWriter& operator=( const Dtk_3MFWriter& )
     {
          return *this;
     }
 
public:
     // Internal data
     void* m_p;
 
};
 
#endif