3dxmlw.hpp

Go to the documentation of this file.

#ifndef _3DXMLW_HPP_
#define _3DXMLW_HPP_
 
 
//! \brief Exported APIs for 3dxml (.3dxml) Write Library
namespace _3dxmlw 
{
     //! \class WriteParameters 
     //! \brief This class provides several parameters to tunes 3dxml Writter.\n
     //! It must be provided to addInstance3D method.
     //! \code
     //! //...
     //! \endcode
     class WriteParameters
     {
     protected:
          Dtk_Int32           _Blanked;
          Dtk_FontLineType    _CurveType;
          Dtk_RGB                  _Color;
          Dtk_Double64        _CurveThickness;
          Dtk_bool            _HasMaterial;
          Dtk_string               _MaterialName;
          Dtk_Double64        _MaterialAmbient;
          Dtk_Double64        _MaterialDiffuse;
          Dtk_Double64        _MaterialSpecular;
          Dtk_Double64        _MaterialRefraction;
          Dtk_Double64        _MaterialTransparency;
          Dtk_Double64        _MaterialReflectivity;
          Dtk_RGB                  _MaterialAmbientColor;
          Dtk_RGB                  _MaterialDiffuseColor;
          Dtk_RGB                  _MaterialSpecularColor;
     public:
          //! \BaseConstructor
          WriteParameters()
               :_Blanked(0)
               , _CurveType( DTK_NO_PATTERN )
               , _Color( Dtk_RGB() )
               , _CurveThickness( 0 )
               , _HasMaterial( false )
               , _MaterialName( L"" )
               , _MaterialAmbient( 0 )
               , _MaterialDiffuse( 0 )
               , _MaterialSpecular( 0 )
               , _MaterialRefraction( 0 )
               , _MaterialTransparency( 0 )
               , _MaterialReflectivity( 0 )
               , _MaterialAmbientColor( Dtk_RGB() )
               , _MaterialDiffuseColor( Dtk_RGB() )
               , _MaterialSpecularColor( Dtk_RGB() )
          {
          }
 
          //! \BaseDestructor
          ~WriteParameters()
          {
          }
 
          //! \brief Sets the blanked status for the written instance node.
          //! \param [in] inBlanked : blanked status.
          inline void SetBlankedStatus( const Dtk_Int32 inBlanked )
          {
               _Blanked = inBlanked;
          }
          //! \brief Retrieve the Written blanked status.
          inline Dtk_Int32 GetBlankedStatus() const
          {
               return _Blanked;
          }
          //! \brief Sets the color for the written instance node.
          //! \param [in] inColor : color.
          inline void SetColor( const Dtk_RGB & inColor )
          {
               _Color = inColor;
          }
          //! \brief Retrieve the Written color.
          inline Dtk_RGB GetColor() const
          {
               return _Color;
          }
          //! \brief Sets the curve type for the written instance node.
          //! \param [in] inCurvetype : curve type.
          inline void SetCurveType( Dtk_FontLineType inCurveType )
          {
               _CurveType = inCurveType;
          }
          //! \brief Retrieve the Written curve type.
          inline Dtk_FontLineType GetCurveType() const
          {
               return _CurveType;
          }
          //! \brief Sets the curve thickness for the written instance node.
          //! \param [in] inCurveThickness : curve thickness.
          inline void SetCurveThickness( Dtk_Double64 inCurveThickness )
          {
               _CurveThickness = inCurveThickness;
          }
          //! \brief Retrieve the Written curve thickness.
          inline Dtk_Double64 GetCurveThickness() const
          {
               return _CurveThickness;
          }
 
          //! \brief Sets material parameters to be applied on the written instance node.
          inline void SetMaterial( const Dtk_string & inMaterialName,
                                         const Dtk_RGB & inAmbientColor = Dtk_RGB(),
                                         const Dtk_RGB & inDiffuseColor = Dtk_RGB(),
                                         const Dtk_RGB & inSpecularColor = Dtk_RGB(),
                                         Dtk_Double64 inAmbient = 0,
                                         Dtk_Double64 inDiffuse = 0,
                                         Dtk_Double64 inSpecular = 0,
                                         Dtk_Double64 inRefraction = 0,
                                         Dtk_Double64 inTransparency = 0,
                                         Dtk_Double64 inReflectivity = 0 )
          {
               _HasMaterial = true;
               _MaterialName = inMaterialName;
               _MaterialAmbientColor = inAmbientColor;
               _MaterialDiffuseColor = inDiffuseColor;
               _MaterialSpecularColor = inSpecularColor;
               _MaterialAmbient = inAmbient;
               _MaterialDiffuse = inDiffuse;
               _MaterialSpecular = inSpecular;
               _MaterialRefraction = inRefraction;
               _MaterialTransparency = inTransparency;
               _MaterialReflectivity = inReflectivity;
          }
 
          //! \brief Clears material parameters for the written instance node.
          inline void ClearMaterial()
          {
               _HasMaterial = false;
               _MaterialName = L"";
          }
 
          //! \brief Returns whether a material was actually set on this instance.
          //! \remark Guards against a stale/garbage _HasMaterial flag: a material is only
          //! considered present if a non-empty material name was actually provided via SetMaterial().
          inline Dtk_bool HasMaterial() const { return _HasMaterial && !_MaterialName.is_NULL() && _MaterialName.len() > 0; }
          inline Dtk_string GetMaterialName() const { return _MaterialName; }
          inline Dtk_Double64 GetMaterialAmbient() const { return _MaterialAmbient; }
          inline Dtk_Double64 GetMaterialDiffuse() const { return _MaterialDiffuse; }
          inline Dtk_Double64 GetMaterialSpecular() const { return _MaterialSpecular; }
          inline Dtk_Double64 GetMaterialRefraction() const { return _MaterialRefraction; }
          inline Dtk_Double64 GetMaterialTransparency() const { return _MaterialTransparency; }
          inline Dtk_Double64 GetMaterialReflectivity() const { return _MaterialReflectivity; }
          inline Dtk_RGB GetMaterialAmbientColor() const { return _MaterialAmbientColor; }
          inline Dtk_RGB GetMaterialDiffuseColor() const { return _MaterialDiffuseColor; }
          inline Dtk_RGB GetMaterialSpecularColor() const { return _MaterialSpecularColor; }
     };
 
    //! \class WriteOptions 
    //! \brief This class provides several options to tune 3dxml Writer.\n
    //! It must be provided to _3dxmlw::InitWrite method.
    //! \code
    //! //...
    //! Dtk_string LogFile = L"MyLogFile.log";
    //! _3dxmlw::WriteOptions 3DxmlOptions;
    //! Dtk_ErrorStatus err = _3dxmlw::InitWrite( LogFile, 3DxmlOptions);
    //! //...
    //! \endcode
    class WriteOptions
    {
    protected:
 
    public:
        //! \BaseConstructor
        WriteOptions() {}
 
        //! \BaseDestructor
        ~WriteOptions() {}
 
    };
 
    //! \brief Initialize the 3dxmlw 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, WriteOptions& inOptions);
 
    //! \brief Creation of the output file and free the 3dxmlw Writer  
    //! \return dtkNoError if it is OK.
    //! \remark used as the last function used for the writer.
    DtkErrorStatus EndWrite();
 
    //! \brief Don't create a component already viewed. Is instantiate by an instance 
    //! \param [in] inCurrentChildId : Current child id
    //! \return DTK_TRUE if component already exist.
    //! \remark 
     Dtk_bool isAlreadyAddComponent(Dtk_ID inCurrentChildId);
 
    //! \brief Create Reference3D node
    //! \param [in] inName : Node Name
     //! \param [in] inComponentId : Component id
     //! \param [in] inMetadata : metadata
    //! \return 
    //! \remark  : add only V_description
     void addReference3D(const Dtk_string & inName, Dtk_ID inComponentId,Dtk_tab<Dtk_MetaDataPtr> & inMetadata);
 
    //! \brief Create ReferenceRep node
     //! \param [in] inMesh : Mesh Array
    //! \param [in] inName : Node Name
     //! \param [in] inComponentId : Component id
    //! \return 
    //! \remark
     void addReferenceRep(const Dtk_tab<Dtk_MeshPtr> & inMesh, const Dtk_string & inName, Dtk_Size_t inComponentId);
 
    //! \brief Create Instance3D node
     //! \param [in] inParentId : Parent id
     //! \param [in] inChildId : Child id
     //! \param [in] inMatrix : Instance matrix
    //! \param [in] inInstanceName : Instance Name
     //! \param [in] inMetadata : metadata
     //! \param [in] inParameters : parameters
    //! \return 
     //! \remark  : add only V_description
     void addInstance3D( Dtk_ID parentId,
                              Dtk_ID ref3dId,
                              const Dtk_transfo &matrix,
                              const Dtk_string &objectName,
                              Dtk_MetaDataPtr & inMetadata,
                              const WriteParameters & inParameters = WriteParameters() );
}
 
#endif