const VectorString& OgreDataManager::getDataListNames(const std::string& _pattern, bool _fullpath)
{
static VectorString result;
result.clear();
Ogre::FileInfoListPtr pFileInfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(mGroup, _pattern);
result.reserve(pFileInfo->size());
for (Ogre::FileInfoList::iterator fi = pFileInfo->begin(); fi != pFileInfo->end(); ++fi )
{
if (fi->path.empty())
{
bool found = false;
for (VectorString::iterator iter = result.begin(); iter != result.end(); ++iter)
{
if (*iter == fi->filename)
{
found = true;
break;
}
}
if (!found)
{
result.push_back(_fullpath ? fi->archive->getName() + "/" + fi->filename : fi->filename);
}
}
}
pFileInfo.setNull();
return result;
}
void CMapPack::init() {
if (m_bInitialised) {return;}
Ogre::LogManager::getSingleton().logMessage("Creating map pack for " + m_sMapName);
Ogre::ResourceGroupManager::getSingleton().createResourceGroup(m_sMapName);
Ogre::FileInfoListPtr files = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo("level_user", m_sMapName + ".zip");
if (files->size() == 0) {
throw Ogre::Exception(0, "Map zip file not found", __FILE__);
}
Ogre::String sZipFile = files->front().archive->getName() + "/" + files->front().filename;
Ogre::LogManager::getSingleton().logMessage(" adding zip from " + sZipFile);
#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(sZipFile, "APKZip", m_sMapName, true);
#else
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(sZipFile, "Zip", m_sMapName, true);
#endif
Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup(m_sMapName);
m_bInitialised = true;
try {
loadLanguage();
}
catch (const Ogre::Exception& e) {
Ogre::LogManager::getSingleton().logMessage(Ogre::LML_CRITICAL, e.getFullDescription());
}
if (!m_pMapInfo) {
m_pMapInfo = shared_ptr<CMapInfo>(new CMapInfo(m_sMapName, m_sMapName));
}
}
const VectorString& Ogre2DataManager::getDataListNames(const std::string& _pattern, bool _fullpath)
{
static VectorString result;
result.clear();
VectorString search;
if (mAllGroups)
{
Ogre::StringVector sp = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
search.reserve(sp.size());
for (size_t i = 0; i < sp.size(); i++)
search.push_back(sp[i]);
}
else
search.push_back(mGroup);
std::vector<Ogre::FileInfoListPtr> pFileInfos;
int resultSize = 0;
for (size_t i = 0; i < search.size(); i++)
{
Ogre::FileInfoListPtr pFileInfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(search[i], _pattern);
resultSize += pFileInfo->size();
if (!pFileInfo->empty())
pFileInfos.push_back(pFileInfo);
else
pFileInfo.setNull();
}
result.reserve(resultSize);
for (size_t i = 0; i < pFileInfos.size(); i++)
{
Ogre::FileInfoListPtr pFileInfo = pFileInfos[i];
for (Ogre::FileInfoList::iterator fi = pFileInfo->begin(); fi != pFileInfo->end(); ++fi )
{
if (fi->path.empty())
{
bool found = false;
for (VectorString::iterator iter = result.begin(); iter != result.end(); ++iter)
{
if (*iter == fi->filename)
{
found = true;
break;
}
}
if (!found)
{
result.push_back(_fullpath ? fi->archive->getName() + "/" + fi->filename : fi->filename);
}
}
}
pFileInfo.setNull();
}
return result;
}
String ResourceManager::GetAssetPath(const String& FileName, const String& Group)
{
Ogre::FileInfoListPtr FileList = this->OgreResource->listResourceFileInfo(Group);
for( Whole X = 0 ; X < FileList->size() ; ++X )
{
if( FileName == FileList->at(X).filename )
{
return FileList->at(X).path;
}
}
return "";
}
OgreNetworkReply::OgreNetworkReply(const QNetworkRequest &request)
{
setOperation(QNetworkAccessManager::GetOperation);
setRequest(request);
setUrl(request.url());
QString path = request.url().toString(QUrl::RemoveScheme);
// Remote slashes at the beginning
while (path.startsWith('/'))
path = path.mid(1);
qDebug() << "Opening" << path << "from ogre resource.";
Ogre::ResourceGroupManager &resourceManager = Ogre::ResourceGroupManager::getSingleton();
qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
/* Is it a directory? */
Ogre::FileInfoListPtr fileInfo = resourceManager.findResourceFileInfo("General", path.toStdString(), true);
if (fileInfo->size() > 0) {
QString msg = QString("Cannot open %1: Path is a directory").arg(path);
setError(ContentOperationNotPermittedError, msg);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentOperationNotPermittedError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
return;
}
try {
mDataStream = resourceManager.openResource(path.toStdString());
} catch (Ogre::FileNotFoundException &e) {
qWarning("Couldn't find %s: %s", qPrintable(path), e.getFullDescription().c_str());
setError(ContentNotFoundError, "Couldn't find " + path);
QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ContentNotFoundError));
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
return;
}
open(QIODevice::ReadOnly);
setHeader(QNetworkRequest::ContentLengthHeader, mDataStream->size());
QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
Q_ARG(qint64, mDataStream->size()), Q_ARG(qint64, mDataStream->size()));
QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
}
const Ogre::StringVector& ManipulatorTerrain::GetAllLayerTexThumbnailNames()
{
m_vecLayerTex.clear();
Ogre::FileInfoListPtr fileinfo = Ogre::ResourceGroupManager::getSingleton().findResourceFileInfo(
"TerrainTextures", "*.png");
int i = 0;
m_vecLayerTex.resize(fileinfo->size());
for (auto iter=fileinfo->begin(); iter!=fileinfo->end(); ++iter)
{
const Ogre::FileInfo& info = (*iter);
m_vecLayerTex[i++] = info.archive->getName() + "/" + info.filename;
}
return m_vecLayerTex;
}
//-----------------------------------------------------------------------
DataStreamPtr ZipArchive::open(const String& filename, bool readOnly)
{
// zziplib is not threadsafe
OGRE_LOCK_AUTO_MUTEX;
String lookUpFileName = filename;
// Format not used here (always binary)
ZZIP_FILE* zzipFile =
zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS);
if (!zzipFile) // Try if we find the file
{
const Ogre::FileInfoListPtr fileNfo = findFileInfo(lookUpFileName, true);
if (fileNfo->size() == 1) // If there are more files with the same do not open anyone
{
Ogre::FileInfo info = fileNfo->at(0);
lookUpFileName = info.path + info.basename;
zzipFile = zzip_file_open(mZzipDir, lookUpFileName.c_str(), ZZIP_ONLYZIP | ZZIP_CASELESS); // When an error happens here we will catch it below
}
}
if (!zzipFile)
{
int zerr = zzip_error(mZzipDir);
String zzDesc = getZzipErrorDescription((zzip_error_t)zerr);
LogManager::getSingleton().logMessage(
mName + " - Unable to open file " + lookUpFileName + ", error was '" + zzDesc + "'", LML_CRITICAL);
// return null pointer
return DataStreamPtr();
}
// Get uncompressed size too
ZZIP_STAT zstat;
zzip_dir_stat(mZzipDir, lookUpFileName.c_str(), &zstat, ZZIP_CASEINSENSITIVE);
// Construct & return stream
return DataStreamPtr(OGRE_NEW ZipDataStream(lookUpFileName, zzipFile, static_cast<size_t>(zstat.st_size)));
}
gkBlendListIterator::gkBlendListIterator(List* list)
: m_list(list),
#if OGREKIT_USE_BPARSE
m_index(0)
#else
m_index(list ? list->first : 0)
#endif
{
}
bool gkBlendListIterator::hasMoreElements() const
{
if (m_list == 0) return false;
#if OGREKIT_USE_BPARSE
return m_index < m_list->size();
#else
return m_index != 0;
#endif
}
gkBlendListIterator::ListItem* gkBlendListIterator::getNext(void)
{
#if OGREKIT_USE_BPARSE
return m_list->at(m_index++);
#else
ListItem* item = m_index;
m_index = m_index->next;
return item;
#endif
}
//--
gkBlendInternalFile::gkBlendInternalFile()
: m_file(0)
{
}
gkBlendInternalFile::~gkBlendInternalFile()
{
delete m_file;
m_file = 0;
}
bool gkBlendInternalFile::parse(const gkString& fname)
{
if (fname.empty())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. File name is empty.");
return false;
}
#if OGREKIT_USE_BPARSE
utMemoryStream fs;
fs.open(fname.c_str(), utStream::SM_READ);
if (!fs.isOpen())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. No such file.");
return false;
}
// Write contents and inflate.
utMemoryStream buffer(utStream::SM_WRITE);
fs.inflate(buffer);
m_file = new bParse::bBlenderFile((char*)buffer.ptr(), buffer.size());
m_file->parse(false);
if (!m_file->ok())
{
gkLogMessage("BlendFile: File " << fname << " loading failed. Data error.");
return false;
}
#else
m_file = new fbtBlend();
int status = m_file->parse(fname.c_str(), fbtFile::PM_COMPRESSED);
if (status != fbtFile::FS_OK)
{
delete m_file;
m_file = 0;
gkLogMessage("BlendFile: File " << fname << " loading failed. code: " << status);
//return false;
}
else
{
gkLogMessage("BlendFile: File " << fname << " loading end1" );
return true;
}
//gkLogMessage("BlendFile: File " << fname << " loading end" );
m_file = new fbtBlend();
Ogre::DataStreamPtr stream;
Ogre::ArchiveManager::ArchiveMapIterator beginItera = Ogre::ArchiveManager::getSingleton().getArchiveIterator();
while(beginItera.hasMoreElements())
{
typedef std::map<Ogre::String, Ogre::Archive*>::iterator ArchiveIterator;
ArchiveIterator arch = beginItera.current();
if (arch->second)
{
Ogre::FileInfoListPtr fileInfo = arch->second->findFileInfo(fname);
if (fileInfo->size() > 0)
{
stream = arch->second->open(fname);
gkLogMessage("BlendFile: File found create stream");
break;
}
}
beginItera.moveNext();
}
//gkLogMessage("malloc buffer");
unsigned char * buffer = new unsigned char[stream->size()];
//gkLogMessage(" stream->read ");
long sizeCount = stream->read(buffer,stream->size());
//gkLogMessage(" m_file->parse");
if(m_file) m_file->parse(buffer,sizeCount);
delete buffer;
//gkLogMessage(" m_file->parse end");
#endif
return true;
}
Blender::FileGlobal* gkBlendInternalFile::getFileGlobal()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return (Blender::FileGlobal*)m_file->getFileGlobal();
#else
return m_file->m_fg;
#endif
}
int gkBlendInternalFile::getVersion()
{
GK_ASSERT(m_file);
#if OGREKIT_USE_BPARSE
return m_file->getMain()->getVersion();
#else
return m_file->getVersion();
#endif
}
//-------------------------------------------------------------------------------------
void SceneLoader::load(std::string filename, Scene* scene)
{
try
{
Ogre::FileInfoListPtr files = Ogre::ResourceGroupManager::getSingletonPtr()->findResourceFileInfo("Essential", filename);
if(files->size() < 1) throw NHException("could not find the path to the specified scene");
std::string filePath = files->front().archive->getName() + "/" + files->front().filename;
std::ifstream streamfile(filePath);
rapidxml::xml_document<> doc;
std::vector<char> buffer((std::istreambuf_iterator<char>(streamfile)), std::istreambuf_iterator<char>());//streamfile)), std::istreambuf_iterator<char>());
buffer.push_back('\0');//null terminating the buffer
//std::cout << &buffer[0] << std::endl; //test the buffer
doc.parse<0>(&buffer[0]);
rapidxml::xml_node<>* root = doc.first_node(SCENE_STRING);//"scene");
scene->getSceneGraphicsManager()->setAmbientLight(getXMLColour(root, AMBIENT_RED_STRING, AMBIENT_GREEN_STRING, AMBIENT_BLUE_STRING));
//description attributes
//north = boost::lexical_cast<float>(root->first_attribute(NORTH_STRING)->value());
//Architecture
rapidxml::xml_node<>* architectureNode = root->first_node(ARCHITECTURE_STRING);//"architecture");
while(architectureNode != NULL)
{
int id = boost::lexical_cast<int>(architectureNode->first_attribute(ID_STRING)->value());
try
{
scene->addArchitecture(id, getXMLPosition(architectureNode), getXMLRotation(architectureNode), getXMLScale(architectureNode));
}
catch(NHException e)
{
#ifdef _DEBUG
std::cout << e.what() << std::endl;
#endif
}
architectureNode = architectureNode->next_sibling(ARCHITECTURE_STRING);
}
scene->build();//building static geometry - must do here else we can't use the navigation mesh for creature placement
//Lights
rapidxml::xml_node<>* lightNode = root->first_node(LIGHT_STRING);//"light");
while(lightNode != NULL)
{
bool cast_shadows = boost::lexical_cast<bool>(lightNode->first_attribute(CAST_SHADOWS_STRING)->value());
float range = boost::lexical_cast<float>(lightNode->first_attribute(RANGE_STRING)->value());
Ogre::ColourValue colour = getXMLColour(lightNode);
scene->addLight(-1, getXMLPosition(lightNode),cast_shadows,range);//TODO: use actual id rather than -1
lightNode = lightNode->next_sibling(LIGHT_STRING);
}
//Items
rapidxml::xml_node<>* itemNode = root->first_node(ITEM_STRING);
while(itemNode != NULL)
{
int id = boost::lexical_cast<int>(itemNode->first_attribute(ID_STRING)->value());
scene->addItem(id, getXMLPosition(itemNode), getXMLRotation(itemNode));
itemNode = itemNode->next_sibling(ITEM_STRING);
}
//Creatures
rapidxml::xml_node<>* creatureNode = root->first_node(CREATURE_STRING);
while(creatureNode != NULL)
{
int id = boost::lexical_cast<int>(creatureNode->first_attribute(ID_STRING)->value());
scene->addCreature(id, getXMLPosition(creatureNode));
creatureNode = creatureNode->next_sibling(CREATURE_STRING);
}
//Portals
rapidxml::xml_node<>* portalNode = root->first_node(PORTAL_STRING);
while(portalNode != NULL)
{
int id = boost::lexical_cast<int>(portalNode->first_attribute(ID_STRING)->value());
int targetSceneID = boost::lexical_cast<int>(portalNode->first_attribute(TARGET_SCENE_ID_STRING)->value());
int targetPortalID = boost::lexical_cast<int>(portalNode->first_attribute(TARGET_PORTAL_ID_STRING)->value());
scene->addPortal(id, getXMLPosition(portalNode), getXMLVector(portalNode, LOOK_AT_X_STRING, LOOK_AT_Y_STRING, LOOK_AT_Z_STRING), Id<Scene>(targetSceneID), Id<Portal>(targetPortalID), Id<Portal>(id));
portalNode = portalNode->next_sibling(PORTAL_STRING);//"portal");
}
//Particles //TODO: change to emitter
/*
rapidxml::xml_node<>* particleNode = root->first_node(PARTICLE_STRING);//"particle");
while(particleNode != NULL)
{
scene->addParticles(particleNode->first_attribute(NAME_STRING)->value(), particleNode->first_attribute(TEMPLATE_NAME_STRING)->value(),getXMLPosition(particleNode));
particleNode = particleNode->next_sibling(PARTICLE_STRING);
}
*/
}
catch (rapidxml::parse_error e)
{
std::stringstream ss;
ss << "could not load the xml scene '" << filename << "': " << e.what() << std::endl;
throw NHException(ss.str().c_str());
}
}