Ogre::DataStreamPtr OMEFileSystemArchive::open(const Ogre::String& filename, bool readOnly) const { Ogre::String full_path = concatenate_path(mName, filename); // Use filesystem to determine size // (quicker than streaming to the end and back) struct stat tagStat; int ret = stat(full_path.c_str(), &tagStat); assert(ret == 0 && "Problem getting file size" ); (void)ret; // Silence warning // Always open in binary mode // Also, always include reading std::ios::openmode mode = std::ios::in | std::ios::binary; std::istream* baseStream = 0; std::ifstream* roStream = 0; std::fstream* rwStream = 0; if (!readOnly && isReadOnly()) { mode |= std::ios::out; rwStream = OGRE_NEW_T(std::fstream, Ogre::MEMCATEGORY_GENERAL)(); rwStream->open(full_path.c_str(), mode); baseStream = rwStream; } else { roStream = OGRE_NEW_T(std::ifstream, Ogre::MEMCATEGORY_GENERAL)(); roStream->open(full_path.c_str(), mode); baseStream = roStream; } // Should check ensure open succeeded, in case fail for some reason. if (baseStream->fail()) { OGRE_DELETE_T(roStream, basic_ifstream, Ogre::MEMCATEGORY_GENERAL); OGRE_DELETE_T(rwStream, basic_fstream, Ogre::MEMCATEGORY_GENERAL); OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "Cannot open file: " + filename, "FileSystemArchive::open"); } /// Construct return stream, tell it to delete on destroy Ogre::FileStreamDataStream* stream = 0; if (rwStream) { // use the writeable stream stream = OGRE_NEW Ogre::FileStreamDataStream(filename, rwStream, (size_t)tagStat.st_size, true); } else { // read-only stream Ogre::String newName = mName + ":" + filename; stream = OGRE_NEW Ogre::FileStreamDataStream(newName, roStream, (size_t)tagStat.st_size, true); } return Ogre::DataStreamPtr(stream); }
//----------------------------------------------------------------------- void PhysXActorExtern::setPhysicsShape(PhysicsShapeDesc* physicsShapeDesc) { if (mPhysicsShapeDesc) { OGRE_DELETE_T(mPhysicsShapeDesc, PhysicsShapeDesc, Ogre::MEMCATEGORY_SCENE_OBJECTS); } switch (physicsShapeDesc->mPhysicsShapeType) { case ST_BOX: { PhysicsBoxDesc* physicsBoxDesc = static_cast<PhysicsBoxDesc*>(physicsShapeDesc); mPhysicsShapeDesc = OGRE_NEW_T(PhysicsBoxDesc, Ogre::MEMCATEGORY_SCENE_OBJECTS)(*physicsBoxDesc); } break; case ST_SPHERE: { PhysicsSphereDesc* physicsSphereDesc = static_cast<PhysicsSphereDesc*>(physicsShapeDesc); mPhysicsShapeDesc = OGRE_NEW_T(PhysicsSphereDesc, Ogre::MEMCATEGORY_SCENE_OBJECTS)(*physicsSphereDesc); } break; case ST_CAPSULE: { PhysicsCapsuleDesc* physicsCapsuleDesc = static_cast<PhysicsCapsuleDesc*>(physicsShapeDesc); mPhysicsShapeDesc = OGRE_NEW_T(PhysicsCapsuleDesc, Ogre::MEMCATEGORY_SCENE_OBJECTS)(*physicsCapsuleDesc); } break; } }
//----------------------------------------------------------------------- void ConfigFile::load(const DataStreamPtr& stream, const String& separators, bool trimWhitespace) { /* Clear current settings map */ clear(); String currentSection = StringUtil::BLANK; SettingsMultiMap* currentSettings = OGRE_NEW_T(SettingsMultiMap, MEMCATEGORY_GENERAL)(); mSettings[currentSection] = currentSettings; /* Process the file line for line */ String line, optName, optVal; while (!stream->eof()) { line = stream->getLine(); /* Ignore comments & blanks */ if (line.length() > 0 && line.at(0) != '#' && line.at(0) != '@') { if (line.at(0) == '[' && line.at(line.length()-1) == ']') { // Section currentSection = line.substr(1, line.length() - 2); SettingsBySection::const_iterator seci = mSettings.find(currentSection); if (seci == mSettings.end()) { currentSettings = OGRE_NEW_T(SettingsMultiMap, MEMCATEGORY_GENERAL)(); mSettings[currentSection] = currentSettings; } else { currentSettings = seci->second; } } else { /* Find the first seperator character and split the string there */ Ogre::String::size_type separator_pos = line.find_first_of(separators, 0); if (separator_pos != Ogre::String::npos) { optName = line.substr(0, separator_pos); /* Find the first non-seperator character following the name */ Ogre::String::size_type nonseparator_pos = line.find_first_not_of(separators, separator_pos); /* ... and extract the value */ /* Make sure we don't crash on an empty setting (it might be a valid value) */ optVal = (nonseparator_pos == Ogre::String::npos) ? "" : line.substr(nonseparator_pos); if (trimWhitespace) { StringUtil::trim(optVal); StringUtil::trim(optName); } currentSettings->insert(SettingsMultiMap::value_type(optName, optVal)); } } } } }
//----------------------------------------------------------------------- TextureRotator::TextureRotator(void) : ParticleAffector(), mUseOwnRotationSpeed(DEFAULT_USE_OWN_SPEED), mScaledRotationSpeed(Ogre::Radian(0)), twoPiRad(Ogre::Radian(Ogre::Math::TWO_PI)) { mDynRotation = OGRE_NEW_T(DynamicAttributeFixed, Ogre::MEMCATEGORY_SCENE_OBJECTS)(); (static_cast<DynamicAttributeFixed*>(mDynRotation))->setValue(DEFAULT_ROTATION); mDynRotationSpeed = OGRE_NEW_T(DynamicAttributeFixed, Ogre::MEMCATEGORY_SCENE_OBJECTS)(); (static_cast<DynamicAttributeFixed*>(mDynRotationSpeed))->setValue(DEFAULT_ROTATION_SPEED); }
//--------------------------------------------------------------------- void AnimationState::createBlendMask(size_t blendMaskSizeHint, float initialWeight) { if(!mBlendMask) { if(initialWeight >= 0) { mBlendMask = OGRE_NEW_T(BoneBlendMask, MEMCATEGORY_ANIMATION)(blendMaskSizeHint, initialWeight); } else { mBlendMask = OGRE_NEW_T(BoneBlendMask, MEMCATEGORY_ANIMATION)(blendMaskSizeHint); } } }
//----------------------------------------------------------------------- JetAffector::JetAffector (void) : ParticleAffector(), mScaled(0.0f) { mDynAcceleration = OGRE_NEW_T(DynamicAttributeFixed, Ogre::MEMCATEGORY_SCENE_OBJECTS)(); (static_cast<DynamicAttributeFixed*>(mDynAcceleration))->setValue(DEFAULT_ACCELERATION); }
//--------------------------------------------------------------------- D3D11VideoModeList* D3D11Driver::getVideoModeList() { if(mVideoModeList.isNull()) mVideoModeList = SharedPtr<D3D11VideoModeList>(OGRE_NEW_T(D3D11VideoModeList, MEMCATEGORY_GENERAL)(getDeviceAdapter()), SPFM_DELETE_T); return mVideoModeList.get(); }
void ConfigFile::addSection(const Ogre::String& section, const Ogre::NameValuePairList& settings) { // Create new section mSettings[section] = OGRE_NEW_T(SettingsMultiMap, MEMCATEGORY_GENERAL); // Insert values from the settings list mSettings[section]->insert(settings.begin(), settings.end()); }
//----------------------------------------------------------------------- DataStreamPtr FileSystemArchive::open(const String& filename) const { #if (_MSC_VER >= 1400) // std::locale langLocale(""); // std::locale::global(langLocale); setlocale( LC_CTYPE, "" ); #endif String full_path = concatenate_path(mName, filename); // Use filesystem to determine size // (quicker than streaming to the end and back) struct stat tagStat; int ret = stat(full_path.c_str(), &tagStat); assert(ret == 0 && "Problem getting file size" ); // Always open in binary mode std::ifstream *origStream = OGRE_NEW_T(std::ifstream, MEMCATEGORY_GENERAL)(); origStream->open(full_path.c_str(), std::ios::in | std::ios::binary); // Should check ensure open succeeded, in case fail for some reason. if (origStream->fail()) { OGRE_DELETE_T(origStream, basic_ifstream, MEMCATEGORY_GENERAL); OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "Cannot open file: " + filename, "FileSystemArchive::open"); } /// Construct return stream, tell it to delete on destroy FileStreamDataStream* stream = OGRE_NEW FileStreamDataStream(filename, origStream, tagStat.st_size, true); return DataStreamPtr(stream); }
//----------------------------------------------------------------------- void QueuedRenderableCollection::merge( const QueuedRenderableCollection& rhs ) { mSortedDescending.insert( mSortedDescending.end(), rhs.mSortedDescending.begin(), rhs.mSortedDescending.end() ); PassGroupRenderableMap::const_iterator srcGroup; for( srcGroup = rhs.mGrouped.begin(); srcGroup != rhs.mGrouped.end(); ++srcGroup ) { PassGroupRenderableMap::iterator dstGroup = mGrouped.find( srcGroup->first ); if (dstGroup == mGrouped.end()) { std::pair<PassGroupRenderableMap::iterator, bool> retPair; // Create new pass entry, build a new list // Note that this pass and list are never destroyed until the // engine shuts down, or a pass is destroyed or has it's hash // recalculated, although the lists will be cleared retPair = mGrouped.insert( PassGroupRenderableMap::value_type( srcGroup->first, OGRE_NEW_T(RenderableList, MEMCATEGORY_SCENE_CONTROL)() )); assert(retPair.second && "Error inserting new pass entry into PassGroupRenderableMap"); dstGroup = retPair.first; } // Insert renderable dstGroup->second->insert( dstGroup->second->end(), srcGroup->second->begin(), srcGroup->second->end() ); } }
//------------------------------------------------------------------------ BackgroundProcessTicket ResourceBackgroundQueue::load( const String& resType, const String& name, const String& group, bool isManual, ManualResourceLoader* loader, const NameValuePairList* loadParams, ResourceBackgroundQueue::Listener* listener) { #if OGRE_THREAD_SUPPORT // queue a request ResourceRequest req; req.type = RT_LOAD_RESOURCE; req.resourceType = resType; req.resourceName = name; req.groupName = group; req.isManual = isManual; req.loader = loader; // Make instance copy of loadParams for thread independence req.loadParams = ( loadParams ? OGRE_NEW_T(NameValuePairList, MEMCATEGORY_GENERAL)( *loadParams ) : 0 ); req.listener = listener; return addRequest(req); #else // synchronous ResourceManager* rm = ResourceGroupManager::getSingleton()._getResourceManager(resType); rm->load(name, group, isManual, loader, loadParams); return 0; #endif }
//--------------------------------------------------------------------- Ogre::DataStreamPtr UnicodeFileSystemArchive::create(const String& _filename) const { if (isReadOnly()) { GOTHOGRE_EXCEPT(_filename << " - Cannot create a file in" << " read-only archive " << getName() << "."); } WString wfullpath = getFullPath(_filename); // Always open in binary mode // Also, always include reading std::ios::openmode mode = std::ios::out | std::ios::binary; std::fstream* rwStream = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)(); rwStream->open(wfullpath.c_str(), mode); // Should check ensure open succeeded, in case fail for some reason. if (rwStream->fail()) { OGRE_DELETE_T(rwStream, basic_fstream, MEMCATEGORY_GENERAL); GOTHOGRE_EXCEPT(_filename << " - Cannot create file in" << " archive " << getName() << "."); } GOTHOGRE_INFO(_filename << " - " << "Saving to" << " archive " << getName() << "."); /// Construct return stream, tell it to delete on destroy FileStreamDataStream* stream = OGRE_NEW FileStreamDataStream(_filename, rwStream, 0, true); return DataStreamPtr(stream); }
//------------------------------------------------------------------------- void LGPArchive::load() { //OGRE_LOCK_AUTO_MUTEX std::ifstream *ifs( OGRE_NEW_T( std::ifstream, Ogre::MEMCATEGORY_GENERAL )( mName.c_str(), std::ifstream::binary ) ); load( OGRE_NEW Ogre::FileStreamDataStream( ifs ) ); }
//--------------------------------------------------------------------- DataStreamPtr FileSystemArchive::create(const String& filename) const { if (isReadOnly()) { OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Cannot create a file in a read-only archive", "FileSystemArchive::remove"); } String full_path = concatenate_path(mName, filename); // Always open in binary mode // Also, always include reading std::ios::openmode mode = std::ios::out | std::ios::binary; std::fstream* rwStream = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)(); rwStream->open(full_path.c_str(), mode); // Should check ensure open succeeded, in case fail for some reason. if (rwStream->fail()) { OGRE_DELETE_T(rwStream, basic_fstream, MEMCATEGORY_GENERAL); OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "Cannot open file: " + filename, "FileSystemArchive::create"); } /// Construct return stream, tell it to delete on destroy FileStreamDataStream* stream = OGRE_NEW FileStreamDataStream(filename, rwStream, 0, true); return DataStreamPtr(stream); }
FileInfoListPtr findResourceFileInfo (const String& _groupName, const String& _pattern, bool _recursive, bool _dirs) { OGRE_LOCK_AUTO_MUTEX // MEMCATEGORY_GENERAL is the only category supported for SharedPtr FileInfoListPtr vec(OGRE_NEW_T(FileInfoList, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); // Try to find in resource index first ResourceGroup* grp = getResourceGroup(_groupName); if (!grp) { GOTHOGRE_EXCEPT( "Cannot locate a resource group called '" << _groupName << "'"); } OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME) // lock group mutex // Iterate over the archives LocationList::iterator i, iend; iend = grp->locationList.end(); for (i = grp->locationList.begin(); i != iend; ++i) { FileInfoListPtr lst = (*i)->archive->findFileInfo(_pattern, _recursive, _dirs); vec->insert(vec->end(), lst->begin(), lst->end()); } return vec; }
//----------------------------------------------------------------------- void QueuedRenderableCollection::addRenderable(Pass* pass, Renderable* rend) { // ascending and descending sort both set bit 1 if (mOrganisationMode & OM_SORT_DESCENDING) { mSortedDescending.push_back(RenderablePass(rend, pass)); } if (mOrganisationMode & OM_PASS_GROUP) { PassGroupRenderableMap::iterator i = mGrouped.find(pass); if (i == mGrouped.end()) { std::pair<PassGroupRenderableMap::iterator, bool> retPair; // Create new pass entry, build a new list // Note that this pass and list are never destroyed until the // engine shuts down, or a pass is destroyed or has it's hash // recalculated, although the lists will be cleared retPair = mGrouped.insert( PassGroupRenderableMap::value_type( pass, OGRE_NEW_T(RenderableList, MEMCATEGORY_SCENE_CONTROL)() )); assert(retPair.second && "Error inserting new pass entry into PassGroupRenderableMap"); i = retPair.first; } // Insert renderable i->second->push_back(rend); } }
//----------------------------------------------------------------------- DataStreamPtr FileSystemArchive::open(const String& filename, bool readOnly) const { String full_path = concatenate_path(mName, filename); // Use filesystem to determine size // (quicker than streaming to the end and back) struct stat tagStat; stat(full_path.c_str(), &tagStat); // Always open in binary mode std::ifstream *origStream = OGRE_NEW_T(std::ifstream, MEMCATEGORY_GENERAL)(); origStream->open(full_path.c_str(), std::ios::in | std::ios::binary); // Should check ensure open succeeded, in case fail for some reason. if (origStream->fail()) { OGRE_DELETE_T(origStream, basic_ifstream, MEMCATEGORY_GENERAL); OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND, "Cannot open file: " + filename, "FileSystemArchive::open"); } // Construct return stream, tell it to delete on destroy FileStreamDataStream* stream = OGRE_NEW FileStreamDataStream(filename, origStream, tagStat.st_size, true); return DataStreamPtr(stream); }
//--------------------------------------------------------------------- void DeflateStream::init() { mpZStream = OGRE_ALLOC_T(z_stream, 1, MEMCATEGORY_GENERAL); mpZStream->zalloc = OgreZalloc; mpZStream->zfree = OgreZfree; if (getAccessMode() == READ) { mpTmp = (unsigned char*)OGRE_MALLOC(OGRE_DEFLATE_TMP_SIZE, MEMCATEGORY_GENERAL); size_t restorePoint = mCompressedStream->tell(); // read early chunk mpZStream->next_in = mpTmp; mpZStream->avail_in = mCompressedStream->read(mpTmp, OGRE_DEFLATE_TMP_SIZE); if (inflateInit(mpZStream) != Z_OK) { mIsCompressedValid = false; } else mIsCompressedValid = true; if (mIsCompressedValid) { // in fact, inflateInit on some implementations doesn't try to read // anything. We need to at least read something to test Bytef testOut[4]; size_t savedIn = mpZStream->avail_in; mpZStream->avail_out = 4; mpZStream->next_out = testOut; if (inflate(mpZStream, Z_SYNC_FLUSH) != Z_OK) mIsCompressedValid = false; // restore for reading mpZStream->avail_in = savedIn; mpZStream->next_in = mpTmp; inflateReset(mpZStream); } if (!mIsCompressedValid) { // Not compressed data! // Fail gracefully, fall back on reading the underlying stream direct destroy(); mCompressedStream->seek(restorePoint); } } else { // Write to temp file char tmpname[L_tmpnam]; tmpnam(tmpname); mTempFileName = tmpname; std::fstream *f = OGRE_NEW_T(std::fstream, MEMCATEGORY_GENERAL)(); f->open(tmpname, std::ios::binary | std::ios::out); mTmpWriteStream = DataStreamPtr(OGRE_NEW FileStreamDataStream(f)); } }
//----------------------------------------------------------------------- FileInfoListPtr FileSystemArchive::listFileInfo(bool recursive, bool dirs) { FileInfoListPtr ret(OGRE_NEW_T(FileInfoList, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); findFiles("*", recursive, dirs, 0, ret.getPointer()); return ret; }
void MouseCursor::registerSkinDefinition() { SkinDefinition* d = OGRE_NEW_T(SkinDefinition,Ogre::MEMCATEGORY_GENERAL)("MouseCursor"); d->defineSkinElement(TEXTURE); d->definitionComplete(); SkinDefinitionManager::getSingleton().registerSkinDefinition("MouseCursor",d); }
//-------------------------------------------------------------------------- void MeshLodTests::setUp() { mFSLayer = OGRE_NEW_T(Ogre::FileSystemLayer, Ogre::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME); #ifdef OGRE_STATIC_LIB mStaticPluginLoader = OGRE_NEW StaticPluginLoader(); Root* root = OGRE_NEW Root(BLANKSTRING); mStaticPluginLoader.load(); #else String pluginsPath = mFSLayer->getConfigFilePath("plugins.cfg"); Root* root = OGRE_NEW Root(pluginsPath); #endif CPPUNIT_ASSERT(!root->getAvailableRenderers().empty()); root->setRenderSystem(root->getAvailableRenderers().back()); root->initialise(false); // Needed for setting up HardwareBufferManager #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE Ogre::NameValuePairList misc; // Tell OGRE that we're using cocoa, so it doesn't need to make a window for us misc["macAPI"] = "cocoa"; root->createRenderWindow("", 320, 240, false, &misc)->setHidden(true); #else root->createRenderWindow("", 320, 240, false, NULL)->setHidden(true); #endif new MeshLodGenerator; // Load resource paths from config file ConfigFile cf; String resourcesPath; #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_WIN32 resourcesPath = mFSLayer->getConfigFilePath("resources.cfg"); #else resourcesPath = mFSLayer->getConfigFilePath("bin/resources.cfg"); #endif cf.load(resourcesPath); // Go through all sections & settings in the file ConfigFile::SectionIterator seci = cf.getSectionIterator(); String secName, typeName, archName; while (seci.hasMoreElements()) { secName = seci.peekNextKey(); ConfigFile::SettingsMultiMap* settings = seci.getNext(); ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); } } // Create the mesh for testing mMesh = MeshManager::getSingleton().load("Sinbad.mesh", ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME); }
void TerrainTests::setUp() { // set up silent logging to not pollute output if(LogManager::getSingletonPtr()) OGRE_DELETE Ogre::LogManager::getSingletonPtr(); if(LogManager::getSingletonPtr() == 0) { LogManager* logManager = OGRE_NEW LogManager(); logManager->createLog("testTerrain.log", true, false); } LogManager::getSingleton().setLogDetail(LL_LOW); mFSLayer = OGRE_NEW_T(Ogre::FileSystemLayer, Ogre::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME); #ifdef OGRE_STATIC_LIB mRoot = OGRE_NEW Root(BLANKSTRING); mStaticPluginLoader.load(); #else String pluginsPath = mFSLayer->getConfigFilePath("plugins.cfg"); mRoot = OGRE_NEW Root(pluginsPath); #endif mTerrainOpts = OGRE_NEW TerrainGlobalOptions(); // Load resource paths from config file ConfigFile cf; String resourcesPath; #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_WIN32 resourcesPath = mFSLayer->getConfigFilePath("resources.cfg"); #else resourcesPath = mFSLayer->getConfigFilePath("bin/resources.cfg"); #endif cf.load(resourcesPath); // Go through all sections & settings in the file ConfigFile::SectionIterator seci = cf.getSectionIterator(); String secName, typeName, archName; while (seci.hasMoreElements()) { secName = seci.peekNextKey(); ConfigFile::SettingsMultiMap *settings = seci.getNext(); ConfigFile::SettingsMultiMap::iterator i; for (i = settings->begin(); i != settings->end(); ++i) { typeName = i->first; archName = i->second; ResourceGroupManager::getSingleton().addResourceLocation( archName, typeName, secName); } } mSceneMgr = mRoot->createSceneManager(ST_GENERIC); }
//----------------------------------------------------------------------- StringVectorPtr FileSystemArchive::list(bool recursive, bool dirs) { // directory change requires locking due to saved returns StringVectorPtr ret(OGRE_NEW_T(StringVector, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); findFiles("*", recursive, dirs, ret.getPointer(), 0); return ret; }
void AndroidAppHelper::initialiseFS() { mFSLayer = OGRE_NEW_T (Ogre::FileSystemLayer, Ogre::MEMCATEGORY_GENERAL) (OGRE_VERSION_NAME); AAssetManager* assetManager = CEGUI::AndroidUtils::getAndroidApp()->activity->assetManager; Ogre::APKFileSystemArchiveFactory* apk = new Ogre::APKFileSystemArchiveFactory (assetManager); Ogre::APKZipArchiveFactory* zip = new Ogre::APKZipArchiveFactory (assetManager); Ogre::ArchiveManager::getSingleton().addArchiveFactory (apk); Ogre::ArchiveManager::getSingleton().addArchiveFactory (zip); }
//----------------------------------------------------------------------- FileInfoListPtr FileSystemArchive::findFileInfo(const String& pattern, bool recursive, bool dirs) const { FileInfoListPtr ret(OGRE_NEW_T(FileInfoList, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); findFiles(pattern, recursive, dirs, 0, ret.getPointer()); return ret; }
//----------------------------------------------------------------------- FileInfoListPtr FileSystemArchive::listFileInfo(bool recursive, bool dirs) { // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category FileInfoListPtr ret(OGRE_NEW_T(FileInfoList, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); findFiles("*", recursive, dirs, 0, ret.getPointer()); return ret; }
void MenuImageItem::registerSkinDefinition() { SkinDefinition* d = OGRE_NEW_T(SkinDefinition,Ogre::MEMCATEGORY_GENERAL)("MenuImageItem"); d->defineSkinElement(DEFAULT); d->defineSkinElement(OVER); d->defineSkinElement(DOWN); d->definitionComplete(); SkinDefinitionManager::getSingleton().registerSkinDefinition("MenuImageItem",d); }
//----------------------------------------------------------------------- StringVectorPtr FileSystemArchive::list(bool recursive, bool dirs) { // directory change requires locking due to saved returns // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category StringVectorPtr ret(OGRE_NEW_T(StringVector, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); findFiles("*", recursive, dirs, ret.getPointer(), 0); return ret; }
//----------------------------------------------------------------------- FileInfoListPtr UnicodeFileSystemArchive::listFileInfo(bool _recursive, bool _dirs) { // Note that we have to tell the SharedPtr to use OGRE_DELETE_T not OGRE_DELETE by passing category FileInfoListPtr lst(OGRE_NEW_T(FileInfoList, MEMCATEGORY_GENERAL)(), SPFM_DELETE_T); FileFinder fileFinder(this, mWName, getIgnoreHidden()); fileFinder.run(L"*", _recursive, _dirs, nullptr, lst.getPointer()); return lst; }
void MenuPanel::registerSkinDefinition() { SkinDefinition* d = OGRE_NEW_T(SkinDefinition,Ogre::MEMCATEGORY_GENERAL)("MenuPanel"); d->defineSkinElement(BACKGROUND); d->defineSkinReference(HSCROLLBAR,"HScrollBar"); d->defineSkinReference(VSCROLLBAR,"VScrollBar"); d->definitionComplete(); SkinDefinitionManager::getSingleton().registerSkinDefinition("MenuPanel",d); }