testlibcolladawrite.cpp File Reference

Functions
int	ColladaWriteSample (const Dtk_string &inResultDirectory)

Function Documentation

ColladaWriteSample()

int ColladaWriteSample

(

const Dtk_string &

inResultDirectory

)

{
     Dtk_ErrorStatus               err = dtkNoError;
     int                           status;
     Dtk_MeshPtr                   cubeMesh = NULL;
     Dtk_MeshPtr                   cubeMeshVC = NULL;
     Dtk_MeshPtr                   cylinderMesh = NULL;
     Dtk_MeshPtr                   wireMesh = NULL;
     Dtk_ModelDisplayPtr           modelDisplay = NULL;
     Dtk_RenderInfosPtr            renderInfos = NULL;
     Dtk_string                    outputFileName, outputDirectory;
     Dtk_string                    nodeName;
     Dtk_tab<Dtk_MetaDataPtr>      tabMetadata;
     Dtk_tab<Dtk_ID>               tabNodesView1;
     Dtk_tab<Dtk_ID>               tabNodesView2;
     Dtk_tab<Dtk_ID>               tabNodesView3;
     Dtk_tab< Dtk_tab <Dtk_ID> >   tabNodesViews;
     Dtk_ID                        nodeID = 0;
     Dtk_bool                      reinstanciate = DTK_TRUE;
     Dtk_InfoPtr info;
 
     cout << endl << "----------------------------------------------" << endl;
     cout << "Collada Write start" << endl;
 
     // Choosing output directory and file name
     outputDirectory = inResultDirectory + L"Collada/";
     outputDirectory.FixPathSeparator();
     outputDirectory.mkdir();
     outputFileName = outputDirectory + L"sample.dae";
 
     // Cube Sample
     cubeMesh = sampleWriter::CreateMeshCube();
     sampleWriter::FillFacesColors( cubeMesh );
 
     // Cylinder Sample
     cylinderMesh = sampleWriter::CreateMeshCylinder( 30 );
 
     //RenderInfos Sample
     renderInfos = sampleWriter::CreateCubeRenderInfos();
 
     // First we initialize writing 
     Colladaw::WriteOptions options;
     options.ConvertRenderInfos = 1;
 
     status = Colladaw::InitWrite( outputFileName, Dtk_string( "testcolladaw.log" ), options );
 
     if( status != 0 )
     {
          err = Colladaw::EndWrite(); 
          cout << "error : " << dtkTypeError( status ).c_str() << endl;
          return status;
     }
 
     // Lets write a small assembly composed by one cube and one cylinder
 
     // let a matrix moving the cube on the left
     Dtk_transfo cubetransfo;
     cubetransfo.addTranslate( Dtk_dir( -10, 0, 0 ) );
 
     // let a matrix moving the cylinder
     Dtk_transfo cyltransfo;
     cyltransfo.addTranslate( Dtk_dir( 10, 0, 0 ) );
 
     // let a matrix moving the first instance
     Dtk_transfo transfo;
     transfo.addTranslate( Dtk_dir( 100, 100, 100 ) );
     transfo.setXdir( 0.0, 1.0, 0.0 );
     transfo.setYdir( 0.0, 0.0, 1.0 );
     transfo.setZdir( 1.0, 0.0, 0.0 );
 
     // Rootnode creation
     if( err == dtkNoError )
     {
          nodeName = "RootNode";
          err = Colladaw::InitNode( nodeName );
     }
     // Facetted data node creation
     if( err == dtkNoError )
     {
          nodeName = "Facetted data";
          info = Dtk_Info::create();
          err = Colladaw::InitNode( nodeName, Dtk_transfo(), info, nodeID );
     }
 
     // from this node, create a Child for the cube, giving its matrix, and naming it "Cube"
     if( err == dtkNoError )
     {
          nodeName = "Cube";
          err = Colladaw::InitNode( nodeName, cubetransfo );
     }
     cubeMesh->info() = Dtk_Info::create();
     cubeMesh->info()->AddRenderInfos( renderInfos );
     // Write the mesh cube
     if( err == dtkNoError )
          Colladaw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cubeMesh ) );
     // Close the mesh cube node
     if( err == dtkNoError )
          err = Colladaw::EndNode();
 
     // From root node again, create a Child for the cylinder, giving its matrix, and naming it "Cylinder"
     if( err == dtkNoError )
     {
          nodeName = "Cylinder";
          err = Colladaw::InitNode( nodeName, cyltransfo );
     }
     // Write the mesh cylinder
     if( err == dtkNoError )
          err = Colladaw::WriteEntity( Dtk_EntityPtr::DtkDynamicCast( cylinderMesh ) );
     // Close the mesh cylinder
     if( err == dtkNoError )
          err = Colladaw::EndNode();
     // Close the facetted data node
     if( err == dtkNoError )
          err = Colladaw::EndNode();
 
     if( reinstanciate )
     {
          // "Facetted data (Reinstanciated)" creation
          if( err == dtkNoError )
          {
               nodeName = "Facetted data (Reinstanciated)";
               err = Colladaw::InitNode( nodeName, transfo );
          }
          // Reinstanciating prototype nodeID
          if( err == dtkNoError )
               err = Colladaw::ReinstanciatePrototype( nodeID );
          // Closing node
          if( err == dtkNoError )
               err = Colladaw::EndNode();
     }
     // Rootnode closing : VERY IMPORTANT, you must close all nodes that were opened.
     if( err == dtkNoError )
          err = Colladaw::EndNode();
     // And free memory allocated for writing
     if( err == dtkNoError )
          err = Colladaw::EndWrite();
 
     cout << "=> " << outputFileName.c_str() << endl << "Collada Write end" << endl;
 
     return err;
}