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);
}
