int32_t C4SoundSystem::LoadEffects(C4Group &hGroup, const char *namespace_prefix, bool group_is_root)
{
	// Local definition sounds: If there is a Sound.ocg in the group, load the sound from there
	if(group_is_root && hGroup.FindEntry(C4CFN_Sound))
	{
		C4Group g;
		g.OpenAsChild(&hGroup, C4CFN_Sound, false, false);
		return LoadEffects(g, namespace_prefix, false);
	}
	int32_t iNum=0;
	char szFilename[_MAX_FNAME+1];
	char szFileType[_MAX_FNAME+1];
	C4SoundEffect *nsfx;
	// Process segmented list of file types
	for (int32_t i = 0; SCopySegment(C4CFN_SoundFiles, i, szFileType, '|', _MAX_FNAME); i++)
	{
		// Search all sound files in group
		hGroup.ResetSearch();
		while (hGroup.FindNextEntry(szFileType, szFilename))
			// Create and load effect
			if ((nsfx = new C4SoundEffect))
			{
				if (nsfx->Load(szFilename, hGroup, namespace_prefix))
				{
					// Overload same name effects
					RemoveEffect(nsfx->Name);
					// Add effect
					nsfx->Next=FirstSound;
					FirstSound=nsfx;
					iNum++;
				}
				else
					delete nsfx;
			}
	}
	// Load subgroups from Sound.ocg and other subgroups
	if (!group_is_root)
	{
		hGroup.ResetSearch();
		while (hGroup.FindNextEntry(C4CFN_SoundSubgroups, szFilename))
		{
			// Load from subgroup as a sub-namespace
			// get namespace name
			StdStrBuf sub_namespace;
			if (namespace_prefix)
			{
				sub_namespace.Copy(namespace_prefix);
				sub_namespace.Append("::");
			}
			sub_namespace.Append(szFilename, strlen(szFilename) - strlen(C4CFN_SoundSubgroups) + 1);
			// load from child group
			C4Group subgroup;
			if (subgroup.OpenAsChild(&hGroup, szFilename, false, false))
			{
				iNum += LoadEffects(subgroup, sub_namespace.getData(), false);
			}
		}
	}
	return iNum;
}
예제 #2
0
 DiEffectManager::DiEffectManager () :
     mLastCreatedTemplateName(DiString::BLANK)
 {
     InitFactories();
     
     LoadEffects();
 }
void CForceFeedBackSystem::LoadXmlData()
{
	const char* xmlDataFile = "Libs/GameForceFeedback/ForceFeedbackEffects.xml";
	XmlNodeRef rootNode = gEnv->pSystem->LoadXmlFromFile(xmlDataFile);

	if (!rootNode || strcmpi(rootNode->getTag(), "ForceFeedback"))
	{
		FORCEFEEDBACK_LOG("Could not load force feedback system data. Invalid XML file '%s'! ", xmlDataFile);
		return;
	}

	const int childCount = rootNode->getChildCount();
	for (int i = 0; i < childCount; ++i)
	{
		XmlNodeRef childNode = rootNode->getChild(i);

		const char* childTag = childNode->getTag();
		if (strcmp(childTag, "Patterns") == 0)
		{
			LoadPatters(childNode);
		}
		else if (strcmp(childTag, "Envelopes") == 0)
		{
			LoadEnvelopes(childNode);
		}
		else if (strcmp(childTag, "Effects") == 0)
		{
			LoadEffects(childNode);
		}
	}	
}
예제 #4
0
void CGControlSys::LoadEnvironment(int iStage)
{
//	m_Environment.LoadSkyDome(SFullName("ev_environment", "skydome.smd"));
	m_Environment.LoadSkyDome(iStage);

	LoadEffects();

}
예제 #5
0
bool psEffectManager::LoadFromDirectory(const csString & path, bool includeSubDirs, iView * parentView)
{
    bool success = true;
#ifndef DONT_DO_EFFECTS
    csRef<iVFS> vfs =  csQueryRegistry<iVFS> (psCSSetup::object_reg);
    assert(vfs);

    if (!vfs->Exists(path))
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "Eulora_effects", "Failed to load effects from directory; %s does not exist", path.GetData());
        return false;
    }

    if (!vfs->ChDir(path))
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "Eulora_effects", "Failed to load effects from directory; %s read failed", path.GetData());
        return false;
    }

    csRefArray<iThreadReturn> threadReturns;

    csRef<iStringArray> files = vfs->FindFiles("*");
    for (size_t a=0; a<files->GetSize(); ++a)
    {
        const char * file = files->Get(a);
        if (file[0] == '.')
            continue;

        if (strcmp(file, path) == 0)
            continue;

        size_t len = strlen(file);
        char lastChar = file[len-1];
        if (lastChar == '/' || lastChar == '\\')
        {
            if (includeSubDirs)
            {
                if (!LoadFromDirectory(file, true, parentView))
                {
                    success = false;
                }
            }
        }
        else if (len > 4 && ((lastChar == 'f' || lastChar == 'F') && (file[len-2] == 'f' || file[len-2] == 'F') && (file[len-3] == 'e' || file[len-3] == 'E') && file[len-4] == '.'))
        {
            threadReturns.Push(LoadEffects(file, parentView));
        }
    }
#endif
    csRef<iThreadManager> threadman = csQueryRegistry<iThreadManager>(object_reg);
    return threadman->Wait(threadReturns);
}
예제 #6
0
// XBMC has loaded us into memory,
// we should set our core values
// here and load any settings we
// may have from our config file
extern "C" void Create(LPDIRECT3DDEVICE8 pd3dDevice, int iWidth, int iHeight, const char* szScreenSaverName, float ratio)
{
    memset(&world,0,sizeof(WaterSettings));

    strcpy(m_szScrName,szScreenSaverName);
    g_pd3dDevice = pd3dDevice;

    m_iWidth = iWidth;
    m_iHeight = iHeight;

    world.scaleX = 1.0f;
    if ( (ratio * iWidth / iHeight) > 1.5)
        world.scaleX = 1/1.333f;//0.91158f/ratio; widescreen mode
    // Load the settings
    LoadSettings();
    CreateLight();
    LoadEffects();

    if (world.isTextureMode)
    {
        LoadTexture();
        world.effectCount--; //get rid of logo effect
    }

    world.effectType = rand()%world.effectCount;
    //world.effectType = 5;
    world.frame = 0;
    world.nextEffectTime = 0;



    /*
    char buff[100];
    for(int j = 0; j < 15; j++)
    {
      buff[j] = (int)ratio + '0';
      ratio = (ratio - (int)ratio)*10;
    }
    buff[15] = 0;
    ((EffectText*)(effects[6]))->drawString(buff,0.6f,0.6f,1.3f,0.06f,-7.0f,7.8f);*/
    //world.widescreen = (float)iWidth/ (float)iHeight > 1.7f;
}
bool C4SoundSystem::Init()
{
	if (!Application.MusicSystem.MODInitialized &&
	    !Application.MusicSystem.InitializeMOD())
		return false;

	// Might be reinitialisation
	ClearEffects();
	// (re)init EFX
	Modifiers.Init();
	// Open sound file
	if (!SoundFile.IsOpen())
		if (!Reloc.Open(SoundFile, C4CFN_Sound)) return false;
	// Load static sound from Sound.ocg
	LoadEffects(SoundFile, NULL, false);
#if AUDIO_TK == AUDIO_TK_SDL_MIXER
	Mix_AllocateChannels(C4MaxSoundInstances);
#endif
	return true;
}
예제 #8
0
void ColladaDoc::Load(
	lpxmlnode						 pNode)
{
	lpxmlnode pCurrNode = pNode;
	std::string Name = pCurrNode->name();	
	if(Name == "COLLADA") {

		//	COLLADA header found
		pCurrNode = pCurrNode->first_node();
		while(pCurrNode != NULL) {

			Name = pCurrNode->name();

			if(Name == "library_images")
				LoadImages(pCurrNode->first_node());

			else if(Name ==  "library_effects")
				LoadEffects(pCurrNode->first_node());

			else if(Name == "library_materials")
				LoadMaterials(pCurrNode->first_node());

			else if(Name == "library_geometries")
				LoadGeometries(pCurrNode->first_node());

			else if(Name == "library_animations")
				LoadAnimations(pCurrNode->first_node());

			else if(Name =="library_controllers")
				LoadControllers(pCurrNode->first_node());

			else if(Name == "library_visual_scenes")
				LoadVisualScenes(pCurrNode->first_node());

			else if(Name == "asset")
				LoadAssets(pCurrNode->first_node());

			pCurrNode = pCurrNode->next_sibling();
		};
	}
}
예제 #9
0
BattleSystem::BattleSystem( ) :
    _effects( []( std::vector<Effect> effects )
    {
        std::map<int, Effect> temp;

        for( int i = 0, limit = effects.size( ); i < limit; i++ )
        {
            temp.try_emplace( 1 << i, effects[i] );
        }

        return temp;
    }( LoadEffects( ) ) ),
    _spells( []( std::vector<Spell> spells )
    {
        std::map<int, Spell> temp;

        for( int i = 0, limit = spells.size( ); i < limit; i++ )
        {
            temp.try_emplace( 1 << i, spells[i] );
        }

        return temp;
    }( LoadSpells( ) ) )
{ }
예제 #10
0
bool psEffectManager::LoadFromEffectsList(const csString & fileName, iView * parentView)
{
#ifndef DONT_DO_EFFECTS
    csRef<iVFS> vfs =  csQueryRegistry<iVFS> (psCSSetup::object_reg);
    assert(vfs);
    
    if (!vfs->Exists(fileName))
        return false;

    csRef<iDocument> doc;
    csRef<iDocumentNodeIterator> xmlbinds;
    csRef<iDocumentSystem>  xml;
    const char* error;

    csRef<iDataBuffer> buff = vfs->ReadFile(fileName);
    if (buff == 0)
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "Eulora_effects", "Could not find file: %s", fileName.GetData());
        return false;
    }
    xml =  csQueryRegistry<iDocumentSystem> (psCSSetup::object_reg);
    doc = xml->CreateDocument();
    assert(doc);
    error = doc->Parse( buff );
    if ( error )
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "Eulora_effects",
                 "Parse error in %s: %s", fileName.GetData(), error);
        return false;
    }
    if (doc == 0)
        return false;

    csRef<iDocumentNode> root = doc->GetRoot();
    if (root == 0)
    {
        csReport(psCSSetup::object_reg, CS_REPORTER_SEVERITY_ERROR, "Eulora_effects", "No root in XML");
        return false;
    }

    csRefArray<iThreadReturn> threadReturns;
    csRef<iDocumentNode> listNode = root->GetNode("effectsFileList");
    if (listNode != 0)
    {
        xmlbinds = listNode->GetNodes("effectsFile");
        csRef<iDocumentNode> fileNode;
        while (xmlbinds->HasNext())
        {
            fileNode = xmlbinds->Next();

            csString effectFile = fileNode->GetAttributeValue("file");
            if (vfs->Exists(effectFile))
            {
                threadReturns.Push(LoadEffects(effectFile, parentView));
            }
        }
    }
    csRef<iThreadManager> threadman = csQueryRegistry<iThreadManager>(object_reg);
    return threadman->Wait(threadReturns);
#endif
    return true;
}
예제 #11
0
// The `main program' equivalent, creating the windows and returning the
// main frame
bool AudacityApp::OnInit()
{
   // Unused strings that we want to be translated, even though
   // we're not using them yet...
   wxString future1 = _("Master Gain Control");
   wxString future2 = _("Input Meter");
   wxString future3 = _("Output Meter");

   ::wxInitAllImageHandlers();

   wxFileSystem::AddHandler(new wxZipFSHandler);

   InitPreferences();

	#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) && !defined(__CYGWIN__)
		this->AssociateFileTypes(); 
	#endif

   //
   // Paths: set search path and temp dir path
   //

   wxString home = wxGetHomeDir();
   mAppHomeDir = home;

   // On Unix systems, the default temp dir is in /tmp.
   // Search path (in this order):
   // * The AUDACITY_PATH environment variable
   // * The current directory
   // * The user's .audacity-files directory in their home directory
   // * The "share" and "share/doc" directories in their install path
   #ifdef __WXGTK__
   defaultTempDir.Printf(wxT("/tmp/audacity1.2-%s"), wxGetUserId().c_str());
   wxString pathVar = wxGetenv(wxT("AUDACITY_PATH"));
   if (pathVar != wxT(""))
      AddMultiPathsToPathList(pathVar, audacityPathList);
   AddUniquePathToPathList(FROMFILENAME(::wxGetCwd()), audacityPathList);
   AddUniquePathToPathList(wxString::Format(wxT("%s/.audacity-files"),
                                            home.c_str()),
                           audacityPathList);
   #ifdef AUDACITY_NAME
      AddUniquePathToPathList(wxString::Format(wxT("%s/share/%s"),
                                               wxT(INSTALL_PREFIX), wxT(AUDACITY_NAME)),
                              audacityPathList);
      AddUniquePathToPathList(wxString::Format(wxT("%s/share/doc/%s"),
                                               wxT(INSTALL_PREFIX), wxT(AUDACITY_NAME)),
                              audacityPathList);
   #else
      AddUniquePathToPathList(wxString::Format(wxT("%s/share/audacity"),
                                               wxT(INSTALL_PREFIX)),
                              audacityPathList);
      AddUniquePathToPathList(wxString::Format(wxT("%s/share/doc/audacity"),
                                               wxT(INSTALL_PREFIX)),
                              audacityPathList);
   #endif

   AddUniquePathToPathList(wxString::Format(wxT("%s/share/locale"),
                                            wxT(INSTALL_PREFIX)),
                           audacityPathList);

   #endif

   wxFileName tmpFile;
   tmpFile.AssignTempFileName(wxT("nn"));
   wxString tmpDirLoc = tmpFile.GetPath(wxPATH_GET_VOLUME);
   ::wxRemoveFile(FILENAME(tmpFile.GetFullPath()));

   // On Mac and Windows systems, use the directory which contains Audacity.
   #ifdef __WXMSW__
   // On Windows, the path to the Audacity program is in argv[0]
   wxString progPath = wxPathOnly(argv[0]);
   AddUniquePathToPathList(progPath, audacityPathList);
   AddUniquePathToPathList(progPath+wxT("\\Languages"), audacityPathList);
   defaultTempDir.Printf(wxT("%s\\audacity_1_2_temp"), tmpDirLoc.c_str());
   #endif
   #ifdef __MACOSX__
   // On Mac OS X, the path to the Audacity program is in argv[0]
   wxString progPath = wxPathOnly(argv[0]);

   AddUniquePathToPathList(progPath, audacityPathList);
   // If Audacity is a "bundle" package, then the root directory is
   // the great-great-grandparent of the directory containing the executable.
   AddUniquePathToPathList(progPath+wxT("/../../../"), audacityPathList);

   AddUniquePathToPathList(progPath+wxT("/Languages"), audacityPathList);
   AddUniquePathToPathList(progPath+wxT("/../../../Languages"), audacityPathList);
   defaultTempDir.Printf(wxT("%s/audacity1.2-%s"),
                         tmpDirLoc.c_str(),
                         wxGetUserId().c_str());
   #endif
   #ifdef __MACOS9__
   // On Mac OS 9, the initial working directory is the one that
   // contains the program.
   wxString progPath = wxGetCwd();
   AddUniquePathToPathList(progPath, audacityPathList);
   AddUniquePathToPathList(progPath+wxT(":Languages"), audacityPathList);
   defaultTempDir.Printf(wxT("%s/audacity_1_2_temp"), tmpDirLoc.c_str());
   #endif

   // BG: Create a temporary window to set as the top window
   wxFrame *temporarywindow = new wxFrame(NULL, -1, wxT("temporarytopwindow"));
   SetTopWindow(temporarywindow);

   // Locale
   // wxWindows 2.3 has a much nicer wxLocale API.  We can make this code much
   // better once we move to wx 2.3/2.4.

   wxString lang = gPrefs->Read(wxT("/Locale/Language"), wxT(""));

   // Pop up a dialog the first time the program is run
   if (lang == wxT(""))
      lang = ChooseLanguage(NULL);

#ifdef NOT_RQD
//TIDY-ME: (CleanSpeech) Language prompt??
// The prompt for language only happens ONCE on a system.
// I don't think we should disable it JKC
   wxString lang = gPrefs->Read(wxT("/Locale/Language"), "en");  //lda

// Pop up a dialog the first time the program is run
//lda   if (lang == "")
//lda      lang = ChooseLanguage(NULL);
#endif
   gPrefs->Write(wxT("/Locale/Language"), lang);

   if (lang != wxT("en")) {
      wxLogNull nolog;
      mLocale = new wxLocale(wxT(""), lang, wxT(""), true, true);

      for(unsigned int i=0; i<audacityPathList.GetCount(); i++)
         mLocale->AddCatalogLookupPathPrefix(audacityPathList[i]);

#ifdef AUDACITY_NAME
      mLocale->AddCatalog(wxT(AUDACITY_NAME));
#else
      mLocale->AddCatalog(wxT("audacity"));
#endif
   } else
      mLocale = NULL;

   // Initialize internationalisation (number formats etc.)
   //
   // This must go _after_ creating the wxLocale instance because
   // creating the wxLocale instance sets the application-wide locale.
   Internat::Init();

   // Init DirManager, which initializes the temp directory
   // If this fails, we must exit the program.

   if (!InitTempDir()) {
      FinishPreferences();
      return false;
   }

   // More initialization
   InitCleanSpeech();

   InitDitherers();
   InitAudioIO();

   LoadEffects();

#ifdef __WXMAC__

   // On the Mac, users don't expect a program to quit when you close the last window.
   // Create an offscreen frame with a menu bar.  The frame should never
   // be visible, but when all other windows are closed, this menu bar should
   // become visible.

   gParentFrame = new wxFrame(NULL, -1, wxT("invisible"), wxPoint(5000, 5000), wxSize(100, 100));

   wxMenu *fileMenu = new wxMenu();
   fileMenu->Append(wxID_NEW, wxT("&New\tCtrl+N"));
   fileMenu->Append(wxID_OPEN, wxT("&Open...\tCtrl+O"));
   /* i18n-hint: Mac OS X shortcut should be Ctrl+, */
   fileMenu->Append(wxID_PREFERENCES, _("&Preferences...\tCtrl+,"));

   wxMenuBar *menuBar = new wxMenuBar();
   menuBar->Append(fileMenu, wxT("&File"));

   gParentFrame->SetMenuBar(menuBar);

   gParentFrame->Show();

   SetTopWindow(gParentFrame);

#endif

   SetExitOnFrameDelete(true);


   ///////////////////////////////////////////////////////////////////
   //////////////////////////////////////////////////////////////////
   //Initiate pointers to toolbars here, and create 
   //the toolbars that should be loaded at startup.

   gControlToolBarStub = 
      LoadToolBar( wxT(""),true,
      gParentWindow,ControlToolBarID);
   gMixerToolBarStub = 
      LoadToolBar( wxT("/GUI/EnableMixerToolBar"),true,
      gParentWindow,MixerToolBarID);
   gMeterToolBarStub = 
      LoadToolBar( wxT("/GUI/EnableMeterToolBar"),true,
      gParentWindow,MeterToolBarID);
   gEditToolBarStub = 
      LoadToolBar( wxT("/GUI/EnableEditToolBar"),true,
      gParentWindow,EditToolBarID);
   gTranscriptionToolBarStub = 
      LoadToolBar( wxT("/GUI/EnableTranscriptionToolBar"),false,
      gParentWindow,TranscriptionToolBarID);

   /// ToolBar Initiation Complete.
   ////////////////////////////////////////////////////////////////
   ////////////////////////////////////////////////////////////////

   AudacityProject *project = CreateNewAudacityProject(gParentWindow);
   SetTopWindow(project);

   delete temporarywindow;

   // Can't handle command-line args on Mac OS X yet...
   // Cygwin command-line parser below...
   #if !defined(__MACOSX__) && !defined(__CYGWIN__)
   // Parse command-line arguments
   if (argc > 1) {
      for (int option = 1; option < argc; option++) {
         if (!argv[option])
            continue;
         bool handled = false;

         if (!wxString(wxT("-help")).CmpNoCase(argv[option])) {
            wxPrintf(/* i18n-hint: '-help', '-test' and
                      '-blocksize' need to stay in English. */
                   _("Command-line options supported:\n  -help (this message)\n  -test (run self diagnostics)\n  -blocksize ### (set max disk block size in bytes)\n\nIn addition, specify the name of an audio file or Audacity project\nto open it.\n\n"));
            exit(0);
         }

         if (option < argc - 1 &&
             argv[option + 1] &&
             !wxString(wxT("-blocksize")).CmpNoCase(argv[option])) {
            long theBlockSize;
            if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
               if (theBlockSize >= 256 && theBlockSize < 100000000) {
                  wxFprintf(stderr, _("Using block size of %ld\n"),
                          theBlockSize);
                  Sequence::SetMaxDiskBlockSize(theBlockSize);
               }
            }
            option++;
            handled = true;
         }

         if (!handled && !wxString(wxT("-test")).CmpNoCase(argv[option])) {
            RunBenchmark(NULL);
            exit(0);
         }

         if (argv[option][0] == wxT('-') && !handled) {
            wxPrintf(_("Unknown command line option: %s\n"), argv[option]);
            exit(0);
         }

         if (!handled)
            project->OpenFile(argv[option]);

      }                         // for option...
   }                            // if (argc>1)
   #endif // not Mac OS X
	
   // Cygwin command line parser (by Dave Fancella)
   #if defined(__CYGWIN__)
   if (argc > 1) {
      int optionstart = 1;
      bool startAtOffset = false;
		
      // Scan command line arguments looking for trouble
      for (int option = 1; option < argc; option++) {
         if (!argv[option])
            continue;
         // Check to see if argv[0] is copied across other arguments.
         // This is the reason Cygwin gets its own command line parser.
         if (wxString(argv[option]).Lower().Contains(wxString(wxT("audacity.exe")))) {
            startAtOffset = true;
            optionstart = option + 1;
         }
      }
		
      for (int option = optionstart; option < argc; option++) {
         if (!argv[option])
            continue;
         bool handled = false;
         bool openThisFile = false;
         wxString fileToOpen;
			
         if (!wxString(wxT("-help")).CmpNoCase(argv[option])) {
            wxPrintf(/* i18n-hint: '-help', '-test' and
                      '-blocksize' need to stay in English. */
                   _("Command-line options supported:\n"
                     "  -help (this message)\n"
                     "  -test (run self diagnostics)\n"
                     "  -blocksize ### (set max disk block size in bytes)\n"
                     "\n"
                     "In addition, specify the name of an audio file or "
                     "Audacity project\n" "to open it.\n" "\n"));
            exit(0);
         }

         if (option < argc - 1 &&
             argv[option + 1] &&
             !wxString(wxT("-blocksize")).CmpNoCase(argv[option])) {
            long theBlockSize;
            if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
               if (theBlockSize >= 256 && theBlockSize < 100000000) {
                  wxFprintf(stderr, _("Using block size of %ld\n"),
                          theBlockSize);
                  Sequence::SetMaxDiskBlockSize(theBlockSize);
               }
            }
            option++;
            handled = true;
         }

         if (!handled && !wxString(wxT("-test")).CmpNoCase(argv[option])) {
            RunBenchmark(NULL);
            exit(0);
         }

         if (argv[option][0] == wxT('-') && !handled) {
            wxPrintf(_("Unknown command line option: %s\n"), argv[option]);
            exit(0);
         }
			
         if(handled)
            fileToOpen.Clear();
			
         if (!handled)
            fileToOpen = fileToOpen + wxT(" ") + argv[option];
         if(wxString(argv[option]).Lower().Contains(wxT(".aup")))
            openThisFile = true;
         if(openThisFile) {
            openThisFile = false;
            project->OpenFile(fileToOpen);
         }

      }                         // for option...
   }                            // if (argc>1)
   #endif // Cygwin command-line parser

   gInited = true;

   return TRUE;
}
예제 #12
0
//Función para cargar los recursos necesarios para el juego.
bool cGame::LoadResources( void )
{

	bool lbResult;

	lbResult = LoadWindowProperties();

	if ( lbResult )
	{
		//Se inicializa la clase que encapsula las operaciones de OpenGL:
		lbResult = cGraphicManager::Get().Init( &cWindow::Get() );   

		// Clean Window context
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     
		// Resetea color de fondo
		glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

		if (lbResult)
		{
			//Se inicializa la clase que gestiona la texturas indicando que habrá 1, por ejemplo.
			cTextureManager::Get().Init(60);

			mMad_drive_loading = cTextureManager::Get().LoadResource( "Mad_drive_loading", "Data/Scene/images/hud/mad_drive_loading.png" );
			mMad_drive = cTextureManager::Get().LoadResource( "Mad_drive", "Data/Scene/images/hud/mad_drive.png" );
			mLoading = cTextureManager::Get().LoadResource( "Loading", "Data/Scene/images/hud/loading.png" );

			Load2DCameraProperties();

			cGraphicManager::Get().ActivateCamera( &m2DCamera );

			RenderProgress(0.1f);

			Load3DCameraProperties();

			RenderProgress(0.2f);

			LoadIAProperties();

			LoadManagerProperties();

			RenderProgress(0.3f);

			//Se carga la escena.
			//mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/dragonsmall.DAE" ); 		
			//*mDuck = cSceneManager::Get().LoadResource( "Duck", "./Data/Scene/duck_triangulate.dae" ); 
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_cactus.dae" ); 
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_carretera.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_matorral.dae" ); 
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_palmera.dae" ); 
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_tronco.dae" ); 

			LoadVehicles();

			RenderProgress(0.5f);

			LoadHUD();

			RenderProgress(0.6f);

			LoadEffects();

			RenderProgress(0.7f);

			LoadObstacles();

			RenderProgress(0.85f);

//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2_exterior.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2_arma.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2_rueda.dae" );
//		    mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mad_drive_escombros_ruina.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/combustible.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/especial_invencibilidad.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/especial_superturbo.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/municion.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo1_destruido_arma.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo1_destruido_exterior.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2_destruido_arma.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/enemigo2_destruido_exterior.dae" );
//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/mustang_destruido_exterior.dae" );
			//mScene1 = cSceneManager::Get().LoadResource( "TestLevel1", "./Data/Scene/mustang_destruido_interior.dae" );
			
			// Loads skeleton 
		//	cResourceHandle mustang_mesh = cMeshManager::Get().LoadResource("testlevel1", "./Data/Scene/mustang_destruido_interior.dae");

			/*if (!((cScene *)mScene.GetResource())->Init("TestLevel1", "./Data/Scene/mustang_destruido_interior.dae")){
				OutputDebugStr("Error loading object!");
			}*/

//			mScene = cSceneManager::Get().LoadResource( "TestLevel", "./Data/Scene/plane.DAE" );

			//cPhysicObject mModelObject = *((cPhysicObject*) ((cScene *)mScene.GetResource())->getSubObject( 1 ));


			// Inits skeleton model
			//cSkeletalManager::Get().LoadResource("Skeleton", "./Data/Skeletal/SkeletonModel.xml");
		
			// Loads skeleton 
			//mSkeletalMesh = cMeshManager::Get().LoadResource("Skeleton", "Skeleton", kuiSkeletalMesh);

			// Get skeleton mesh
			//cSkeletalMesh* lpSkeletonMesh=(cSkeletalMesh*)mSkeletalMesh.GetResource();

			// Load Skeleton meshes
			//cResourceHandle lMaterial = cMaterialManager::Get().LoadResource("Skeleton", "./Data/Material/SkeletonMaterial.xml");
		
			//assert(lMaterial.IsValidHandle());
			//mObject.AddMesh(mSkeletalMesh, lMaterial);	
		
			// Bounding box del personaje
			/*mBoxModel.InitBox( 0.0f, cVec3( 0.3f, 1.0f, 0.3f ) );
			mObject.CreatePhysics( &mBoxModel );
			lScaleMatrix.LoadScale(0.01f);
			mObject.SetScaleMatrix( lScaleMatrix );*/

			LoadObjects();

			RenderProgress(1.0f);
			
			LoadWorld();

		} else {
			//Si algo falla se libera la ventana.
			cWindow::Get().Deinit();
		}
	}

   return lbResult;
}
예제 #13
0
bool SequenceElements::LoadSequencerFile(xLightsXmlFile& xml_file)
{
    mFilename = xml_file;
    wxXmlDocument& seqDocument = xml_file.GetXmlDocument();

    wxXmlNode* root=seqDocument.GetRoot();
    std::vector<std::string> effectStrings;
    std::vector<std::string> colorPalettes;
    Clear();
    for(wxXmlNode* e=root->GetChildren(); e!=NULL; e=e->GetNext() )
    {
       if (e->GetName() == "DisplayElements")
       {
            for(wxXmlNode* element=e->GetChildren(); element!=NULL; element=element->GetNext() )
            {
                bool active=false;
                bool selected=false;
                bool collapsed=false;
                std::string name = element->GetAttribute(STR_NAME).ToStdString();
                std::string type = element->GetAttribute(STR_TYPE).ToStdString();
                bool visible = element->GetAttribute("visible")=='1'?true:false;

                if (type==STR_TIMING)
                {
                    active = element->GetAttribute("active")=='1'?true:false;
                }
                else
                {
                    collapsed = element->GetAttribute("collapsed")=='1'?true:false;
                }
                Element* elem = AddElement(name,type,visible,collapsed,active,selected);
                if (type==STR_TIMING)
                {
                    std::string views = element->GetAttribute("views", "").ToStdString();
                    elem->SetViews(views);
                }
            }
       }
       else if (e->GetName() == "EffectDB")
       {
           effectStrings.clear();
           for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
           {
               if(elementNode->GetName()==STR_EFFECT)
               {
                   effectStrings.push_back(elementNode->GetNodeContent().ToStdString());
               }
           }
       }
       else if (e->GetName() == "ColorPalettes")
       {
           colorPalettes.clear();
           for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
           {
               if(elementNode->GetName() == STR_COLORPALETTE)
               {
                   colorPalettes.push_back(elementNode->GetNodeContent().ToStdString());
               }
           }
       }
       else if (e->GetName() == "ElementEffects")
        {
            for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
            {
                if(elementNode->GetName()==STR_ELEMENT)
                {
                    Element* element = GetElement(elementNode->GetAttribute(STR_NAME).ToStdString());
                    if (element !=NULL)
                    {
                        // check for fixed timing interval
                        int interval = 0;
                        if( elementNode->GetAttribute(STR_TYPE) == STR_TIMING )
                        {
                            interval = wxAtoi(elementNode->GetAttribute("fixed"));
                        }
                        if( interval > 0 )
                        {
                            element->SetFixedTiming(interval);
                            EffectLayer* effectLayer = element->AddEffectLayer();
                            int time = 0;
                            int end_time = xml_file.GetSequenceDurationMS();
                            int startTime, endTime, next_time;
                            while( time <= end_time )
                            {
                                next_time = (time + interval <= end_time) ? time + interval : end_time;
                                startTime = TimeLine::RoundToMultipleOfPeriod(time,mFrequency);
                                endTime = TimeLine::RoundToMultipleOfPeriod(next_time,mFrequency);
                                effectLayer->AddEffect(0,"","","",startTime,endTime,EFFECT_NOT_SELECTED,false);
                                time += interval;
                            }
                        }
                        else
                        {
                            for(wxXmlNode* effectLayerNode=elementNode->GetChildren(); effectLayerNode!=NULL; effectLayerNode=effectLayerNode->GetNext())
                            {
                                if (effectLayerNode->GetName() == STR_EFFECTLAYER || effectLayerNode->GetName() == STR_STRAND)
                                {
                                    EffectLayer* effectLayer = NULL;
                                    if (effectLayerNode->GetName() == STR_EFFECTLAYER) {
                                        effectLayer = element->AddEffectLayer();
                                    } else {
                                        effectLayer = element->GetStrandLayer(wxAtoi(effectLayerNode->GetAttribute(STR_INDEX)), true);
                                        if (effectLayerNode->GetAttribute(STR_NAME, STR_EMPTY) != STR_EMPTY) {
                                            ((StrandLayer*)effectLayer)->SetName(effectLayerNode->GetAttribute(STR_NAME).ToStdString());
                                        }
                                    }
                                    LoadEffects(effectLayer, elementNode->GetAttribute(STR_TYPE).ToStdString(), effectLayerNode, effectStrings, colorPalettes);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    // Select view and set current view models as visible
    int last_view = xml_file.GetLastView();
    for(wxXmlNode* view=mViewsNode->GetChildren(); view!=NULL; view=view->GetNext() )
    {
        std::string viewName = view->GetAttribute(STR_NAME).ToStdString();
        std::string models = view->GetAttribute("models").ToStdString();
        std::vector <Element*> new_view;
        mAllViews.push_back(new_view);
        int view_index = mAllViews.size()-1;
        if( view_index == last_view )
        {
            AddMissingModelsToSequence(models);
            PopulateView(models, view_index);
            SetCurrentView(view_index);
        }
    }

    if (mModelsNode != nullptr) {
        PopulateRowInformation();
    }
    // Set to the first model/view
    mFirstVisibleModelRow = 0;
    return true;
}
예제 #14
0
void SequenceElements::LoadEffects(EffectLayer *effectLayer,
                                   const std::string &type,
                                   wxXmlNode *effectLayerNode,
                                   const std::vector<std::string> & effectStrings,
                                   const std::vector<std::string> & colorPalettes) {
    for(wxXmlNode* effect=effectLayerNode->GetChildren(); effect!=NULL; effect=effect->GetNext())
    {
        if (effect->GetName() == STR_EFFECT)
        {
            std::string effectName;
            std::string settings;
            int id = 0;
            long palette = -1;
            bool bProtected=false;

            // Start time
            double startTime;
            effect->GetAttribute(STR_STARTTIME).ToDouble(&startTime);
            startTime = TimeLine::RoundToMultipleOfPeriod(startTime,mFrequency);
            // End time
            double endTime;
            effect->GetAttribute(STR_ENDTIME).ToDouble(&endTime);
            endTime = TimeLine::RoundToMultipleOfPeriod(endTime,mFrequency);
            // Protected
            bProtected = effect->GetAttribute(STR_PROTECTED)=='1'?true:false;
            if(type != STR_TIMING)
            {
                // Name
                effectName = effect->GetAttribute(STR_NAME);
                // ID
                id = wxAtoi(effect->GetAttribute(STR_ID, STR_ZERO));
                if (effect->GetAttribute(STR_REF) != STR_EMPTY) {
                    settings = effectStrings[wxAtoi(effect->GetAttribute(STR_REF))];
                } else {
                    settings = effect->GetNodeContent();
                }

                wxString tmp;
                if (effect->GetAttribute(STR_PALETTE, &tmp)) {
                    tmp.ToLong(&palette);
                }
            }
            else
            {
                // store timing labels in name attribute
                effectName = effect->GetAttribute(STR_LABEL);

            }
            effectLayer->AddEffect(id,effectName,settings,
                                   palette == -1 ? STR_EMPTY : colorPalettes[palette],
                                   startTime,endTime,EFFECT_NOT_SELECTED,bProtected);
        } else if (effect->GetName() == STR_NODE && effectLayerNode->GetName() == STR_STRAND) {
            EffectLayer* neffectLayer = ((StrandLayer*)effectLayer)->GetNodeLayer(wxAtoi(effect->GetAttribute(STR_INDEX)), true);
            if (effect->GetAttribute(STR_NAME, STR_EMPTY) != STR_EMPTY) {
                ((NodeLayer*)neffectLayer)->SetName(effect->GetAttribute(STR_NAME).ToStdString());
            }

            LoadEffects(neffectLayer, type, effect, effectStrings, colorPalettes);
        }
    }

}
예제 #15
0
// The `main program' equivalent, creating the windows and returning the
// main frame
bool AudacityApp::OnInit()
{
    // mChecker = new wxSingleInstanceChecker(GetAppName());
    ::wxInitAllImageHandlers();

    wxFileSystem::AddHandler(new wxZipFSHandler);

#ifdef __WXMSW__

    //BG: On Windows, associate the aup file type with Audacity
    {
        wxRegKey associateFileTypes;

        associateFileTypes.SetName("HKCR\\.AUP");
        associateFileTypes.Create(true);
        associateFileTypes = "Audacity.Project";

        associateFileTypes.SetName("HKCR\\Audacity.Project");
        associateFileTypes.Create(true);
        associateFileTypes = "Audacity Project File";

        associateFileTypes.SetName("HKCR\\Audacity.Project\\shell");
        associateFileTypes.Create(true);
        associateFileTypes = "";

        associateFileTypes.SetName("HKCR\\Audacity.Project\\shell\\open");
        associateFileTypes.Create(true);

        associateFileTypes.SetName("HKCR\\Audacity.Project\\shell\\open\\command");
        associateFileTypes.Create(true);
        associateFileTypes = (wxString)argv[0] + (wxString)" %1";
    }

#endif

    InitPreferences();
    InitAudioIO();

    // Locale
    // wxWindows 2.3 has a much nicer wxLocale API.  We can make this code much
    // better once we move to wx 2.3/2.4.

    wxString lang = gPrefs->Read("/Locale/Language", "en");

    if (lang != "en") {
        wxLogNull nolog;
        mLocale = new wxLocale("", lang, "", true, true);
        mLocale->AddCatalog("audacity");
    } else
        mLocale = NULL;

    LoadEffects(wxPathOnly(argv[0]));

#ifdef __WXMAC__

    // Install AppleEvent handlers (allows us to open documents
    // that are dragged to our application's icon)

    AEInstallEventHandler(kCoreEventClass,
                          kAEOpenDocuments,
                          NewAEEventHandlerUPP(AEOpenFiles), 0, 0);
    AEInstallEventHandler(kCoreEventClass,
                          kAEQuitApplication,
                          NewAEEventHandlerUPP(AEQuit), 0, 0);


    // On the Mac, users don't expect a program to quit when you close the last window.
    // Create an offscreen frame with a menu bar.  The frame should never
    // be visible, but when all other windows are closed, this menu bar should
    // become visible.

    gParentFrame = new wxFrame(NULL, -1, "invisible", wxPoint(5000, 5000), wxSize(100, 100));
    wxMenu *fileMenu = new wxMenu();
    fileMenu->Append(NewID, "&New\tCtrl+N");
    fileMenu->Append(OpenID, "&Open...\tCtrl+O");
    fileMenu->AppendSeparator();
    fileMenu->Append(PreferencesID, "&Preferences...\tCtrl+P");
    fileMenu->AppendSeparator();
    fileMenu->Append(ExitID, "Quit\tCtrl+Q");
    wxMenu *helpMenu = new wxMenu();
    helpMenu->Append(AboutID, "About Audacity...");
    wxApp::s_macAboutMenuItemId = AboutID;

    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(fileMenu, "&File");
    menuBar->Append(helpMenu, "&Help");

    gParentFrame->SetMenuBar(menuBar);
    gParentFrame->Show();

    SetTopWindow(gParentFrame);

#endif

    SetExitOnFrameDelete(true);

    //Initiate pointers to toolbars here, and create
    //the toolbars that should be loaded at startup.


    //Initiate globally-held toolbar stubs here.
    gControlToolBarStub = new ToolBarStub(gParentWindow, ControlToolBarID);

    // Changing the following to NULL will make the application
    // load without the toolbar in memory at all.

    bool editToolBar;
    gPrefs->Read("/GUI/EnableEditToolBar", &editToolBar, true);
    if(editToolBar)
        gEditToolBarStub =  new ToolBarStub(gParentWindow, EditToolBarID);
    else
        gEditToolBarStub = NULL;


    InitFreqWindow(gParentWindow);
    AudacityProject *project = CreateNewAudacityProject(gParentWindow);
    SetTopWindow(project);

    // Can't handle command-line args on Mac OS X yet...
#ifndef __MACOSX__

    // Parse command-line arguments

    if (argc > 1) {
        for (int option = 1; option < argc; option++) {
            if (!argv[option])
                continue;
            bool handled = false;

            if (!wxString("-help").CmpNoCase(argv[option])) {
                printf(_("Command-line options supported:\n"
                         "  -help (this message)\n"
                         "  -test (run self diagnostics)\n"
                         "  -blocksize ### (set max disk block size in bytes)\n"
                         "\n"
                         "In addition, specify the name of an audio file or "
                         "Audacity project\n" "to open it.\n" "\n"));
                exit(0);
            }

            if (option < argc - 1 &&
                    argv[option + 1] &&
                    !wxString("-blocksize").CmpNoCase(argv[option])) {
                long theBlockSize;
                if (wxString(argv[option + 1]).ToLong(&theBlockSize)) {
                    if (theBlockSize >= 256 && theBlockSize < 100000000) {
                        fprintf(stderr, _("Using block size of %ld\n"),
                                theBlockSize);
                        Sequence::SetMaxDiskBlockSize(theBlockSize);
                    }
                }
                option++;
                handled = true;
            }

            if (!handled && !wxString("-test").CmpNoCase(argv[option])) {
                RunBenchmark(NULL);
                exit(0);
            }

            if (argv[option][0] == '-' && !handled) {
                printf(_("Unknown command line option: %s\n"), argv[option]);
                exit(0);
            }

            if (!handled)
                project->OpenFile(argv[option]);

        }                         // for option...
    }                            // if (argc>1)

#endif // not Mac OS X

    return TRUE;
}
예제 #16
0
void SequenceElements::LoadEffects(EffectLayer *effectLayer,
                                   const std::string &type,
                                   wxXmlNode *effectLayerNode,
                                   const std::vector<std::string> & effectStrings,
                                   const std::vector<std::string> & colorPalettes) {
    log4cpp::Category &logger_base = log4cpp::Category::getInstance(std::string("log_base"));
    for(wxXmlNode* effect=effectLayerNode->GetChildren(); effect!=NULL; effect=effect->GetNext())
    {
        if (effect->GetName() == STR_EFFECT)
        {
            std::string effectName;
            std::string settings;
            int id = 0;
            long palette = -1;
            bool bProtected=false;

            // Start time
            double startTime;
            effect->GetAttribute(STR_STARTTIME).ToDouble(&startTime);
            startTime = TimeLine::RoundToMultipleOfPeriod(startTime,mFrequency);
            // End time
            double endTime;
            effect->GetAttribute(STR_ENDTIME).ToDouble(&endTime);
            endTime = TimeLine::RoundToMultipleOfPeriod(endTime,mFrequency);
            // Protected
            bProtected = effect->GetAttribute(STR_PROTECTED)=='1'?true:false;
            if(type != STR_TIMING)
            {
                // Name
                effectName = effect->GetAttribute(STR_NAME);
                // ID
                id = wxAtoi(effect->GetAttribute(STR_ID, STR_ZERO));
                if (effect->GetAttribute(STR_REF) != STR_EMPTY) {
                    int ref = wxAtoi(effect->GetAttribute(STR_REF));
                    if (ref >= effectStrings.size())
                    {
                        logger_base.warn("Effect string not found for effect %s between %d and %d. Settings ignored.", effectName.c_str(), (int)startTime, (int)endTime);
                        settings = "";
                    }
                    else
                    {
                        settings = effectStrings[ref];
                    }
                } else {
                    settings = effect->GetNodeContent();
                }

				if (settings.find("E_FILEPICKER_Pictures_Filename") != std::string::npos)
				{
					settings = xLightsXmlFile::FixEffectFileParameter("E_FILEPICKER_Pictures_Filename", settings, "");
				}
				else if (settings.find("E_TEXTCTRL_Glediator_Filename") != std::string::npos)
				{
					settings = xLightsXmlFile::FixEffectFileParameter("E_TEXTCTRL_Glediator_Filename", settings, "");
				}
				else if (settings.find("E_TEXTCTRL_Piano_CueFilename") != std::string::npos)
				{
					settings = xLightsXmlFile::FixEffectFileParameter("E_TEXTCTRL_Piano_CueFilename", settings, "");
				}
				else if (settings.find("E_TEXTCTRL_Piano_MapFilename") != std::string::npos)
				{
					settings = xLightsXmlFile::FixEffectFileParameter("E_TEXTCTRL_Piano_MapFilename", settings, "");
				}
				else if (settings.find("E_TEXTCTRL_Piano_ShapeFilename") != std::string::npos)
				{
					settings = xLightsXmlFile::FixEffectFileParameter("E_TEXTCTRL_Piano_ShapeFilename", settings, "");
				}

                wxString tmp;
                if (effect->GetAttribute(STR_PALETTE, &tmp)) {
                    tmp.ToLong(&palette);
                }
            }
            else
            {
                // store timing labels in name attribute
                effectName = effect->GetAttribute(STR_LABEL);

            }
            effectLayer->AddEffect(id,effectName,settings,
                                   palette == -1 ? STR_EMPTY : colorPalettes[palette],
                                   startTime,endTime,EFFECT_NOT_SELECTED,bProtected);
        } else if (effect->GetName() == STR_NODE && effectLayerNode->GetName() == STR_STRAND) {
            EffectLayer* neffectLayer = ((StrandLayer*)effectLayer)->GetNodeLayer(wxAtoi(effect->GetAttribute(STR_INDEX)), true);
            if (effect->GetAttribute(STR_NAME, STR_EMPTY) != STR_EMPTY) {
                ((NodeLayer*)neffectLayer)->SetName(effect->GetAttribute(STR_NAME).ToStdString());
            }

            LoadEffects(neffectLayer, type, effect, effectStrings, colorPalettes);
        }
    }

}