source: GTP/trunk/Lib/Vis/Preprocessing/src/main.cpp @ 1344

#ifdef GTP_INTERNAL
//#define USE_QT 0
#endif

#define USE_BOOST 1

#ifdef UNICODE
#undef UNICODE
#endif

#include <windows.h>
#include <stdio.h>
#include <crtdbg.h>

#include "SamplingPreprocessor.h"
#include "VssPreprocessor.h"
#include "RssPreprocessor.h"
#include "ExactPreprocessor.h"
#include "Parser.h"
#include "UnigraphicsParser.h"
#include "X3dParser.h"
#include "Environment.h"
#include "Camera.h"
#include "MeshKdTree.h"
#include "Exporter.h"
#include "ViewCell.h"
#include "SceneGraph.h"

#if USE_BOOST
#include "BoostPreprocessorThread.h"
#endif

#include "RenderSampler.h"
#include "ResourceManager.h"
#include "GlRenderer.h"

#if USE_QT
#include "QtRenderer/QtGlRenderer.h"
#endif

#define USE_EXE_PATH false


using namespace GtpVisibilityPreprocessor;

Preprocessor *preprocessor = NULL;
GlRendererWidget *rendererWidget = NULL;

// DLL function signature
typedef GlRendererWidget *(*importFunction)(Preprocessor *);


int LoadMyDll()
{
        importFunction LoadRenderWidget;

        // Load DLL file
        HINSTANCE hinstLib = LoadLibrary("../QtGlRenderer/Release/QtGlRenderer.dll");

        if (hinstLib == NULL) 
        {
                cout << "ERROR: unable to load DLL\n";
                return 1;
        }
  
        // Get function pointer
        LoadRenderWidget = (importFunction)GetProcAddress(hinstLib, "LoadRenderWidget");
  
        if (LoadRenderWidget == NULL) 
        {
                cout << "ERROR: unable to find DLL function\n";
                return 1;
        }

        cout << "loading widget ... ";
        // load the render window
        rendererWidget = LoadRenderWidget(preprocessor);
        cout << "finished" << endl;
        // Unload DLL file
        //FreeLibrary(hinstLib);
  
        return 0;
}


void Cleanup()
{
        DEL_PTR(rendererWidget);
        DEL_PTR(preprocessor);

        Environment::DelSingleton();
        MeshManager::DelSingleton();
        MaterialManager::DelSingleton();
}


void DisplayWidget()
{
        if (!rendererWidget)
        {
                LoadMyDll();
        }
        
  //rendererWidget->Show();
}


string ReplaceSuffix(string filename,
                                         string a,
                                         string b)
{
  string result = filename;

  int pos = (int)filename.rfind(a, (int)filename.size() - 1);
  if (pos == filename.size() - a.size()) {
        result.replace(pos, a.size(), b);
  }
  return result;
}

int
main(int argc, char **argv)
{

        //Now just call this function at the start of your program and if you're
        //compiling in debug mode (F5), any leaks will be displayed in the Output
        //window when the program shuts down. If you're not in debug mode this will
        //be ignored. Use it as you will!
        //note: from GDNet Direct [3.8.04 - 3.14.04] void detectMemoryLeaks() {
#if 0
  _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
  _CrtSetReportMode(_CRT_ASSERT,_CRTDBG_MODE_FILE);
  _CrtSetReportFile(_CRT_ASSERT,_CRTDBG_FILE_STDERR); 
#endif

        int returnCode = 0;
        
        InitTiming();

        Debug.open("debug.log");
  
        Environment::GetSingleton()->Parse(argc, argv, USE_EXE_PATH);
        MeshKdTree::ParseEnvironment();

        
        char buff[128];
        Environment::GetSingleton()->GetStringValue("Preprocessor.type", buff);
        string preprocessorType(buff);

        if (preprocessorType == "vss")
        {
                preprocessor = new VssPreprocessor();
        }
        else
        {
                if (preprocessorType == "rss")
                {
                        preprocessor = new RssPreprocessor();
                }
                else
                {
                        if (preprocessorType == "exact")
                        {
                                preprocessor = new ExactPreprocessor();
                        }
                        else
                        {
                                if (preprocessorType == "sampling")
                                {
                                        preprocessor = new SamplingPreprocessor();
                                }
                                else
                                {       
                                        if (preprocessorType == "render")
                                        {
                                                preprocessor = new RenderSampler();
                                        }
                                        else 
                                        {
                                                Environment::DelSingleton();
                                                cerr<<"Unknown preprocessor type"<<endl;
                                                Debug<<"Unknown preprocessor type"<<endl;
                                                exit(1);
                                        }
                                }
                        }
                }
        }

        ////////////////////////////////////////
        //-- load scene 

        Environment::GetSingleton()->GetStringValue("Scene.filename", buff);
        string filename(buff);

        if (!preprocessor->LoadScene(filename))
        {
                cout << "loading file " << filename << " failed" << endl;
                Cleanup();
                exit(1);
        }

        string rayCastFile = ReplaceSuffix(filename, ".obj", ".kdf");

        //-- initialize external ray casters
        if (preprocessor->InitRayCast(rayCastFile))
        {
                cout << "ray casting initialized!" << endl;
        }
        else
        {
                cout << "ray casting initialization failed" << endl;
                Cleanup();
                exit(1);
        }

        //-- build kd tree from scene geometry
        preprocessor->BuildKdTree();
        preprocessor->KdTreeStatistics(cout);

        /*preprocessor->mKdTree->ExportBinTree("kd.bin.gz");
        MeshManager::GetSingleton()->ExportEntries("meshes.bin");

        KdTree *kdTree2 = new KdTree;

        cout << "loading kd tree ... ";
        long startTime = GetTime();
        kdTree2->LoadBinTree("kd.bin.gz", preprocessor->mObjects);
                
        cout << "finished in " << TimeDiff(startTime, GetTime()) * 1e-3 << " secs" << endl;

        Exporter *exporter = Exporter::GetExporter("testkd.x3d");
        MeshManager::GetSingleton()->ExportEntries("meshes.bin");

        if (exporter) 
        {
                exporter->SetWireframe();
                exporter->ExportKdTree(*kdTree2, true);

                delete exporter;
        }

        DEL_PTR(kdTree2);
*/
        // parse view cells related options
        preprocessor->PrepareViewCells();

        if (0) 
        {
                preprocessor->Export(filename + "-out.x3d", true, false, false);
                preprocessor->Export(filename + "-kdtree.x3d", false, true, false);     
        }

        // create a preprocessor thread (note: capsulates calls to boost fuctions!)
        //PreprocessorThread *pt = PreprocessorThreadFactory::Create(preprocessor);
#if USE_BOOST
        BoostPreprocessorThread pt(preprocessor);
#endif
        
        bool guiSupported = false;
        if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
        {
                cout << "using gl widget" << endl;
                // create and run the preprocessor application in a parallel thread
#if USE_BOOST
                pt.InitThread();
#endif
                //pt.RunThread();

                // display the render widget
                if (!rendererWidget) 
                {
#if !USE_QT
                        guiSupported = LoadMyDll();
#else
                        rendererWidget = new QtGlRendererWidget(preprocessor->mSceneGraph,
                                preprocessor->mViewCellsManager,
                                preprocessor->mKdTree);
#endif
                }

        }
        
        if (!guiSupported) {
          preprocessor->mUseGlRenderer = false;
          preprocessor->mUseGlDebugger = false;
        }
        
        if (!(preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)) {
          // just call the mail method -> will be executed in the main thread
#if USE_BOOST
          pt.Main();
#endif
        }
        
        Cleanup();
        
        return returnCode;
}