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

#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"
#include "BoostPreprocessorThread.h"
#include "RenderSampler.h"
#include "ResourceManager.h"
#include "GlRenderer.h"

#define USE_EXE_PATH false

#include <crtdbg.h>

using namespace GtpVisibilityPreprocessor;

Preprocessor *preprocessor = NULL;
GlRenderWidget *renderWidget = NULL;


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

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


void DisplayWidget()
{
        // note matt: capsulate qt dependent code as good as possible
        renderWidget = 
                new GlRenderWidget(preprocessor->mSceneGraph, 
                                                   preprocessor->mViewCellsManager, 
                                                   preprocessor->mKdTree);

        renderWidget->Show();

#if QT_ENABLED

        // create a qt application first (must be created before any opengl widget ...)
        app = new QApplication(argc, argv);

        if (!QGLFormat::hasOpenGL() || !QGLPixelBuffer::hasOpenGLPbuffers()) {
                QMessageBox::information(0, "OpenGL pbuffers", 
                        "This system does not support OpenGL/pbuffers.",
                        QMessageBox::Ok);
                return -1;
        }
        
        // note matt: capsulate qt dependent code as good as possible
        rendererWidget = 
                new GlRendererWidget(p->mSceneGraph, p->mViewCellsManager, p->mKdTree);

        rendererWidget->resize(640, 480);
        rendererWidget->show();

        if (0 && p->GetRenderer()) 
        {
                cout<<"CONNECTING"<<endl;
                QObject::connect(p->GetRenderer(),
                SIGNAL(UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &)),
                                rendererWidget->mControlWidget, 
                                SLOT(UpdatePvsErrorItem(int i,
                                GlRendererBuffer::PvsErrorEntry &)));

                cout<<"CONNECTED"<<endl;
        }
#endif
}


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() {
        _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
        _CrtSetReportMode(_CRT_ASSERT,_CRTDBG_MODE_FILE);
        _CrtSetReportFile(_CRT_ASSERT,_CRTDBG_FILE_STDERR); 

        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);
        preprocessor->LoadScene(filename);

        //-- build kd tree from scene geometry

        preprocessor->BuildKdTree();
        preprocessor->KdTreeStatistics(cout);

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

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


        // create a preprocessor thread
        //PreprocessorThread *pt = new PreprocessorThread(p, app);
        BoostPreprocessorThread pt(preprocessor);

        if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
        {
                // display the render widget
                DisplayWidget();

                // create and run the preprocessor application in a parallel thread
                pt.InitThread();
                pt.RunThread();
        } 
        else
        {
                // just call the mail method -> will be executed in the main thread
                pt.Main();
        }


        Cleanup();

        return returnCode;
}