//----------------------------------------------------------------------------------
bool GameObject::removeFlag(Ogre::String flag)
{
std::string::size_type pos1 = mFlags.find("|" + flag + "|");
if (pos1 == Ogre::String::npos)
{
return false;
}
++pos1;
std::string::size_type pos2 = flag.length() + 1;
mFlags.erase(pos1, pos2);
return true;
}
void SoundEditDialog::SaveSoundInfoFromFile(const Ogre::String& filename)
{
if (mSoundInfoFileChanged)
{
char buf[1024];
FILE* pFile = NULL;
pFile = ::fopen(filename.c_str(), "w");
if(NULL == pFile)
{
wxMessageBox("Can't open the file, Maybe the file is missing or it is read only!");
return;
}
memset(buf, 0, sizeof(buf));
sprintf(buf, "INT\tINT\tINT\tINT\tINT\tINT\tINT\tINT\n");
::fwrite(buf, strlen(buf), 1, pFile);
memset(buf, 0, sizeof(buf));
sprintf(buf, "ID\t声音ID\t声源位置X\t声源位置Z\t有效距离\t连播次数\t间隔时间(ms)\t下一次连播间隔时间(ms)\n");
::fwrite(buf, strlen(buf), 1, pFile);
memset(buf, 0, sizeof(buf));
for(size_t i=0; i<mSoundItems.size(); ++i)
{
SoundItem* soundItem = mSoundItems[i];
if (soundItem->mRepeatTime == 0)
{
sprintf(buf, "%d\t%d\t%d\t%d\t%d\n",
i, soundItem->mSoundID, soundItem->mXPos, soundItem->mZPos, soundItem->mRadius);
}
else
{
sprintf(buf, "%d\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",
i, soundItem->mSoundID, soundItem->mXPos, soundItem->mZPos, soundItem->mRadius,
soundItem->mRepeatTime, soundItem->mRepeatIntervalTime, soundItem->mNextRepeatTime);
}
::fwrite(buf, strlen(buf), 1, pFile);
}
::fclose(pFile);
mSoundInfoFileChanged = false;
}
}
Ogre::ResourcePtr
loadCorrelativeResource(const Ogre::String& resourceName, const Ogre::String& groupName,
const Ogre::String& baseResourceName, const Ogre::String& baseGroupName,
Ogre::ResourceManager& resourceManager)
{
Ogre::ResourcePtr res;
Ogre::String name, path;
Ogre::StringUtil::splitFilename(resourceName, name, path);
bool existsPath = !path.empty();
// First, load in correlatived group and path if resource name doesn't exists path
if (!existsPath)
{
Ogre::StringUtil::splitFilename(baseResourceName, name, path);
if (!path.empty())
{
name = path + resourceName;
res = tryLoadResource(resourceManager, name, baseGroupName);
if (!res.isNull())
return res;
}
}
// Second, load in correlatived group
res = tryLoadResource(resourceManager, resourceName, baseGroupName);
if (!res.isNull())
return res;
// Three, load in user given group
if (!groupName.empty())
{
res = tryLoadResource(resourceManager, resourceName, groupName);
if (!res.isNull())
return res;
}
// Four, load in global default group
if (groupName != DEFAULT_RESOURCE_GROUP_NAME)
{
res = tryLoadResource(resourceManager, resourceName, groupName);
if (!res.isNull())
return res;
}
return res;
}
//-----------------------------------------------------------------------------
int COFSSceneSerializer::_writeFile(Ogre::String exportfile, const bool forceSave)
{
if (exportfile.empty())
return SCF_ERRUNKNOWN;
OgitorsRoot *ogRoot = OgitorsRoot::getSingletonPtr();
// Open a stream to output our XML Content and write the general headercopyFile
std::stringstream outfile;
outfile << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
outfile << "<OGITORSCENE version=\"" << Globals::OGSCENE_FORMAT_VERSION << "\">\n";
PROJECTOPTIONS *pOpt = ogRoot->GetProjectOptions();
pOpt->CameraSpeed = ogRoot->GetViewport()->GetCameraSpeed();
ogRoot->WriteProjectOptions(outfile, pOpt);
ObjectVector ObjectList;
OgitorsPropertyValueMap theList;
OgitorsPropertyValueMap::iterator ni;
// Start from 1, since 0 means all objects
for(unsigned int i = 1; i < LAST_EDITOR; i++)
{
ogRoot->GetObjectList(i, ObjectList);
for(unsigned int ob = 0; ob < ObjectList.size(); ob++)
{
/// If Object does not have a parent, then it is not part of the scene
if(ObjectList[ob]->getParent())
{
ObjectList[ob]->onSave(forceSave);
if(ObjectList[ob]->isSerializable())
{
outfile << OgitorsUtils::GetObjectSaveStringV2(ObjectList[ob], 2, true, true).c_str();
outfile << "\n";
}
}
}
}
outfile << "</OGITORSCENE>\n";
if (OgitorsUtils::SaveStreamOfs(outfile, exportfile)) {
return SCF_OK;
}
return SCF_ERRFILE;
}
//-----------------------------------------------------------------------------------------
void OgitorsRoot::GetObjectListByCustomProperty(unsigned int type, const Ogre::String& nameregexp, bool inverse, ObjectVector& list)
{
list.clear();
try
{
const boost::regex e(nameregexp.c_str());
NameObjectPairList::iterator list_st, list_ed;
if(type == 0)
{
list_st = mNameList.begin();
list_ed = mNameList.end();
}
else
{
list_st = mNamesByType[type].begin();
list_ed = mNamesByType[type].end();
}
OgitorsPropertyVector pvec;
while(list_st != list_ed)
{
pvec = list_st->second->getCustomProperties()->getPropertyVector();
bool add_list = false;
for(unsigned int k = 0;k < pvec.size();k++)
{
if(regex_match(pvec[k]->getName().c_str(), e))
{
add_list = true;
break;
}
}
if(add_list != inverse)
list.push_back(list_st->second);
list_st++;
}
}
catch(...)
{
list.clear();
}
}
void Cube::save(Ogre::String file)
{
if (rndCounter == 0)
{
std::ofstream output(file.c_str());
// Write cube size
output << size << std::endl;
for (int i = 0; i < size; ++i)
for (int j = 0; j < size; ++j)
for (int k = 0; k < size; ++k)
{
CubeElement *e = data[i][j][k];
Ogre::Entity *ent = static_cast<Ogre::Entity*>(e->node->getAttachedObject(0));
Ogre::SceneNode *node = e->node;
// Write name, indexes and position
output << node->getName() << "\n"
<< "\t" << i << " " << j << " " << k << "\n" // index in data array
<< "\t" << node->getPosition().x << " " << node->getPosition().y << " " << node->getPosition().z << "\n"; // position
// Write orientation
Ogre::Vector3 orient_axis;
Ogre::Degree orient_angle;
node->getOrientation().ToAngleAxis(orient_angle, orient_axis);
output << "\t" << orient_axis.x << " " << orient_axis.y << " " << orient_axis.z << " " // orientation axis
<< orient_angle.valueDegrees() << "\n"; // orientation angle
output << "\t" << ent->getSubEntity(0)->getMaterialName() << "\n"
<< "\t" << ent->getSubEntity(1)->getMaterialName() << "\n"
<< "\t" << ent->getSubEntity(2)->getMaterialName() << "\n"
<< "\t" << ent->getSubEntity(3)->getMaterialName() << "\n"
<< "\t" << ent->getSubEntity(4)->getMaterialName() << "\n"
<< "\t" << ent->getSubEntity(5)->getMaterialName() << "\n";
// Write pivot info
output << "\t" << e->isPivot << "\n";
if (e->isPivot)
{
// pivot indexes
output << "\t" << e->pivotArrays[0] << " " << e->pivotArrayIndexes[0] << "\n"
<< "\t" << e->pivotArrays[1] << " " << e->pivotArrayIndexes[1] << "\n";
}
// flush
output << std::endl;
}
output.close();
}
}
bool NetworkManager::doConnect( Ogre::String serverIP, Ogre::ushort serverPort )
{
mConnectAtemp = true;
switch(mRakPeer->Connect(serverIP.c_str(), serverPort, 0, 0, 0))
{
case RakNet::CONNECTION_ATTEMPT_STARTED:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "CONNECTION_ATTEMPT_STARTED");
return true;
break;
}
case RakNet::INVALID_PARAMETER:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "INVALID_PARAMETER");
break;
}
case RakNet::CANNOT_RESOLVE_DOMAIN_NAME:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "CANNOT_RESOLVE_DOMAIN_NAME");
break;
}
case RakNet::ALREADY_CONNECTED_TO_ENDPOINT:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "ALREADY_CONNECTED_TO_ENDPOINT");
break;
}
case RakNet::CONNECTION_ATTEMPT_ALREADY_IN_PROGRESS:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "CONNECTION_ATTEMPT_ALREADY_IN_PROGRESS");
break;
}
case RakNet::SECURITY_INITIALIZATION_FAILED:
{
Ogre::LogManager::getSingletonPtr()
->logMessage(RealToys::logMessagePrefix + "SECURITY_INITIALIZATION_FAILED");
break;
}
}
return false;
}
bool fnmatch (Ogre::String pattern, Ogre::String name, int dummy)
{
if (pattern == "*")
{
return true;
}
if (pattern.substr(0,2) == "*.")
{
Ogre::StringUtil::toLowerCase(pattern);
Ogre::StringUtil::toLowerCase(name);
Ogre::String extToFind = pattern.substr(2, pattern.size() - 2);
if ((name.size() > extToFind.size()) &&(extToFind == name.substr(name.size() - extToFind.size(), extToFind.size())))
{
return 0; // match
}
else
{
return 1; // don't match
}
}
return false;
}
MovableTextOverlayAttributes::MovableTextOverlayAttributes(const Ogre::String & name, const Ogre::Camera *cam,
const Ogre::String & fontName, int charHeight, const Ogre::ColourValue & color, const Ogre::String & materialName)
: mpCam(cam)
, mpFont(NULL)
, mName(name)
, mFontName("")
, mMaterialName("")
, mCharHeight(charHeight)
, mColor(ColourValue::ZERO)
{
if (fontName.length() == 0)
Ogre::Exception(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid font name", "MovableTextOverlayAttributes::MovableTextOverlayAttributes");
setFontName(fontName);
setMaterialName(materialName);
setColor(color);
}
//-----------------------------------------------------------------------
void XercesWriter::writeXMLFile(const XMLNode* root, const Ogre::String& filename)
{
XERCES_CPP_NAMESPACE_USE;
DOMImplementation* impl = DOMImplementationRegistry::getDOMImplementation(L"Core");
DOMDocumentType* docType = NULL;
DOMDocument* doc = impl->createDocument(NULL, transcode(root->getName()).c_str(), docType);
populateDOMElement(root, doc->getDocumentElement());
LocalFileFormatTarget destination(filename.c_str());
DOMWriter* writer = impl->createDOMWriter();
writer->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
writer->writeNode(&destination, *doc);
writer->release();
doc->release();
}
bool OgreDetourTileCache::saveAll(Ogre::String filename)
{
if (!m_tileCache) {
Ogre::LogManager::getSingletonPtr()->logMessage("Error: OgreDetourTileCache::saveAll("+filename+"). Could not save tilecache, no tilecache to save.");
return false;
}
FILE* fp = fopen(filename.data(), "wb");
if (!fp) {
Ogre::LogManager::getSingletonPtr()->logMessage("Error: OgreDetourTileCache::saveAll("+filename+"). Could not save file.");
return false;
}
// Store header.
TileCacheSetHeader header;
header.magic = TILECACHESET_MAGIC;
header.version = TILECACHESET_VERSION;
header.numTiles = 0;
for (int i = 0; i < m_tileCache->getTileCount(); ++i)
{
const dtCompressedTile* tile = m_tileCache->getTile(i);
if (!tile || !tile->header || !tile->dataSize) continue;
header.numTiles++;
}
memcpy(&header.cacheParams, m_tileCache->getParams(), sizeof(dtTileCacheParams));
memcpy(&header.meshParams, m_recast->m_navMesh->getParams(), sizeof(dtNavMeshParams));
memcpy(&header.recastConfig, &m_cfg, sizeof(rcConfig));
fwrite(&header, sizeof(TileCacheSetHeader), 1, fp);
// Store tiles.
for (int i = 0; i < m_tileCache->getTileCount(); ++i)
{
const dtCompressedTile* tile = m_tileCache->getTile(i);
if (!tile || !tile->header || !tile->dataSize) continue;
TileCacheTileHeader tileHeader;
tileHeader.tileRef = m_tileCache->getTileRef(tile);
tileHeader.dataSize = tile->dataSize;
fwrite(&tileHeader, sizeof(tileHeader), 1, fp);
fwrite(tile->data, tile->dataSize, 1, fp);
}
fclose(fp);
return true;
}
bool LuaScriptUtilities::HasAttribute(
lua_State* const luaVM,
const int tableIndex,
const Ogre::String& attributeName)
{
if (!lua_istable(luaVM, tableIndex))
return false;
lua_pushstring(luaVM, attributeName.c_str());
lua_gettable(luaVM, tableIndex);
const bool result = lua_isnil(luaVM, -1);
lua_pop(luaVM, 1);
return !result;
}
void CollisionSerializer::exportCollision(const CollisionPtr& collision, const Ogre::String& filename)
{
if( !collision )
OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Argument collision is NULL","CollisionSerializer::exportCollision");
mpfFile=fopen(filename.c_str(),"wb");
if (!mpfFile)
{
OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Unable to open file " + filename + " for writing","CollisionSerializer::exportCollision");
}
NewtonCollisionSerialize(collision->getWorld()->getNewtonWorld(), collision->m_col, &CollisionSerializer::_newtonSerializeCallback, this);
fclose(mpfFile);
}
Ogre::Real LuaScriptUtilities::GetRealAttribute(
lua_State* const luaVM,
const Ogre::String attributeName,
const int tableIndex)
{
if (!lua_istable(luaVM, tableIndex))
return Ogre::Real();
lua_pushstring(luaVM, attributeName.c_str());
lua_gettable(luaVM, tableIndex);
Ogre::Real value = lua_tonumber(luaVM, -1);
lua_pop(luaVM, 1);
return value;
}
void
AudioManager::Player::Play( const Ogre::String &file )
{
boost::recursive_mutex::scoped_lock lock( *m_UpdateMutex );
// open vorbis file
if( ov_fopen( const_cast< char* >( file.c_str() ), &m_VorbisFile ) )
{
LOG_ERROR( "Can't play file \"" + file + "\"." );
return;
}
// get file info
m_VorbisInfo = ov_info( &m_VorbisFile, -1.0f );
// create sound source
alGenSources( 1, &m_Source );
// create buffers
ALuint buffers[ m_ChannelBufferNumber ];
alGenBuffers( m_ChannelBufferNumber, buffers );
// set source parameters
alSourcei( m_Source, AL_LOOPING, AL_FALSE );
// fill buffers
for( int i = 0; i < m_ChannelBufferNumber; ++i )
{
ALsizei buffer_size = FillBuffer();
if( buffer_size )
{
alBufferData( buffers[ i ], m_VorbisInfo->channels == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, ( const ALvoid* )AudioManager::getSingleton().m_Buffer, ( ALsizei )buffer_size, ( ALsizei )m_VorbisInfo->rate );
alSourceQueueBuffers( m_Source, 1, &buffers[ i ] );
}
else
{
m_StreamFinished = true;
alDeleteBuffers( 1, &buffers[ i ] );
}
}
// start playback
alSourcePlay( m_Source );
}
//-----------------------------------------------------------------------
void AtlasImageTool::initialise (const Ogre::String& configFileName)
{
if (!configFileName.empty())
{
mConfigFile.load(configFileName);
}
else
{
mConfigFile.load("atlas.cfg");
}
mInputFileNames = Ogre::StringUtil::split(mConfigFile.getSetting("InputImage"), ";, ");
mInputFrames = Ogre::StringUtil::split(mConfigFile.getSetting("Frame"), ";, ");
mAlpha = Ogre::StringUtil::split(mConfigFile.getSetting("Alpha"), ";, ");
mOutputImage = mConfigFile.getSetting("OutputImage");
mImagePath = mConfigFile.getSetting("ImagePath");
mAtlasImage.setAlwaysUpdate(false); // Manual compilation to speed things up.
}
MainSkin::MainSkin(const SubWidgetInfo& _info, const Ogre::String& _material, CroppedRectanglePtr _parent, size_t _id) :
CroppedRectangleInterface(_info.coord, _info.align, _parent)
{
Ogre::OverlayManager& overlayManager = Ogre::OverlayManager::getSingleton();
mOverlayContainer = static_cast<SharedPanelAlphaOverlayElement*>( overlayManager.createOverlayElement(
"SharedPanelAlpha", utility::toString("MainSkin_", this)) );
// устанавливаем колличество саб оверлеев
mOverlayContainer->setCountSharedOverlay(1);
//mOverlayContainer->setMetricsMode(Ogre::GMM_PIXELS);
mOverlayContainer->setPositionInfo(mParent->getLeft() + mCoord.left, mParent->getTop() + mCoord.top, mCoord.width, mCoord.height, 0);
if (false == _material.empty() && (_info.coord.width != 0)) mOverlayContainer->setMaterialName(_material);
mParent->_attachChild(this, false);
}
bool TracksXml::LoadXml(Ogre::String file)
{
TiXmlDocument doc;
if (!doc.LoadFile(file.c_str())) return false;
TiXmlElement* root = doc.RootElement();
if (!root) return false;
// clear
//Default();
trks.clear(); trkmap.clear();
/// tracks
const char* a; int i=1; //0 = none
TiXmlElement* eTrk = root->FirstChildElement("track");
while (eTrk)
{
TrackInfo t;
a = eTrk->Attribute("n"); if (a) t.n = s2i(a);
a = eTrk->Attribute("name"); if (a) t.name = std::string(a);
a = eTrk->Attribute("created"); if (a) t.created = s2dt(a);
a = eTrk->Attribute("crtver"); if (a) t.crtver = s2r(a);
a = eTrk->Attribute("modified"); if (a) t.modified = s2dt(a);
a = eTrk->Attribute("scenery"); if (a) t.scenery = std::string(a);
a = eTrk->Attribute("author"); if (a) t.author = std::string(a);
a = eTrk->Attribute("fluids"); if (a) t.fluids = s2i(a);
a = eTrk->Attribute("bumps"); if (a) t.bumps = s2i(a); a = eTrk->Attribute("jumps"); if (a) t.jumps = s2i(a);
a = eTrk->Attribute("loops"); if (a) t.loops = s2i(a); a = eTrk->Attribute("pipes"); if (a) t.pipes = s2i(a);
a = eTrk->Attribute("banked"); if (a) t.banked = s2i(a); a = eTrk->Attribute("frenzy"); if (a) t.frenzy = s2i(a);
a = eTrk->Attribute("long"); if (a) t.longn = s2i(a);
a = eTrk->Attribute("diff"); if (a) t.diff = s2i(a);
a = eTrk->Attribute("rating"); if (a) t.rating = s2i(a);
a = eTrk->Attribute("rateuser"); if (a) t.rateuser = s2i(a);
a = eTrk->Attribute("drivenlaps"); if (a) t.drivenlaps = s2i(a);
trks.push_back(t);
//trkmap[t.name] = &trks.back();
trkmap[t.name] = i++;
eTrk = eTrk->NextSiblingElement("track");
}
return true;
}
NativeWindowPair ApplicationContextSDL::createWindow(const Ogre::String& name, Ogre::uint32 w, Ogre::uint32 h, Ogre::NameValuePairList miscParams)
{
NativeWindowPair ret = {NULL, NULL};
parseWindowOptions(w, h, miscParams);
Ogre::ConfigOptionMap& ropts = mRoot->getRenderSystem()->getConfigOptions();
if(!SDL_WasInit(SDL_INIT_VIDEO)) {
SDL_InitSubSystem(SDL_INIT_VIDEO);
}
Uint32 flags = SDL_WINDOW_RESIZABLE;
if(ropts["Full Screen"].currentValue == "Yes"){
flags = SDL_WINDOW_FULLSCREEN;
} else {
flags = SDL_WINDOW_RESIZABLE;
}
ret.native = SDL_CreateWindow(name.c_str(),
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, w, h, flags);
#if OGRE_PLATFORM == OGRE_PLATFORM_EMSCRIPTEN
SDL_GL_CreateContext(ret.native);
miscParams["currentGLContext"] = "true";
#else
SDL_SysWMinfo wmInfo;
SDL_VERSION(&wmInfo.version);
SDL_GetWindowWMInfo(ret.native, &wmInfo);
#endif
#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX
miscParams["parentWindowHandle"] = Ogre::StringConverter::toString(size_t(wmInfo.info.x11.window));
#elif OGRE_PLATFORM == OGRE_PLATFORM_WIN32
miscParams["externalWindowHandle"] = Ogre::StringConverter::toString(size_t(wmInfo.info.win.window));
#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
assert(wmInfo.subsystem == SDL_SYSWM_COCOA);
miscParams["externalWindowHandle"] = Ogre::StringConverter::toString(size_t(wmInfo.info.cocoa.window));
#endif
ret.render = mRoot->createRenderWindow(name, w, h, false, &miscParams);
mWindows.push_back(ret);
return ret;
}
void BoneCollisionManager::CreateBoneData(Ogre::Bone *q, Ogre::String Type, Ogre::Vector3 D, Ogre::String MeshName)
{
Ogre::String Line;
if (mFile == NULL)
{
mFile = fopen((MeshName.c_str()), "w");
}
//Write Top Compoment
Line = "[" + q->getName() + "]" + "\n";
fwrite(Line.c_str(), 1, strlen(Line.c_str()), mFile);
//Write Bone Name
Line = "boneName=" + q->getName() + "\n";
//fputs(Line.c_str(),mFile);
fwrite(Line.c_str(), 1, strlen(Line.c_str()), mFile);
//Write Type
Line = "actorShape="+Type+"\n";
//fputs(Line.c_str(),mFile);
fwrite(Line.c_str(), 1, strlen(Line.c_str()), mFile);
//Write Dimensions
std::stringstream s;
std::stringstream ss;
std::stringstream sss;
s << D.x;
ss << D.y;
sss << D.z;
Line = "dimensions=";
Line += s.str()+" "+ss.str()+" "+sss.str()+"\n"+"\n";
fputs(Line.c_str(),mFile);
fflush(mFile);
}
CChest::CChest(Ogre::SceneNode *pNode, CObjectManager &objectManager, btCollisionObject *pCollisionObject, EChestType eChestType, const Ogre::String &id)
: CObject(objectManager, CHEST_OBJECT, pCollisionObject, id), m_eChestType(eChestType) {
m_eChestState = CS_CLOSED;
//setInnerObject(&innerObject);
m_pInnerObject = NULL;
m_pLidSceneNode = objectManager.getMap().getRootSceneNode()->createChildSceneNode();
m_pLidSceneNode->setPosition(pNode->getPosition());
m_pLidSceneNode->setOrientation(pNode->getOrientation());
m_pLidSceneNode->setScale(pNode->getScale());
m_vInnerObjectPos = m_pLidSceneNode->getPosition();
btCollisionShape *pColShape(0);
switch (m_eChestType) {
case CT_SMALL:
m_pLidSceneNode->attachObject(pNode->getCreator()->createEntity("Chest.Small.Upper.mesh"));
m_pLidSceneNode->translate(0, 0.37465f, -0.30862f, Ogre::Node::TS_LOCAL);
m_vInnerObjectPos += m_pLidSceneNode->getOrientation() * Ogre::Vector3(0, 0.15f, 0);
pColShape = new btBoxShape(btVector3(0.3f, 0.08f, 0.2f));
m_vPhysicsOffset = Ogre::Vector3(0, 0.15f, 0.25f);
break;
default:
throw Ogre::Exception(0, "Unknown chest type", __FILE__);
break;
}
m_pLidPhysics = new btRigidBody(0, new btDefaultMotionState(), pColShape);
m_pLidPhysics->getWorldTransform().setOrigin(BtOgre::Convert::toBullet(m_pLidSceneNode->getPosition() + m_pLidSceneNode->getOrientation() * m_vPhysicsOffset));
m_pLidPhysics->getWorldTransform().setRotation(BtOgre::Convert::toBullet(m_pLidSceneNode->getOrientation()));
m_ObjectManager.getMap().getPhysicsManager()->getWorld()->addRigidBody(m_pLidPhysics, COL_STATIC, MASK_STATIC_COLLIDES_WITH);
// check for safe state
if (id.length() > 0) {
EItemSaveState iss = CPlayerData::getSingleton().getMapItemState(m_ObjectManager.getMap().getName(), id, ISS_CLOSED);
if (iss == ISS_OPENED) {
// open chest as initial state
m_eChestState = CS_OPENED;
m_pLidSceneNode->pitch(Ogre::Radian(-CHEST_MAX_ANGLE));
m_pLidPhysics->getWorldTransform().setOrigin(BtOgre::Convert::toBullet(m_pLidSceneNode->getPosition() + m_pLidSceneNode->getOrientation() * m_vPhysicsOffset));
m_pLidPhysics->getWorldTransform().setRotation(BtOgre::Convert::toBullet(m_pLidSceneNode->getOrientation()));
}
}
}
bool LuaScriptUtilities::IsUserdataType(
lua_State* const luaVM, const int stackIndex, const Ogre::String type)
{
void* pointer = lua_touserdata(luaVM, stackIndex);
if (pointer != NULL)
{
if (lua_getmetatable(luaVM, stackIndex))
{
lua_getfield(luaVM, LUA_REGISTRYINDEX, type.c_str());
if (lua_rawequal(luaVM, -1, -2))
{
lua_pop(luaVM, 2);
return true;
}
lua_pop(luaVM, 2);
}
}
return false;
}
Ogre::MaterialPtr AssetLoader::createMaterial(Ogre::String name, int index, aiMaterial* mat)
{
Ogre::MaterialManager* omatMgr = Ogre::MaterialManager::getSingletonPtr();
std::ostringstream matname;
matname << name.data() << "_mat";
matname.widen(4);
matname.fill('0');
matname << index;
Ogre::String matName = matname.str();
Ogre::ResourceManager::ResourceCreateOrRetrieveResult status = omatMgr->createOrRetrieve(matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
Ogre::MaterialPtr omat = status.first;
aiColor4D clr(1.0, 1.0, 1.0, 1.0);
aiGetMaterialColor(mat, AI_MATKEY_COLOR_DIFFUSE, &clr);
omat->getTechnique(0)->getPass(0)->setDiffuse(clr.r, clr.g, clr.b, clr.a);
aiGetMaterialColor(mat, AI_MATKEY_COLOR_SPECULAR, &clr);
omat->getTechnique(0)->getPass(0)->setSpecular(clr.r, clr.g, clr.b, clr.a);
aiGetMaterialColor(mat, AI_MATKEY_COLOR_AMBIENT, &clr);
omat->getTechnique(0)->getPass(0)->setAmbient(clr.r, clr.g, clr.b);
aiGetMaterialColor(mat, AI_MATKEY_COLOR_EMISSIVE, &clr);
omat->getTechnique(0)->getPass(0)->setSelfIllumination(clr.r, clr.g, clr.b);
omat->getTechnique(0)->getPass(0)->setShadingMode(Ogre::SO_GOURAUD);
omat->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
omat->getTechnique(0)->getPass(0)->setLightingEnabled(true);
omat->getTechnique(0)->getPass(0)->setDepthCheckEnabled(true);
//omat->getTechnique(0)->getPass(0)->setVertexColourTracking(Ogre::TVC_DIFFUSE);
aiString path;
aiReturn res = mat->GetTexture(aiTextureType_DIFFUSE, 0, &path);
if (res == AI_SUCCESS) {
Ogre::TextureUnitState* stateBase = omat->getTechnique(0)->getPass(0)->createTextureUnitState();
stateBase->setColourOperation(Ogre::LBO_MODULATE);
stateBase->setTextureName(path.data);
}
return omat;
}
//-----------------------------------------------------------------------------------------
TiXmlElement* CPGInstanceManager::exportDotScene(TiXmlElement *pParent)
{
Ogre::String name = mName->get();
std::replace(name.begin(), name.end(), '<', ' ');
std::replace(name.begin(), name.end(), '>', ' ');
std::replace(name.begin(), name.end(), '#', ' ');
name = Ogre::StringConverter::toString(mObjectID->get()) + "_" + name;
Ogre::String filename = "PGInstances/" + name + ".instance";
TiXmlElement *pNode = pParent->InsertEndChild(TiXmlElement("node"))->ToElement();
// node properties
pNode->SetAttribute("name", mName->get().c_str());
pNode->SetAttribute("id", Ogre::StringConverter::toString(mObjectID->get()).c_str());
// position
TiXmlElement *pPosition = pNode->InsertEndChild(TiXmlElement("position"))->ToElement();
pPosition->SetAttribute("x", "0");
pPosition->SetAttribute("y", "0");
pPosition->SetAttribute("z", "0");
// rotation
TiXmlElement *pRotation = pNode->InsertEndChild(TiXmlElement("rotation"))->ToElement();
pRotation->SetAttribute("qw", "1");
pRotation->SetAttribute("qx", "0");
pRotation->SetAttribute("qy", "0");
pRotation->SetAttribute("qz", "0");
// scale
TiXmlElement *pScale = pNode->InsertEndChild(TiXmlElement("scale"))->ToElement();
pScale->SetAttribute("x", "1");
pScale->SetAttribute("y", "1");
pScale->SetAttribute("z", "1");
TiXmlElement *pPG = pNode->InsertEndChild(TiXmlElement("pagedgeometry"))->ToElement();
pPG->SetAttribute("fileName", filename.c_str());
pPG->SetAttribute("model", mModel->get().c_str());
pPG->SetAttribute("pageSize", Ogre::StringConverter::toString(mPageSize->get()).c_str());
pPG->SetAttribute("batchDistance", Ogre::StringConverter::toString(mBatchDistance->get()).c_str());
pPG->SetAttribute("impostorDistance", Ogre::StringConverter::toString(mImpostorDistance->get()).c_str());
pPG->SetAttribute("bounds", Ogre::StringConverter::toString(mBounds->get()).c_str());
pPG->SetAttribute("castShadows", Ogre::StringConverter::toString(mCastShadows->get()).c_str());
return pPG;
}
void NavigationMesh::loadCellsFromXML(const Ogre::String& fileName) {
pugi::xml_document doc;
std::vector<int> a, b, c;
std::vector<Ogre::Vector3> vertex;
if (!doc.load_file(fileName.c_str())) {
cerr << "NavigationMesh::loadCellsFromXML(): error al leer el fichero " << fileName << endl;
exit(1);
}
pugi::xml_node meshNode = doc.child("mesh");
pugi::xml_node subMeshesNode = meshNode.child("submeshes");
pugi::xml_node subMeshNode = subMeshesNode.child("submesh");
pugi::xml_node facesNode = subMeshNode.child("faces");
for (pugi::xml_node faceNode = facesNode.child("face"); faceNode; faceNode = faceNode.next_sibling()) {
int v1 = faceNode.attribute("v1").as_int();
int v2 = faceNode.attribute("v2").as_int();
int v3 = faceNode.attribute("v3").as_int();
a.push_back(v1);
b.push_back(v2);
c.push_back(v3);
}
pugi::xml_node geometryNode = subMeshNode.child("geometry");
pugi::xml_node vertexBufferNode = geometryNode.child("vertexbuffer");
for (pugi::xml_node vertexNode = vertexBufferNode.child("vertex"); vertexNode; vertexNode = vertexNode.next_sibling()) {
pugi::xml_node positionNode = vertexNode.child("position");
Ogre::Vector3 v = Ogre::Vector3(positionNode.attribute("x").as_float(),
positionNode.attribute("y").as_float(),
positionNode.attribute("z").as_float());
vertex.push_back(v);
}
int faceCount = a.size();
for (int i = 0; i < faceCount; ++i)
addCell(i, vertex[a[i]], vertex[b[i]], vertex[c[i]]);
}
//-----------------------------------------------------------------------------------------
void CPGInstanceManager::_save(Ogre::String filename)
{
std::ofstream stream(filename.c_str());
PGInstanceList::iterator it = mInstanceList.begin();
while(it != mInstanceList.end())
{
stream << Ogre::StringConverter::toString(it->first).c_str();
stream << ";";
stream << Ogre::StringConverter::toString(it->second.pos).c_str();
stream << ";";
stream << Ogre::StringConverter::toString(it->second.scale).c_str();
stream << ";";
stream << Ogre::StringConverter::toString(it->second.yaw).c_str();
stream << "\n";
it++;
}
}
//----------------------------------------------------------------------------------
bool UILayout::ConvertCEGUIRectToOgre(const Ogre::String& CEGUICoord,Ogre::Vector4& rect)
{
using namespace std;
Ogre::Vector4 temVect;
int n= sscanf(
CEGUICoord.c_str(),
" {{%g,%g},{%g,%g},{%g,%g},{%g,%g}}",
&rect.x, &temVect.x,
&rect.y, &temVect.y,
&rect.z, &temVect.z,
&rect.w, &temVect.w
);
if(n==8)
return true;
return false;
}
//-------------------------------------------------------------------------------------
void SpaceLogin::createScene(void)
{
g_accountName = kbe_getLastAccountName();
if(g_accountName.size() == 0)
g_accountName = KBEngine::StringConv::val2str(KBEngine::genUUID64());
mTrayMgr->createButton(OgreBites::TL_CENTER, "login", "fast login", 120);
Ogre::StringVector values;
values.push_back(g_accountName);
mTrayMgr->createParamsPanel(OgreBites::TL_CENTER, "accountName", 300, values);
mTrayMgr->showCursor();
mTrayMgr->hideFrameStats();
mTrayMgr->hideLogo();
mTrayMgr->hideBackdrop();
mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC);
// Create the camera
mActiveCamera = mSceneMgr->createCamera("PlayerCam");
// Position it at 500 in Z direction
mActiveCamera->setPosition(Ogre::Vector3(0,0,80));
// Look back along -Z
mActiveCamera->lookAt(Ogre::Vector3(0,0,-300));
mActiveCamera->setNearClipDistance(5);
mCameraMan = new OgreBites::SdkCameraMan(mActiveCamera); // create a default camera controller
mCameraMan->setTopSpeed(7.0f);
OgreApplication::getSingleton().setCurrCameraMan(mCameraMan);
// Create one viewport, entire window
Ogre::Viewport* vp = mWindow->addViewport(mActiveCamera);
vp->setBackgroundColour(Ogre::ColourValue(0,0,0));
// Alter the camera aspect ratio to match the viewport
mActiveCamera->setAspectRatio(
Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight()));
}
void TerrainManager::LoadTerrainGeometry(const Ogre::String& name, float* data, Ogre::uint16 size, Ogre::Real worldSize, Ogre::Real minHeight, Ogre::Real maxHeight, const Ogre::Vector3& position)
{
// Create the manual heightfield
NxOgre::ManualHeightField mhf;
mhf.begin(size, size);
Ogre::Real normMin = -32768.0f;
Ogre::Real normMax = 32767.0f;
// Sample the data to the manual heightfield
for(int x = 0; x < size; ++x)
{
NxOgre::Enums::HeightFieldTesselation tess = NxOgre::Enums::HeightFieldTesselation_NW_SE;
for(int z = size-1; z >= 0; --z)
{
Ogre::Real height = data[(size * z) + x];
short sample = (short)(((height - minHeight) / (maxHeight - minHeight)) * (normMax - normMin) + normMin);
mhf.sample(sample, 0, 0, tess);
if(tess == NxOgre::Enums::HeightFieldTesselation_NE_SW)
tess = NxOgre::Enums::HeightFieldTesselation_NW_SE;
else
tess = NxOgre::Enums::HeightFieldTesselation_NE_SW;
}
}
// Create the actual heightfield
NxOgre::HeightField *hf = mhf.end(name.c_str());
Ogre::Real hf_size = worldSize + (worldSize / size);
Ogre::Real hf_height = (maxHeight - minHeight) / 2.0f;
Ogre::Real hf_pose_x = position.x - (worldSize / 2.0f);
Ogre::Real hf_pose_y = position.y + ((maxHeight + minHeight) / 2.0f);
Ogre::Real hf_pose_z = position.z - (worldSize / 2.0f);
#if NxOgreVersionMajor <= 1 && NxOgreVersionMinor <= 5
NxOgre::HeightFieldGeometry* hfg = new NxOgre::HeightFieldGeometry(hf, NxOgre::Vec3(hf_size, hf_height, hf_size));
hfg->setLocalPose(NxOgre::Matrix44(NxOgre::Vec3(hf_pose_x, hf_pose_y, hf_pose_z)));
mSceneGeometry = GameManager::GetInstance()->GetRenderSystem()->getScene()->createSceneGeometry(hfg);
#else
NxOgre::HeightFieldGeometryDescription desc(hf, NxOgre::Vec3(hf_size, hf_height, hf_size));
mSceneGeometry = GameManager::GetInstance()->GetRenderSystem()->getScene()->createSceneGeometry(
desc, NxOgre::Matrix44(NxOgre::Vec3(hf_pose_x, hf_pose_y, hf_pose_z)));
mSceneGeometry->setGroup(1);
#endif
}
void setIndicatorModel( const Ogre::String &lightType )
{
assert( !lightType.empty() );
assert ( mIndicatorSceneNode );
assert ( mPointLightEntity );
assert ( mDirectionalLightEntity );
assert ( mSpotLightEntity );
mIndicatorSceneNode->detachAllObjects();
if ( lightType == "point" )
{
// mIndicatorSceneNode->attachObject(mPointLightEntity);
mCurrentLightEntity = mPointLightEntity;
if ( mOldPos != Ogre::Vector3::ZERO )
mIndicatorSceneNode->setPosition(mOldPos);
}
else if ( lightType == "directional")
{
// mIndicatorSceneNode->attachObject(mDirectionalLightEntity);
// 因为方向光本身没有位置属性，不过指示器会出现在地形中心，会改变scene node的位置
// 所以这里先把旧位置保存下来
mOldPos = mIndicatorSceneNode->getPosition();
mCurrentLightEntity = mDirectionalLightEntity;
// mIndicatorSceneNode->setPosition(0, 0 ,0);
// 获取到地形中心点的高度
float height = mSceneManipulator->getTerrainData()->getHeightAt(0,0);
mIndicatorSceneNode->setPosition(0, height ,0);
}
else if ( lightType == "spotlight" )
{
// mIndicatorSceneNode->attachObject(mSpotLightEntity);
mCurrentLightEntity = mSpotLightEntity;
if ( mOldPos != Ogre::Vector3::ZERO )
mIndicatorSceneNode->setPosition(mOldPos);
}
mIndicatorSceneNode->attachObject(mCurrentLightEntity);
}