Ejemplo n.º 1
0
//////////////////////////////////////////////////////////////////////////
//
// Class ModelManagerSlaver
// 
void ModelManagerWrapper::AddMesh( const std::wstring& meshID, const std::wstring& meshFilename, const std::wstring& textureFilename )
{
	ModelManager* pModelMan = MyIrrlichtEngine::GetEngine()->GetModelManager();

	pModelMan->AddMesh( meshID, meshFilename, textureFilename );

}
Ejemplo n.º 2
0
bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  //Create the topics
  SimEventsUtils::createTopic(communicator(), "SalientPointMessageTopic");

  //Create the adapter
  sprintf(adapterStr, "default -p %i", RobotBrainObjects::RobotBrainPort);
  itsAdapter = communicator()->createObjectAdapterWithEndpoints("SaliencyModule",
                                                                adapterStr);

  //Create the manager and its objects
  itsMgr = new ModelManager("SaliencyModuleService");

  LINFO("Starting SaliencyModule");
  nub::ref<SaliencyModuleI> ret(new SaliencyModuleI(*itsMgr));
  itsMgr->addSubComponent(ret);

  ret->init(communicator(), itsAdapter);

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}
Ejemplo n.º 3
0
bool SeaBee3GUIService::start(int argc, char* argv[])
{
  QApplication app(argc, argv);

  itsMgr = new ModelManager("SeaBeeIIIGUIManager");

  char adapterStr[255];
  LINFO("Creating Adapter");
  sprintf(adapterStr, "default -p %i", 12345);
  itsAdapter = communicator()->createObjectAdapterWithEndpoints("RobotBrainPort",
      adapterStr);

  nub::ref<MainWindow> mainWindow(new MainWindow(*itsMgr));
  itsMgr->addSubComponent(mainWindow);

  LINFO("Starting Up GUI Comm");
  mainWindow->initIce(communicator(), itsAdapter);

  itsMgr->parseCommandLine(argc, argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  mainWindow->setGeometry(100,100,900,800);
  mainWindow->show();

  return app.exec();
}
Ejemplo n.º 4
0
void CompanyWidget::setup(int companyType, bool isFin, bool isContact,
                          bool isAdd, bool isLabel)
{
    ui->finFrame->setHidden(!isFin);
    ui->contactFrame->setHidden(!isContact);
    ui->addCompany->setHidden(!isAdd);
    ui->typeLabel->setHidden(!isLabel);

    this->companyType = companyType;

    ModelManager *models = ModelManager::getInstance();

    if (isContact) {
        contactF = new SortFilterModel(this);
        contactF->setFilterRole(ContactModel::companyIdRole);
        contactF->setSourceModel(models->getContactModel());
        ui->contact->setModel(contactF);
    }

    SortFilterModel *companyF = new SortFilterModel(this);
    companyF->setFilterRole(CompanyModel::typeRole);
    companyF->setMatchValue(companyType);
    companyF->setSourceModel(models->getCompanyModel());
    ui->company->setModel(companyF);

    if (companyType == Company::CUSTOMER) {
        ui->typeLabel->setText(QString::fromUtf8("Заказчики"));

    } else if  (companyType == Company::SUPPLIER) {
        ui->typeLabel->setText(QString::fromUtf8("Поставщики"));

    }  else if  (companyType == -1) {
        ui->typeLabel->setText(QString::fromUtf8("Компании"));
    }
}
Ejemplo n.º 5
0
bool RobotBrainServiceService::start(int argc, char* argv[])
#endif	
{
  MYLOGVERB = LOG_INFO;

  char adapterStr[255];

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  // try to connect to ports until successful
  LDEBUG("Opening Connection");
  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("GistSal_Navigation", adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
  itsMgr = new ModelManager("BeoLocalizationService");

  LINFO("Starting BeoLocalization System");
  nub::ref<BeoLocalizer>
    bl(new BeoLocalizer
        (*itsMgr, "BeoLocalizer", "BeoLocalizer"));
  LINFO("BeoLocalizer created");
  itsMgr->addSubComponent(bl);
  LINFO("BeoLocalizer Added As a subcomponent");
  bl->init(communicator(), itsAdapter);
  LINFO("BeoLocalizer initiated");

  // check command line inputs/options
  if (itsMgr->parseCommandLine((const int)argc, (const char**)argv,
                               "", 0, 0)
      == false) return(1);

  // FIXXX: in the future the map should be specificable 
  //        from the command line to allow for stand alone application

  // check app-Beobot2_GistSalLocalizer.C


  // activate manager and adapter
  itsAdapter->activate();
  itsMgr->start();

  return true;
}
Ejemplo n.º 6
0
bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  while(!connected)
    {
      try
        {
          LINFO("Trying Port:%d", port);
          sprintf(adapterStr, "default -p %i", port);
          itsAdapter = communicator()->createObjectAdapterWithEndpoints("SeaBee3SimulatorAdapter",
                                                                        adapterStr);
          connected = true;
        }
      catch(Ice::SocketException)
        {
          port++;
        }
    }

  //Create the manager and its objects
  itsMgr = new ModelManager("SeaBee3SimulatorServiceManager");

  nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(*itsMgr));
  itsMgr->addSubComponent(ofs);


  LINFO("Starting SeaBee3 Simulator");
  nub::ref<SeaBee3Simulator> subSim(new SeaBee3Simulator(*itsMgr, "SeaBee3Simulator", "SeaBee3Simulator"));
  itsMgr->addSubComponent(subSim);
  subSim->init(communicator(), itsAdapter);

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  while(1){
    Layout<PixRGB<byte> > outDisp;

    subSim->simLoop();
    Image<PixRGB<byte> > forwardCam = flipVertic(subSim->getFrame(1));
    Image<PixRGB<byte> > downwardCam = flipVertic(subSim->getFrame(2));

    outDisp = vcat(outDisp, hcat(forwardCam, downwardCam));

    ofs->writeRgbLayout(outDisp, "subSim", FrameInfo("subSim", SRC_POS));

    handle_keys(ofs, subSim);
  }


  return true;
}
Ejemplo n.º 7
0
bool RobotBrainServiceService::start(int argc, char* argv[])
#endif	
{
  MYLOGVERB = LOG_INFO;

  char adapterStr[255];

  //Create the topics
//  SimEventsUtils::createTopic(communicator(), "BeoGPSMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  // try to connect to ports until successful
  LDEBUG("Opening Connection");
  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("BeoGPS", adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
  itsMgr = new ModelManager("BeoGPSService");

  LINFO("Starting BeoGPS System");
  nub::ref<BeoGPS> gps(new BeoGPS(*itsMgr, "BeoGPS", "BeoGPS"));
  LINFO("BeoGPS created");
  itsMgr->addSubComponent(gps);
  LINFO("BeoGPS Added As a subcomponent");
  gps->init(communicator(), itsAdapter);
  LINFO("BeoGPS initiated");

  // check command line inputs/options
  if (itsMgr->parseCommandLine
      (argc, argv, "<serdev>", 0, 0) == false)
    return(1);

  // let's configure our serial device:
//   gps->configureSerial(itsMgr->getExtraArg(0));
//   LINFO("Using: %s", itsMgr->getExtraArg(0).c_str());

  // activate manager and adapter
  itsAdapter->activate();
  itsMgr->start();

  return true;
}
Ejemplo n.º 8
0
MsgDialog::MsgDialog(QWidget *parent) :
    QDialog(parent),
    ui(new Ui::MsgDialog)
{
    ui->setupUi(this);

    ModelManager *models = ModelManager::getInstance();
    ui->clients->setModel(models->getClientModel());
}
Ejemplo n.º 9
0
PythonSceneNode ModelManagerWrapper::AddSceneNodeByMeshID( const std::wstring& meshID, bool bTestCollision /*= false */ )
{
	ModelManager* pModelMan = MyIrrlichtEngine::GetEngine()->GetModelManager();

	PythonSceneNode node;
	scene::ISceneNode* pNode = pModelMan->AddSceneNodeFromMesh( meshID, bTestCollision );
	node.ptr = pNode;
	//pNode->drop();		// 引用减一
	return node;
}
Ejemplo n.º 10
0
int main(const int argc, const char **argv)
{

  MYLOGVERB = LOG_INFO;
  ModelManager *mgr = new ModelManager("Extract Patches for Hmax with Feature Learning");

  mgr->exportOptions(MC_RECURSE);

  // required arguments
  // <c1patchesDir> <trainPosDir>

  if (mgr->parseCommandLine(
                            (const int)argc, (const char**)argv, "<c1patchesDir> <trainPosDir>", 2, 2) == false)
    return 1;

  // Create a temp HmaxFL object to extract C1Patches
  std::vector<int> c1ScaleSS(2);
  c1ScaleSS[0] = 1; c1ScaleSS[1] = 3;
  std::vector<int> c1SpaceSS(2);
  c1SpaceSS[0] = 10; c1SpaceSS[1] = 11;
  // desired frame sizes [11 and 13]
  HmaxFL hmax(NORI,c1SpaceSS,c1ScaleSS,2,true,1.0F,1.0F,0.3F,4.05F,-0.05F,11,2);

  std::string c1PatchesBaseDir;
  std::string trainPosName; // Directory where positive images are

  c1PatchesBaseDir = mgr->getExtraArg(0);
  trainPosName = mgr->getExtraArg(1);

  // Extract random patches from a set of images in a positive training directory
  std::vector<std::string> trainPos = hmax.readDir(trainPosName);
  int posTrainSize = trainPos.size();

  //Image<byte> inputb;

  Image<float> trainPosImage;

  std::cout << "Scanned training and testing images" << std::endl;

  std::vector<int> pS(4);
  pS[0] = 4; pS[1] = 8, pS[2] = 12; pS[3] = 16;

  std::srand(time(0));
  for(int i=0;i<NUM_PATCHES_PER_SIZE;i++){
    // Randomly select an image from the list
    unsigned int imInd = static_cast<unsigned int>(floor((rand()-1.0F)/RAND_MAX*posTrainSize));
    trainPosImage = Raster::ReadFloat(trainPos[imInd]);
    // Learn the appropriate simple S2 patches from the C1 results
    hmax.extractRandC1Patch(c1PatchesBaseDir,trainPosImage,i,pS);
  }

  std::cout << "Completed extraction of C1 Patches" << std::endl;

  return 0;
}
Ejemplo n.º 11
0
void ToolWidget::on_ambientButton_clicked()
{
    ModelManager* model = mainWindow->getModelManager();
    if (!model->openLight()) {
        QMessageBox::critical(this, "Error", "Fail to open new light");
    }
    mainWindow->getViewManager()->repaintAll();
    ui->ambientButton->setEnabled(model->canOpenLight());

    updateLightBox();
    updateLightCanOpen();
}
Ejemplo n.º 12
0
void ToolWidget::on_tabWidget_currentChanged(QWidget *arg1)
{
    if (arg1 == ui->solidTab) {
        mainWindow->getModelManager()->selectSolid(selectedSolid);
        mainWindow->getViewManager()->repaintAll();
    } else if (arg1 == ui->primitiveTab) {
        ModelManager* model = mainWindow->getModelManager();
        ASolid* solid = model->getSolidFromPmt(selectedPrimitive);
        model->selectSolid(solid);
        mainWindow->getViewManager()->repaintAll();
    }
}
Ejemplo n.º 13
0
void ModelPanel::LoadDataFromScene()
{
	ModelManager* modelMgr = gEngine->GetModelManager();
	std::list<Model*> modelList = modelMgr->GetModelList();

	wxTreeItemId rootId = mTreeCtrl->AddRoot(L"root", 0, 0, New ModelTreeItemData(NULL));

	for(std::list<Model*>::iterator iter = modelList.begin(); iter != modelList.end(); ++iter)
	{
		Model* model = *iter;
		appendModel(rootId, model);
	}
}
Ejemplo n.º 14
0
void ToolWidget::on_visiblePmtBtn_clicked()
{
    ModelManager* model = mainWindow->getModelManager();
    ASolid* solid = model->getSolidFromPmt(selectedPrimitive);
    if (solid) {
        solid->setVisible(!solid->getVisible());
        mainWindow->getViewManager()->repaintAll();
        if (ui->visiblePmtBtn->text() == "Hide") {
            ui->visiblePmtBtn->setText("Show");
        } else {
            ui->visiblePmtBtn->setText("Hide");
        }
    }
}
Ejemplo n.º 15
0
bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  LINFO("Creating Topic!");
  //Create the topics
//  SimEventsUtils::createTopic(communicator(), "BinFinderMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;
  LDEBUG("Opening Connection");

  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("BinFinder",
          adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
        itsMgr = new ModelManager("BinFinderService");

  LINFO("Starting BinFinder");
  nub::ref<BinFinder> ret
    (new BinFinder(*itsMgr, "BinFinder1", "BinFinder2"));
  LINFO("BinFinder Created");
  itsMgr->addSubComponent(ret);
  LINFO("BinFinder Added As Sub Component");
  ret->init(communicator(), itsAdapter);
  LINFO("BinFinder Inited");

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}
Ejemplo n.º 16
0
bool Predictor::Store(std::ostream& os)
{
    ModelManagerFactory mmf(ModelManager::PARAMFILE);
    ModelManager* pModelManager = mmf.Make();
    if(!pModelManager)
    {
        TERR("unable to make ModelManager.");
        return false;
    }
    bool bRet = pModelManager->Store(mpTreeBoost, os);
    if(pModelManager)
        delete pModelManager;
    return bRet;
}
Ejemplo n.º 17
0
// ######################################################################
bool RobotBrainServiceService::start(int argc, char* argv[])
{
    MYLOGVERB = LOG_INFO;

    char adapterStr[255];

    //Create the adapter
    int port = RobotBrainObjects::RobotBrainPort;
    bool connected = false;

    // try to connect to ports until successful
    LDEBUG("Opening Connection");
    while(!connected)
    {
        try
        {
            LINFO("Trying Port:%d", port);
            sprintf(adapterStr, "default -p %i", port);
            itsAdapter = communicator()->createObjectAdapterWithEndpoints
                         ("RG_Lane", adapterStr);
            connected = true;
        }
        catch(Ice::SocketException)
        {
            port++;
        }
    }

    //Create the manager and its objects
    itsMgr = new ModelManager("RG_LaneService");

    LINFO("Starting RG_Lane System");
    nub::ref<RG_Lane>
    nav(new RG_Lane(*itsMgr, "RG_Lane", "RG_Lane"));
    LINFO("RG_Lane created");
    itsMgr->addSubComponent(nav);
    LINFO("RG_Lane Added As a subcomponent");
    nav->init(communicator(), itsAdapter);
    LINFO("RG_Lane initiated");

    // check command line inputs/options
    itsMgr->parseCommandLine(argc, argv, "", 0, 0);

    // activate manager and adapter
    itsAdapter->activate();
    itsMgr->start();

    return true;
}
void ModelDisplayState::PrepareStaticModels(ModelManager& modelManager, const ModelBlueprint& blueprint)
{
   const std::vector<CompositeModel3d::StaticModelData>& vecStaticModels =
      m_spModel->StaticList();

   // blueprint must contain same number of statics as composite models
   ATLASSERT(blueprint.m_vecStaticBlueprints.size() == vecStaticModels.size());

   m_vecStaticModelTextures.resize(vecStaticModels.size());

   for (size_t i=0, iMax=vecStaticModels.size(); i<iMax; i++)
   {
      // static model must contain only one material; get texture name of it
      CString cszTexture = vecStaticModels[i].m_spStatic->SingleMaterialTextureName();
      cszTexture.Replace(_T(".\\"), _T(""));

      // add texture name prefix, if any
      const ModelBlueprint::StaticModelBlueprint& staticBlueprint =
         blueprint.m_vecStaticBlueprints[i];

      if (!staticBlueprint.m_cszStaticTexturePrefix.IsEmpty())
         cszTexture = staticBlueprint.m_cszStaticTexturePrefix + cszTexture;

      m_vecStaticModelTextures[i] = modelManager.LoadTexture(cszTexture);
   }
}
bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

LINFO("Starting XBox Controller...");
  //Create the topics
 // SimEventsUtils::createTopic(communicator(), "XBox360RemoteControlMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  while(!connected)
    {
      try
        {
          LINFO("Trying Port:%d", port);
          sprintf(adapterStr, "default -p %i", port);
          itsAdapter = communicator()->createObjectAdapterWithEndpoints("XBox360RemoteControl",
                                                                        adapterStr);
          connected = true;
        }
      catch(Ice::SocketException)
        {
          port++;
        }
    }

  //Create the manager and its objects
  itsMgr = new ModelManager("XBox360RemoteControlService");

  LINFO("Starting XBox360RemoteControl");
  nub::ref<XBox360RemoteControlI> ret(new XBox360RemoteControlI(0, *itsMgr, "XBox360RemoteControl1", "XBox360RemoteControl2"));
  LINFO("XBox360RemoteControl Created");
  itsMgr->addSubComponent(ret);
  LINFO("XBox360RemoteControl Added As Sub Component");
  ret->init(communicator(), itsAdapter);
  LINFO("XBox360RemoteControl Inited");

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}
Ejemplo n.º 20
0
Eigen::VectorXd ObservableSpinSpinCorrelation::get_current(
  const ModelManager& model, ObservableCache& cache ) const
{
  if ( !cache.s ) {
    cache.s = model.s();
  }
  return cache.s.get().cast<double>();
}
Ejemplo n.º 21
0
void addModelToSolution(const std::shared_ptr<Model>& model, const Remapper& remapper, ModelManager& solution, Printer& printer) {
	auto outmodel = new Model();
	outmodel->literalinterpretations = getBackMappedModel(model->literalinterpretations, remapper);
	outmodel->variableassignments = getBackMappedModel(model->variableassignments, remapper);
	solution.addModel(outmodel);
	printer.addModel(outmodel);

}
Ejemplo n.º 22
0
int main(int argc, char **argv)
{	
	// glut init
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

	// create window
	glutInitWindowPosition(500, 100);
	glutInitWindowSize(600, 600);
	glutCreateWindow("10420 CS550000 CG HW2 Haley");

	glewInit();
	if(glewIsSupported("GL_VERSION_2_0")){
		printf("Ready for OpenGL 2.0\n");
	}
	else{
		printf("OpenGL 2.0 not supported\n");
		system("pause");
		exit(1);
	}
	mm.showHelpMenu();

	puts("\n\n  ====== Translation Mode Start ======\n");
	mm.startManaging();

	// register glut callback functions
	glutDisplayFunc(onDisplay);
	glutIdleFunc(onIdle);
	glutKeyboardFunc(onKeyboard);
	glutSpecialFunc(onKeyboardSpecial);
	glutMouseFunc(onMouse);
	glutMotionFunc(onMouseMotion);
	glutReshapeFunc(onWindowReshape);

	// set up shaders here
	setShaders();

	glEnable(GL_DEPTH_TEST);

	// main loop
	glutMainLoop();

	return 0;
}
Ejemplo n.º 23
0
int nocturn::runNoctrun(int argc, char** argv)
{
    app = new QApplication(argc, argv);
    app->setApplicationName("Nocturn");
    QStringList args = app->arguments();
    bool autoLoadMode = false;
    QStringList path;

    if (args.count() >= 3 and args.at(1) == "-f" and args.at(2) != "")
    {
        for (unsigned i = 2; i < argc; ++i)
        {
            path << args.at(i);
        }
        autoLoadMode = true;
    }

    SettingsManager Settings;
    ModelManager Manager;
    MainControler Controler(&Manager);
    MainView View(Manager.getPlaybackManager()->getPlaybackModel(), autoLoadMode);

    connect(app, SIGNAL(aboutToQuit()), this, SLOT(quitNocturn()) );
    connect(app, SIGNAL(aboutToQuit()), &Controler, SLOT(quitNocturn()));

    Manager.getPlayListManager()->restorePlayListFromFiles();
    if (autoLoadMode)
    {
        Manager.getPlayListManager()->autoLoadPath(path);
    }
    connect(Manager.getPlayListManager(), SIGNAL(CurrentSongChanged(const QString&)), &View, SLOT(updateWindowTitle(const QString&)));
    View.setFirstTab();
    SysTrayIconWrapper Icon(View, *(Manager.getPlayListManager()));
    return app->exec();
}
void ModelDisplayState::PrepareAnimatedModelTextures(ModelManager& modelManager, const ModelBlueprint& blueprint)
{
   AnimatedModel3d& model = *m_spModel->GetAnimated();
   Data& data = model.GetData();

   // prepare textures for each material
   m_vecMaterialTextureData.resize(data.m_vecMaterials.size());
   ATLASSERT(blueprint.m_vecAnimatedMaterialTextures.size() == data.m_vecMaterials.size());

   for (size_t i=0, iMax=m_vecMaterialTextureData.size(); i<iMax; i++)
   {
      const Material& material = data.m_vecMaterials[i];

      CString cszTexture = material.cszTexture;
      cszTexture.Replace(_T(".\\"), _T(""));

      // use blueprint texture name, if set
      if (!blueprint.m_vecAnimatedMaterialTextures[i].IsEmpty())
         cszTexture = blueprint.m_vecAnimatedMaterialTextures[i];

      m_vecMaterialTextureData[i].m_spTexture = modelManager.LoadTexture(cszTexture);
   }
}
Ejemplo n.º 25
0
void MassSpriteModel::restore() {
    _TRACE3_("_model_name=" << _model_name << " start");
    ModelManager* pModelManager = pGOD->_pModelManager;
    HRESULT hr;
    if (!_paVtxBuffer_data_model) {
        //静的な情報設定
        std::vector<std::string> names = UTIL::split(std::string(_model_name), ",");
        std::string xfile_name = ""; //読み込むXファイル名
        if (names.size() == 1) {
            _TRACE_(FUNC_NAME<<" "<<_model_name<<" の最大同時描画オブジェクト数は、デフォルトの"<<GGAFDXMASS_MAX_INSTANCE_NUM<<" が設定されました。");
            _set_num = GGAFDXMASS_MAX_INSTANCE_NUM;
            xfile_name = ModelManager::getSpriteFileName(names[0], "sprx");
        } else if (names.size() == 2) {
            _set_num = STOI(names[0]);
            xfile_name = ModelManager::getSpriteFileName(names[1], "sprx");
        } else {
            throwCriticalException("_model_name には \"xxxxxx\" or \"8/xxxxx\" 形式を指定してください。 \n"
                    "実際は、_model_name="<<_model_name<<" でした。");
        }
        if (_set_num < 1 || _set_num > GGAFDXMASS_MAX_INSTANCE_NUM) {
            throwCriticalException(_model_name<<"の最大同時描画オブジェクト数が不正。範囲は 1〜"<<GGAFDXMASS_MAX_INSTANCE_NUM<<"セットです。_set_num="<<_set_num);
        }
        if (xfile_name == "") {
            throwCriticalException("スプライト定義ファイル(*.sprx)が見つかりません。model_name="<<(_model_name));
        }
        ModelManager::SpriteXFileFmt xdata;
        pModelManager->obtainSpriteInfo(&xdata, xfile_name);
        _model_width_px  = xdata.width;
        _model_height_px = xdata.height;
        _model_half_width_px = _model_width_px/2;
        _model_half_height_px = _model_height_px/2;
        _row_texture_split = xdata.row_texture_split;
        _col_texture_split = xdata.col_texture_split;
        _nVertices = 4;
        _nFaces = 2;
        _paVtxBuffer_data_model = NEW MassSpriteModel::VERTEX_model[_nVertices];
        _size_vertex_unit_model = sizeof(MassSpriteModel::VERTEX_model);
        _size_vertices_model = sizeof(MassSpriteModel::VERTEX_model) * _nVertices;

//        float tex_width  = (float)(model_pTextureConnection->peek()->_pD3DXIMAGE_INFO->Width); //テクスチャの幅(px)
//        float tex_height = (float)(model_pTextureConnection->peek()->_pD3DXIMAGE_INFO->Height); //テクスチャの高さ(px)
        double du = 0.0;
        double dv = 0.0;
        //左上
        _paVtxBuffer_data_model[0].x = PX_DX(xdata.width)  / -2.0;
        _paVtxBuffer_data_model[0].y = PX_DX(xdata.height) /  2.0;
        _paVtxBuffer_data_model[0].z = 0.0f;
        _paVtxBuffer_data_model[0].nx = 0.0f;
        _paVtxBuffer_data_model[0].ny = 0.0f;
        _paVtxBuffer_data_model[0].nz = -1.0f;
        _paVtxBuffer_data_model[0].tu = du;
        _paVtxBuffer_data_model[0].tv = dv;
        //右上
        _paVtxBuffer_data_model[1].x = PX_DX(xdata.width)  / 2.0;
        _paVtxBuffer_data_model[1].y = PX_DX(xdata.height) / 2.0;
        _paVtxBuffer_data_model[1].z = 0.0f;
        _paVtxBuffer_data_model[1].nx = 0.0f;
        _paVtxBuffer_data_model[1].ny = 0.0f;
        _paVtxBuffer_data_model[1].nz = -1.0f;
        _paVtxBuffer_data_model[1].tu = (1.0/xdata.col_texture_split) - du;
        _paVtxBuffer_data_model[1].tv = dv;
        //左下
        _paVtxBuffer_data_model[2].x = PX_DX(xdata.width)  / -2.0;
        _paVtxBuffer_data_model[2].y = PX_DX(xdata.height) / -2.0;
        _paVtxBuffer_data_model[2].z = 0.0f;
        _paVtxBuffer_data_model[2].nx = 0.0f;
        _paVtxBuffer_data_model[2].ny = 0.0f;
        _paVtxBuffer_data_model[2].nz = -1.0f;
        _paVtxBuffer_data_model[2].tu = du;
        _paVtxBuffer_data_model[2].tv = (1.0/xdata.row_texture_split) - dv;
        //右下
        _paVtxBuffer_data_model[3].x = PX_DX(xdata.width)  /  2.0;
        _paVtxBuffer_data_model[3].y = PX_DX(xdata.height) / -2.0;
        _paVtxBuffer_data_model[3].z = 0.0f;
        _paVtxBuffer_data_model[3].nx = 0.0f;
        _paVtxBuffer_data_model[3].ny = 0.0f;
        _paVtxBuffer_data_model[3].nz = -1.0f;
        _paVtxBuffer_data_model[3].tu = 1.0/xdata.col_texture_split;
        _paVtxBuffer_data_model[3].tv = 1.0/xdata.row_texture_split;

        _paIndexBuffer_data = NEW WORD[(_nFaces*3)];
        _paIndexBuffer_data[0] = 0;
        _paIndexBuffer_data[1] = 1;
        _paIndexBuffer_data[2] = 2;

        _paIndexBuffer_data[3] = 1;
        _paIndexBuffer_data[4] = 3;
        _paIndexBuffer_data[5] = 2;

        //距離
        FLOAT model_bounding_sphere_radius = (FLOAT)(sqrt(_paVtxBuffer_data_model[0].x * _paVtxBuffer_data_model[0].x +
                                                          _paVtxBuffer_data_model[0].y * _paVtxBuffer_data_model[0].y +
                                                          _paVtxBuffer_data_model[0].z * _paVtxBuffer_data_model[0].z));
        _bounding_sphere_radius = model_bounding_sphere_radius;

        setMaterial();
        _pa_texture_filenames[0] = std::string(xdata.texture_file);
    }
    //デバイスに頂点バッファ作成(モデル)
    if (_pVertexBuffer_model == nullptr) {
        hr = God::_pID3DDevice9->CreateVertexBuffer(
                _size_vertices_model,
                D3DUSAGE_WRITEONLY,
                0,
                D3DPOOL_DEFAULT,
                &(_pVertexBuffer_model),
                nullptr);
        checkDxException(hr, D3D_OK, "_pID3DDevice9->CreateVertexBuffer 失敗 model="<<(_model_name));
        //バッファへ作成済み頂点データを流し込む
        void* pDeviceMemory = 0;
        hr = _pVertexBuffer_model->Lock(0, _size_vertices_model, (void**)&pDeviceMemory, 0);
        checkDxException(hr, D3D_OK, "頂点バッファのロック取得に失敗 model="<<_model_name);
        memcpy(pDeviceMemory, _paVtxBuffer_data_model, _size_vertices_model);
        hr = _pVertexBuffer_model->Unlock();
        checkDxException(hr, D3D_OK, "頂点バッファのアンロック取得に失敗 model="<<_model_name);
    }
    //デバイスにインデックスバッファ作成
    if (_pIndexBuffer == nullptr) {
        hr = God::_pID3DDevice9->CreateIndexBuffer(
                                sizeof(WORD) * _nFaces * 3,
                                D3DUSAGE_WRITEONLY,
                                D3DFMT_INDEX16,
                                D3DPOOL_DEFAULT,
                                &(_pIndexBuffer),
                                nullptr);
        checkDxException(hr, D3D_OK, "_pID3DDevice9->CreateIndexBuffer 失敗 model="<<_model_name);
        void* pDeviceMemory = 0;
        hr = _pIndexBuffer->Lock(0, 0, (void**)&pDeviceMemory,0);
        checkDxException(hr, D3D_OK, "インデックスバッファのロック取得に失敗 model="<<_model_name);
        memcpy(pDeviceMemory, _paIndexBuffer_data, sizeof(WORD)*_nFaces*3);
        hr = _pIndexBuffer->Unlock();
        checkDxException(hr, D3D_OK, "インデックスバッファのアンロック取得に失敗 model="<<_model_name);
    }
    //デバイスにテクスチャ作成
    if (!_papTextureConnection) {
        _papTextureConnection = NEW TextureConnection*[_num_materials];
        for (DWORD n = 0; n < _num_materials; n++) {
            _papTextureConnection[n] =
                    (TextureConnection*)(pModelManager->_pModelTextureManager->connect(_pa_texture_filenames[n].c_str(), this));
        }
    }
Ejemplo n.º 26
0
void WMOModelInstance::unloadModel(ModelManager &mm)
{
  mm.delbyname(filename);
  model = 0;
}
Ejemplo n.º 27
0
void WMOModelInstance::loadModel(ModelManager &mm)
{
  model = (WoWModel*)mm.items[mm.add(GAMEDIRECTORY.getFile(filename))];
  model->isWMO = true;
}
Ejemplo n.º 28
0
void Renderer::LoadModels(void)
{
	ModelManager* pMM = ModelManager::GetInstance();

	// Load Level Geometry
	pMM->LoadModel("Resource/Level Geo/FFP_3D_AbandonedCart_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ACDuct_FIN.mesh");				
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BakerySign_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutA_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutB_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutC_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BoysRestroom_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ButcherBakeryWindow_FIN.mesh");	
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ButcherSign_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_CardBoardBoxes_FIN.mesh");		
	pMM->LoadModel("Resource/Level Geo/FFP_3D_CeilingSet0_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_CeilingSet1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_DairyItems_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_DeliSign_FIN.mesh");				
	pMM->LoadModel("Resource/Level Geo/FFP_3D_DeliWindow_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_EmployeeDoor_FIN.mesh");			
	pMM->LoadModel("Resource/Level Geo/FFP_3D_EmployeeOfTheMonth_FIN.mesh");	
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Endcap_FIN.mesh");				
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ExitSign_FIN.mesh");				
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet0_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet2_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet3_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet4_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet5_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet6_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet7_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet8_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorSet9_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FloorTrim_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FrontDoor_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDCircleL_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDCircleM_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDCircleS_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDSquareL_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDSquareM_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_FSDSquareS_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_GirlsRestroom_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_GlassCounter_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_GlassFreezer_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_HalfWall_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_HelpDesk_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_LightFixtures_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_LobsterCutout_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_LobsterTank_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_MeatSection_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_OpenFreezerLeft_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_OpenFreezerRight_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Outside_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Pallet_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Pirate_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ProduceLeft_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ProduceRight_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Register_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Shelf_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_ShelfStuff_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Snowman_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartingLine_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Umbra_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_WallSet0_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_WallSet1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_WallSupports_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BreakUpSign0_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BreakUpSign1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_Alien_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_LittleEvelyns_FIN.mesh");

	// these meshes will be sharing a texture and render context, so they will be a special case when loading the level
	/*pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutA_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutB_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_BasicCutoutC_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartBanner_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartFrame0_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartFrame1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartLight0_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartLight1_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartLight2_FIN.mesh");
	pMM->LoadModel("Resource/Level Geo/FFP_3D_StartLight3_FIN.mesh");*/



	// Collision volumes
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_CardBoardBoxes_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Endcap_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FrontDoor_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDCircleL_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDCircleM_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDCircleS_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDSquareL_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDSquareM_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_FSDSquareS_FIN_Collision.mesh");
	//pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_GlassCounter_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_GlassFreezer_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_HalfWall_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_HelpDesk_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_LobsterCutout_FIN_Collision.mesh");
	//pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_LobsterTank_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_OpenFreezerLeft_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_OpenFreezerRight_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Pallet_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Pirate_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_ProduceLeft_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_ProduceRight_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Register_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Shelf_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Snowman_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Umbra_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_Alien_FIN_Collision.mesh");
	pMM->LoadAABB("Resource/Collision Volumes/FFP_3D_LittleEvelyns_FIN_Collision.mesh");

	// PowerUps
	pMM->LoadModel("Resource/PowerUps/Banana_MShape.mesh");
	pMM->LoadModel("Resource/PowerUps/Chicken_NoodleSoup_MShape.mesh");

	pMM->LoadModelWithBones("Resource/PowerUps/FFP_3D_DONUTS_FINShape.mesh");

	pMM->LoadModel("Resource/PowerUps/FFP_3D_IceTurkeyBox_FIN.mesh");
	pMM->LoadModel("Resource/PowerUps/Jam_MShape.mesh");
	pMM->LoadModel("Resource/PowerUps/Peanut_butter_MShape.mesh");
	pMM->LoadModel("Resource/PowerUps/Pie_MShape.mesh");
	pMM->LoadModel("Resource/PowerUps/Thors_Thunder_MShape.mesh");
	pMM->LoadModel("Resource/PowerUps/TurkeyShape.mesh");
	pMM->LoadModel("Resource/PowerUps/FFP_3D_PeanutPile_FINShape.mesh");
	pMM->LoadModel("Resource/PowerUps/Donut.mesh");

	// Shadows
	pMM->LoadModel("Resource/Character Models/Shadows/FFP_3D_BikerShadow_FIN.mesh");
	pMM->LoadModel("Resource/Character Models/Shadows/FFP_3D_BanditosShadow_FIN.mesh");
	pMM->LoadModel("Resource/Character Models/Shadows/FFP_3D_LarperShadow_FIN.mesh");
	pMM->LoadModel("Resource/Character Models/Shadows/FFP_3D_ScientistShadow_FIN.mesh");
	pMM->LoadModel("Resource/Character Models/Shadows/FFP_3D_SashaShadow_FIN.mesh");

	// Level Shadows
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_Circle_Small_M.mesh");
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_Circle_Medium_M.mesh");
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_Circle_Huge_M.mesh");
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_FSD_Square_L.mesh");
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_Special.mesh");
	pMM->LoadModel("Resource/Level Geo/Shadows/Shadow_Cashier_M.mesh");

	pMM->LoadModel("Resource/Collision Volumes/FFP_3D_CheckoutCollision_FIN.mesh");

	pMM->LoadModel("Resource/PowerUps/FFP_3D_BlueLamp_FINShape.mesh"); // 86
}
Ejemplo n.º 29
0
int main(){

//	{
//		const std::string mAlign = "xxx,<><,--x";
//		const int mRepeatRow = 1;
//
//		int row = 0;
//		int ibeg=0, iend=0;
//		for(int i=0; i<mAlign.size(); ++i){
//			if(mAlign[i] == ','){
//				++row;
//				
//			}
//		}
//	}

	#define SET4(x, a,b,c,d) x[0]=a; x[1]=b; x[2]=c; x[3]=d
	#define EQ4(x, a,b,c,d) (x[0]==a && x[1]==b && x[2]==c && x[3]==d)

	// Multidimensional data array
	{
	
		// basics
		{
			const int s1=5, s2=4, s3=3, s4=2;
			Data d(Data::INT, s1,s2,s3,s4);

			assert(d.hasData());
			assert(d.type() == Data::INT);
			assert(d.sizeType() == sizeof(int));
			assert(d.isNumerical());
			assert(d.offset() == 0);
			assert(d.order() == 4);
			assert(d.stride() == 1);

			assert(d.size(0) == s1);
			assert(d.size(1) == s2);
			assert(d.size(2) == s3);
			assert(d.size(3) == s4);
			assert(d.size(0,1) == s1*s2);
			assert(d.size(0,1,2) == s1*s2*s3);
			assert(d.size(0,1,2,3) == d.size());
		
			assert(d.indexFlat(0,0,0,0) ==          0);
			assert(d.indexFlat(1,0,0,0) ==          1);
			assert(d.indexFlat(0,1,0,0) ==       s1*1);
			assert(d.indexFlat(0,2,0,0) ==       s1*2);
			assert(d.indexFlat(0,0,1,0) ==    s2*s1*1);
			assert(d.indexFlat(0,0,2,0) ==    s2*s1*2);
			assert(d.indexFlat(0,0,0,1) == s3*s2*s1*1);
			assert(d.indexFlat(0,0,0,2) == s3*s2*s1*2);
			
			for(int i=0; i<d.size(); ++i){
				int i1,i2,i3,i4;
				d.indexDim(i1,i2,i3,i4, i);
				assert(d.inBounds(i1,i2,i3,i4));
				assert(d.indexFlat(i1,i2,i3,i4) == i);
			}
			
			for(int i=0; i<d.size(); ++i) d.assign(i, i);
			for(int i=0; i<d.size(); ++i) assert(d.elem<int>(i) == i);
			
			// resizing
			{
				Data e(Data::INT, 8);
				int N; // resize change, in bytes

				for(int i=0; i<e.size(); ++i) e.assign(i,i);
				
				N=e.resize(16);			assert(e.sizeType()*8==N);
				
				// old elements should be copied over; extras should be zero
				for(int i=0; i<8 ; ++i) assert(e.at<int>(i) == i);
				for(int i=8; i<16; ++i) assert(e.at<int>(i) == 0);

				N=e.resize(0);			assert(e.sizeType()*-16==N);
				N=e.resize(8);			assert(e.sizeType()*  8==N);
				for(int i=0; i<e.size(); ++i) assert(e.at<int>(i) == 0);
			}
			
			// cloning data
			{
				Data e = d;
				assert(e == d);
				
				e.clone();
				assert(d.elems<int>() != e.elems<int>());
				assert(e == d);
			}
			
			// reversed slice
			{				
				Data e = d.reversed();
				for(int i=0; i<e.size(); ++i)
					assert(d.elem<int>(d.size()-1-i) == e.elem<int>(i));

				e.clone();
				for(int i=0; i<e.size(); ++i)
					assert(d.elem<int>(d.size()-1-i) == e.elem<int>(i));
				
				e += d;
				for(int i=0; i<e.size(); ++i)
					assert(e.elem<int>(i) == e.size()-1);
			}
		}


		// reference counting
		{
			Data d1(Data::INT, 4,4);
			assert(Data::references(d1.elems<int>()) == 1);

			{
				Data d2 = d1;
				assert(d1.elems<int>() == d2.elems<int>());
				assert(Data::references(d1.elems<int>()) == 2);
			}
			assert(Data::references(d1.elems<int>()) == 1);

			{
				Data d2 = d1.slice(1);
				Data d3 = d2.slice(1);
				assert(Data::references(d1.elems<int>()) == 3);
			}
			assert(Data::references(d1.elems<int>()) == 1);
		}
		
	
		const float cf = 10;
		float f = 10;
		std::string s = "hello";
		
		Data d(cf);

		assert(d.hasData());
		assert(d.size() == 1);
		assert(d.type() == Data::FLOAT);
		assert(d.at<float>(0) == cf);
		assert(d.toString() == "10");
		assert(d.at<std::string>(0) == "10");
		
//		d.put(std::string("8"));
//		assert(d.at<float>(0) == 8);

		// Getting/setting values
		d.assign(11.f);
		assert(d.at<float>(0) == 11.f);
		
		d.clone();
		assert(d.hasData());
		assert(d.size() == 1);
		assert(d.type() == Data::FLOAT);

		d.assign(11.f);
		assert(d.at<float>(0) == 11.f);

		d.assign(100);
		assert(d.at<float>(0) == 100);
		
		d.set(f);
		assert(d.elems<float>() == &f);
		assert(d.at<float>(0) == f);
		
		d.set(s);
		assert(d.type() == Data::STRING);
		assert(d.size() == 1);
		assert(d.elems<std::string>() == &s);
		assert(d.at<std::string>(0) == s);
		
		d.clone();
		assert(d.elems<std::string>() != &s);
		assert(d.at<std::string>(0) == s);

		d.set("hello");
		assert(d.type() == Data::STRING);
		assert(d.at<std::string>(0) == "hello");

		{
			std::string s = "d2";
			Data d2(s);
			
			d.set("d");
			d2.assign(d);
			assert(d2.at<std::string>(0) == d.at<std::string>(0));
		}
		
		{
			Data a(Data::FLOAT, 3);
			a.assign(10,0);
			a.assign(20,1);
			a.assign(30,2);
			float b[3];
			a.copyTo(b);
			for(int i=0;i<3;++i) assert(b[i] == a.at<float>(i));
		}
		
		// checking elements
		{
			Data::Type types[] = {Data::BOOL, Data::INT, Data::FLOAT, Data::DOUBLE};
			for(int i=0;i<4;++i){
				Data a(types[i], 8);
				a.assignAll(0);
				assert(a.isZero());
				a.assign(1, 1);
				assert(!a.isZero());
				a.assign(1, 3);
				a.assign(1, 5);
				a.assign(1, 7);
				assert(a.slice(0,4,2).isZero());
			}
		}
		
		// searching
		{
			Data e(Data::STRING, 3);
			std::string s1 = "test1", s2 = "test2", s3 = "test3";
			e.assign(s1, 0);
			e.assign(s2, 1);
			e.assign(s3, 2);
			
			assert(e.indexOf(s1) == 0);
			assert(e.indexOf(s2) == 1);
			assert(e.indexOf(s3) == 2);
			assert(e.indexOf(std::string("invalid")) == Data::npos);
		}
		
		// multiple element assignment
		{
			#define ASSERT_EQUALS(a,b,c,d,e)\
				assert(d1.at<int>(0) == a);\
				assert(d1.at<int>(1) == b);\
				assert(d1.at<int>(2) == c);\
				assert(d1.at<int>(3) == d);\
				assert(d1.at<int>(4) == e)

			Data d1(Data::INT, 5);
			d1.assignAll(-1);
			ASSERT_EQUALS(-1,-1,-1,-1,-1);
			
			d1.assignAll(0);
			ASSERT_EQUALS(0,0,0,0,0);
			
			{
				float t[] = {1,2,3,4,5};
				d1.assignFromArray(t,2);
				ASSERT_EQUALS(1,2,0,0,0);
				
				d1.assignFromArray(t+2,2,1,2);
				ASSERT_EQUALS(1,2,3,4,0);
				
				d1.assignAll(0);
				d1.assignFromArray(t,3, 2);
				ASSERT_EQUALS(1,3,5,0,0);
				
				d1.assignFromArray(t+1,2, 2,3);
				ASSERT_EQUALS(1,3,5,2,4);
			}
			#undef ASSERT_EQUALS
		}
	}


	// stringification
	{	//for(int i=0;i<4;++i) printf("%g\n", f4[i]);
		//printf("%s\n", s1.c_str());
		bool b1;
		float f1;
		double d1;
		std::string s1;
		
		bool b4[4];
		float f4[4];
		double d4[4];
		std::string s4[4];
		
		int N;	// number of elements converted

		N=fromToken(f1, "1e-2");		assert(1==N && f1 == float(1e-2));
		N=fromToken(f1, "1000");		assert(1==N && f1 == float(1000));
		N=fromToken(d1, "1e-2");		assert(1==N && d1 == double(1e-2));
		N=fromToken(d1, "1000");		assert(1==N && d1 == double(1000));
		N=fromToken(b1, "0");			assert(1==N && b1 == 0);
		N=fromToken(b1, "1");			assert(1==N && b1 == 1);
		N=fromToken(s1, "\"test\"");	assert(1==N && s1 == "test");
		
		N=fromToken(b4,4,1, "{1,0,1,1}");				assert(4==N && EQ4(b4, 1,0,1,1));
		N=fromToken(b4,4,1, "{0,  1, 0,0}");			assert(4==N && EQ4(b4, 0,1,0,0));
		N=fromToken(f4,4,1, "{1, -1.2, 1e10, +.1}");	assert(4==N && EQ4(f4, 1.f,-1.2f,1e10f,+.1f));
		N=fromToken(d4,4,1, "{1, -1.2, 1e10, +.1}");	assert(4==N && EQ4(d4, 1,-1.2,1e10,+.1));
		N=fromToken(s4,4,1, "{\"one\", \"two\", \"three\", \"four\"}");
														assert(4==N && EQ4(s4, "one","two","three","four"));

		N=toToken(s1, 1000.f);			assert(1==N && s1 == "1000");
		N=toToken(s1, 2000.0);			assert(1==N && s1 == "2000");
		N=toToken(s1, true);			assert(1==N && s1 == "1");
		N=toToken(s1, false);			assert(1==N && s1 == "0");
		N=toToken(s1, "test");			assert(1==N && s1 == "\"test\"");
		N=toToken(s1, std::string("test"));
										assert(1==N && s1 == "\"test\"");		

		SET4(b4, 1,0,1,1);		N=toToken(s1, b4,4,1);	assert(4==N && s1 == "{1, 0, 1, 1}");
		SET4(f4,-1,0.1,3,1e10);	N=toToken(s1, f4,4,1);	assert(4==N && s1 == "{-1, 0.1, 3, 1e+10}");
		SET4(d4,-1,0.1,3,1e10);	N=toToken(s1, d4,4,1);	assert(4==N && s1 == "{-1, 0.1, 3, 1e+10}");
		SET4(s4,"one","two","three","four"); N=toToken(s1,s4,4,1);
														assert(4==N && s1 == "{\"one\", \"two\", \"three\", \"four\"}");
	}


	// test View linked list implementation
	{
		View n00, n10, n11, n20;

		n00.add(n10);
		n00.add(n11);
		n10.add(n20);
		
		// check all of our links
		assert( n00.child == &n10);
		assert(!n00.parent);
		assert(!n00.sibling);
		assert( n10.parent == &n00);
		assert( n10.sibling == &n11);
		assert( n10.child == &n20);
		assert( n11.parent == &n00);
		assert(!n11.child);
		assert(!n11.sibling);
		assert( n20.parent == &n10);
		assert(!n20.child);
		assert(!n20.sibling);
		
		n10.makeLastSibling();
		assert(!n10.sibling);
		assert(n11.sibling == &n10);
		n11.makeLastSibling();

		n10.remove();
		assert(!n10.parent);
		assert(!n10.sibling);
		assert(!n00.child->sibling);
		
		n11.remove();
		assert(!n00.child);

		assert(n10.child == &n20);
	}

	
	// test View memory management
	{
		View * v0d = new View;
		View v1s;
		View * v1d = new View;
		
		assert(v0d->dynamicAlloc());
		assert(!v1s.dynamicAlloc());

		*v0d << v1s << v1d;
		
		delete v0d;
	}



	// Notifications	
	{
		bool bv1=false, bv2=false, bf=false;
		Notifier n;
	
		assert(n.numObservers(Update::Value) == 0);

		n.attach(ntSetBool1, Update::Value, &bv1);
		n.attach(ntSetBool2, Update::Value, &bv2);
		n.attach(ntSetBool1, Update::Focus, &bf);

		assert(n.numObservers(Update::Value) == 2);
		assert(n.numObservers(Update::Focus) == 1);

		n.notify(Update::Value);
		assert(bv1);
		assert(bv2);
		assert(!bf);

		n.notify(Update::Focus);
		assert(bf);
		
		bv1=bv2=false;
		n.detach(ntSetBool1, Update::Value, &bv1);
		n.notify(Update::Value);
		assert(!bv1);
		assert(bv2);

		bv1=bv2=false;
		n.detach(ntSetBool2, Update::Value, &bv2);
		n.notify(Update::Value);
		assert(!bv1);
		assert(!bv2);
	}
	
	{
		bool b=false;
		Button w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(true);
		assert(b);
		assert(w.getValue() == true);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

// Boolean model variable
		bool v = false;
		w.attachVariable(v);
		w.setValue(true);		assert(v == true);
		w.setValue(false);		assert(v == false);
		
		v = true;
		w.onDataModelSync();		assert(w.getValue() == true);

		w.setValue(true);

		assert(w.data().toToken() == "1");
		w.setValue(false);
		assert(w.data().toToken() == "0");
		w.setDataFromString("0");	assert(w.getValue() == false);
		w.setDataFromString("1");	assert(w.getValue() == true);

		assert(!w.setDataFromString("invalid"));
	}

	{
		Buttons w;
		bool b=false;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(true, 0);
		assert(b);
		assert(w.getValue(0) == true);
		
		w.data().resize(2,2);
		w.data().assignAll(0);

		bool v1 = false;
		bool v2 = false;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 2);

		w.setValue(true, 0);		assert(v1 == true);
		w.setValue(true, 2);		assert(v2 == true);
		w.setValue(false, 0);		assert(v1 == false);
		w.setValue(false, 2);		assert(v2 == false);

		w.setValue(false, 0);
		w.setValue(false, 1);
		w.setValue(false, 2);
		w.setValue(false, 3);
		assert(w.data().toToken() == "{0, 0, 0, 0}");
		
		v1 = v2 = false;
		w.setDataFromString("{1,1,1,1}");
		assert(w.getValue(0) && w.getValue(1) && w.getValue(2) && w.getValue(3));
		assert(v1 && v2);
	}

	{
		bool b=false;
		Slider w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.99f);
		assert(b);
		assert(w.getValue() == 0.99f);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

		float v;
		w.attachVariable(v);
		w.setValue(0.99);
		assert(v == 0.99f);
		
		v = 0;
		w.onDataModelSync();
		assert(w.getValue() == 0);

		std::string s;
		w.setValue(0.25);
		assert(w.data().toToken() == "0.25");
		w.setDataFromString("0.5");	assert(w.getValue() == 0.5);
									assert(v == 0.5);

		assert(!w.setDataFromString("invalid"));
		assert(w.getValue() == 0.5);
	}

	{
		bool b=false;
		Sliders w(Rect(1), 2,2);
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.99f, 3);
		assert(b);
		assert(w.getValue(3) == 0.99f);

		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.1f, 0); assert(v1 == 0.1f);
		w.setValue(0.2f, 0); assert(v1 == 0.2f);
		
		v1 = 0.8f; v2 = 0.9f;
		w.onDataModelSync();
		assert(w.getValue(0) == 0.8f);
		assert(w.getValue(1) == 0.9f);

		w.setValue(0.1f, 0);
		w.setValue(0.2f, 1);
		w.setValue(0.3f, 2);
		w.setValue(0.4f, 3);
		assert(w.data().toToken() == "{0.1, 0.2, 0.3, 0.4}");
		
		v1=v2=0;
		w.setDataFromString("{0.4,0.3,0.2,0.1}");
		assert(w.getValue(0) == 0.4);
		assert(w.getValue(1) == 0.3);
		assert(w.getValue(2) == 0.2);
		assert(w.getValue(3) == 0.1);
		assert(v1 == (float)w.getValue(0) && v2 == (float)w.getValue(1));
		
//		double vs[4] = {0.11, 0.22, 0.33, 0.44};
//		w.attachVariable(vs,4);
//		w.onDataModelSync();
//		for(int i=0; i<4; ++i) printf("%f\n", w.values()[i]);
//		
//		w.getValue(0.44, 0);
//		w.getValue(0.33, 0);
//		w.getValue(0.22, 0);
//		w.getValue(0.11, 0);
//		for(int i=0; i<4; ++i) printf("%f\n", vs[i]);
	}

	{
		bool b=false;
		Slider2D w;
		w.attach(ntSetBool1, Update::Value, &b);
		w.setValue(0.01f, 0);
		assert(b);
		assert(w.getValue(0) == 0.01f);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(0.01f, 0);
		assert(!b);
		
		b=false;
		w.setValue(0.00f, 0);
		w.setValue(0.01f, 1);
		assert(b);
		assert(w.getValue(1) == 0.01f);
		
		b=false;
		w.setValueMax();
		assert(b);
		assert(w.getValue(0) == 1.f);
		assert(w.getValue(1) == 1.f);
		
		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);
		
		w.setValue(0.5f, 0);	assert(v1 == 0.5f);
		w.setValue(0.6f, 1);	assert(v2 == 0.6f);
		
		v1 = 0.1;
		v2 = 0.2;
		
		w.onDataModelSync();
		assert(w.getValue(0) == v1);
		assert(w.getValue(1) == v2);
	
		w.setValue(0.2, 0);
		w.setValue(0.3, 1);
		assert(w.data().toToken() == "{0.2, 0.3}");
		
		v1 = v2 = 0;
		w.setDataFromString("{0.7, 0.8}");
		assert(w.getValue(0)==0.7 && w.getValue(1)==0.8);
		assert(v1==(float)w.getValue(0) && v2==(float)w.getValue(1));
	}

	{
		bool b=false;
		SliderGrid<4> w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.01f, 0);
		assert(b);
		assert(w.getValue(0) == 0.01f);

		float v1, v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.1f, 0); assert(v1 == 0.1f);
		w.setValue(0.2f, 0); assert(v1 == 0.2f);
		
		v1 = 0.8f; v2 = 0.9f;
		w.onDataModelSync();
		assert(w.getValue(0) == 0.8f);
		assert(w.getValue(1) == 0.9f);

		w.setValue(0.1f, 0);
		w.setValue(0.2f, 1);
		w.setValue(0.3f, 2);
		w.setValue(0.4f, 3);
		assert(w.data().toToken() == "{0.1, 0.2, 0.3, 0.4}");
		
		v1=v2=0;
		w.setDataFromString("{0.4,0.3,0.2,0.1}");
		assert(w.getValue(0) == 0.4);
		assert(w.getValue(1) == 0.3);
		assert(w.getValue(2) == 0.2);
		assert(w.getValue(3) == 0.1);
		assert(v1 == (float)w.getValue(0) && v2 == (float)w.getValue(1));
	}
	
	{
		bool b=false;
		SliderRange w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.01f, 0);
		w.setValue(0.02f, 1);
		assert(b);
		assert(w.getValue(0) == 0.01f);
		assert(w.getValue(1) == 0.02f);
		assert(w.center() == 0.015f);
		assert(w.range() == 0.01f);
		
		w.endpoints(0,1);
		assert(w.getValue(0) == 0);
		assert(w.getValue(1) == 1);
		
		w.centerRange(0.5, 0.25);
		assert(w.getValue(0) == (0.5-0.25/2));
		assert(w.getValue(1) == (0.5+0.25/2));

		float v1,v2;
		w.attachVariable(v1, 0);
		w.attachVariable(v2, 1);

		w.setValue(0.2, 0);
		w.setValue(0.3, 1);
		assert(w.data().toToken() == "{0.2, 0.3}");
		
		v1 = v2 = 0;
		w.setDataFromString("{0.7, 0.8}");
		assert(w.getValue(0)==0.7 && w.getValue(1)==0.8);
		assert(v1==(float)w.getValue(0) && v2==(float)w.getValue(1));
	}

	{
		bool b=false;
		Label w;

		w.attach(ntValue, Update::Value, &b);
		w.setValue("test");
		assert(b);
		assert(w.getValue() == "test");
		
		assert(w.data().toToken() == "\"test\"");
		
		w.setValue("");
		w.setDataFromString("\"test\"");	assert(w.getValue() == "test");
	}

	{

//		{
//			double val = 1e14;
//			double inc = 1;
//			printf("%f\n", val + inc*1);
//			printf("%f\n", val + inc*2);
//			printf("%f\n", val + inc*3);
//			printf("%f\n", val + inc*4);
//		}

		bool b=false;
		NumberDialer w(1,2,1,0);
		w.attach(ntValue, Update::Value, &b);
		w.setValue(0.75);
		assert(b);
		assert(w.getValue() == 0.75);

// Setting to current value should NOT send notification to avoid infinite loops
		b=false;
		w.setValue(w.getValue());
		assert(!b);

		double v=0;
		w.attachVariable(v);
		w.setValue(0.5);	assert(v == 0.5);
		
		v = 0.25;
		w.onDataModelSync();
		assert(w.getValue() == v);

		w.setValue(0.2);
		assert(w.data().toToken() == "0.2");
		
		v = 0;
		w.setDataFromString("0.8");
		assert(w.getValue()==0.8 && w.getValue()==v);
	}

	{
		bool b=false;
		TextView w;
		w.attach(ntValue, Update::Value, &b);
		w.setValue("hello");
		assert(b);
		assert(w.getValue() == "hello");
		
		assert(w.data().toToken() == "\"hello\"");

		std::string v = "test";
		w.attachVariable(v);
		
		w.onDataModelSync();
		assert(w.getValue() == "test");

		w.setDataFromString("\"world\"");
		assert(w.getValue() == "world");
		assert(v == "world");
	}



	// model to string conversion
	{
		Label l;
		TextView tv;
		Button b;
		Buttons bs(Rect(), 2, 2);
		Slider s;
		Sliders ss(Rect(), 1, 4);
		Slider2D s2D;
		NumberDialer nd(1,4,1,-1);
		std::string strings[] = {"test1", "test2", "test3"};
	
		l.setValue("Hello Label!").name("l");
		tv.setValue("Hello TextView!").name("tv");
		b.setValue(true).name("b");
		bs.setValue(true, 0,1).name("bs");
		s.setValue(0.5).name("s");
		ss.setValue(0.4, 1).name("ss");
		s2D.setValue(0.5, 0).setValue(0.1, 1).name("s2D");
		nd.setValue(-0.54941).name("nd");

		const View * views[] = {&l, &tv, &b, &bs, &s, &ss, &s2D, &nd};
		for(unsigned i=0; i<sizeof(views)/sizeof(View *); ++i){
			//const Data& d = views[i]->data();
			//printf("%p: %s\n", &d, d.toString().c_str());
			//views[i]->model().print(); printf("\n");
		}

		View top;
		top << l << tv << b << bs << s << ss << s2D << nd;
	
		std::string str1, str2;
//		top.modelToString(str1, "test model");		
//		printf("%s\n", str1.c_str());
//
//		l.setValue("changed...");
//		top.modelFromString(str1);
//		top.modelToString(str2);
//		printf("%s\n", str2.c_str());
//		assert(str1 == str2);

		ModelManager mm;
		
		mm.add("l", l);
		mm.add("tv", tv);
		mm.add("b", b);
		mm.add("bs", bs);
		mm.add("s" , s);
		mm.add("ss", ss);
		mm.add("s2D",s2D);
		mm.add("nd", nd);
		
		Data dat(strings, 3);
		//Data dat(10);
		//dat.print();
		//mm.add("strings", dat);
		//mm.add("strings", *new Data(strings, 3));
		
//		mm.toToken(str1, "test");
//		printf("%s\n", str1.c_str());
//		
//		mm.fromToken(str1);
//		mm.toToken(str2, "test");
//		printf("%s\n", str2.c_str());

		std::string snapshotString1 =
"[\"test 1\"] = {\n\
	l = \"Label 1\",\n\
	tv = \"TextView 1\",\n\
	b = 0,\n\
	bs = {0,0,0,0},\n\
}";

		std::string snapshotString2 =
"[\"test 2\"] = {\n\
	l = \"Label 2\",\n\
	tv = \"TextView 2\",\n\
	b = 1,\n\
	bs = {1,1,1,1},\n\
	s = 1,\n\
	ss = {1,1,1,1},\n\
	s2D = {1,1},\n\
	nd = 1,\n\
}";
		
		mm.snapshotsFromString("{" + snapshotString1 + ",\r\n" + snapshotString2 + "}");

//		mm.snapshots()["test 1"]["l"].print();
//		mm.snapshots()["test 1"]["b"].print();
//		mm.snapshots()["test 1"]["bs"].print();
//		mm.snapshots()["test 1"]["s"].print();
//		mm.snapshots()["test 1"]["ss"].print();
//		mm.snapshots()["test 1"]["s2D"].print();
//		mm.snapshots()["test 1"]["nd"].print();
//		mm.snapshots()["test 2"]["l"].print();
//		mm.snapshots()["test 2"]["b"].print();
//		mm.snapshots()["test 2"]["bs"].print();
//		mm.snapshots()["test 2"]["s"].print();
//		mm.snapshots()["test 2"]["ss"].print();
//		mm.snapshots()["test 2"]["s2D"].print();
//		mm.snapshots()["test 2"]["nd"].print();
//
//		mm.snapshotsToFile("snapshots.txt");
//		
//		mm.clearSnapshots();
//		mm.snapshotsFromFile("snapshots.txt");
//
//		str1.clear();
//		mm.snapshotsToString(str1);
//		printf("%s\n", str1.c_str());
	}

//	{
//		std::string str( "a bc ab ca ab" );
//		std::string searchString("ab"); 
//		std::string replaceString("hello");
//
//		std::string::size_type pos = 0;
//		while((pos = str.find(searchString, pos)) != std::string::npos){
//			str.replace(pos++, searchString.size(), replaceString);
//		}
//		printf("%s\n", str.c_str());
//	}

//	printf("sizeof(Notifier): %d\n", sizeof(Notifier));
//	printf("sizeof(View): %d\n", sizeof(View));
//	printf("sizeof(Data): %d\n", sizeof(Data));
//	printf("sizeof(Model): %d\n", sizeof(Model));
//	printf("sizeof(ModelManager): %d\n", sizeof(ModelManager));

	return 0;
}
Ejemplo n.º 30
0
	void addModelToSolution(const std::shared_ptr<Model>& model, const Remapper& remapper, ModelManager& solution, Printer& printer) {
		auto outmodel = createModel(model, remapper);
		solution.addModel(outmodel);
		printer.addModel(outmodel);
	}