Exemplo n.º 1
0
		bool OgitorWorld::LoadGlobalObject(const String_t &type, const Register::Table &dict)
		{
			if((type.compare("Caelum Object") == 0) ||
			   (type.compare("Viewport Object") == 0))
			{
				return true;
			}
			else if(type.compare("OctreeSceneManager") == 0)
			{
				auto &render = OgreEngine::Render::GetInstance();
				render.SetAmbientColor(Register::GetColour(dict, "ambient"));

				return true;
			}
			else if(type.compare("Terrain Group Object") == 0)
			{
				m_pclTerrainGroupTable = &dict;

				return true;
			}
			else if(type.compare("Terrain Page Object") == 0)
			{
				m_pclTerrainPageTable = &dict;

				return true;
			}

			return false;
		}
Exemplo n.º 2
0
bool zip::ZipArchiveInput::ReadFile( String_t const& fileName, Byte_t*& pMemoryBlock, size_t& size )
{
	String_t fileNameKey = fileName;
	if( !m_caseSensitive )
		for (size_t i = 0; i < fileNameKey.size(); ++i )
			fileNameKey[i] = _ttolower( fileNameKey[i] );

	NameToEntry_t::const_iterator keyValue = m_nameToEntry.find( fileNameKey );
	if( keyValue == m_nameToEntry.end() )
	{
		m_errorMessage << "file " << fileNameKey << " not found in the zip index" << std::endl;
		return false;
	}

	ZipEntry const& zipEntry = keyValue->second;
	unz_file_pos pos;
	pos.pos_in_zip_directory = zipEntry.pos_in_zip_directory;
	pos.num_of_file = zipEntry.num_of_file;

	int err = unzGoToFilePos( uf, &pos );
	if( err != UNZ_OK )
	{
		m_errorMessage << "Can't go to file " << fileName << std::endl;
		return false;
	}

	return ReadCurrentFile( fileName, pMemoryBlock, size );
}
Exemplo n.º 3
0
		bool OgitorWorld::LoadStaticObject(StaticObject_s &object, const String_t &name, const String_t &type, const Register::Table &dict)
		{
			TempStaticObject_s temp;

			temp.m_fParent = dict.TryGetString(PH_ENTITY_KEY_PARENT_NODE, object.strParent) && (object.strParent.compare(PH_WORLD_SCENE_MANAGER_NAME) != 0);
			temp.m_strName = name;

			if(type.compare("Node Object") == 0)
			{
				this->LoadNodeObject(temp, dict);
			}
			else if(type.compare("Light Object") == 0)
			{
				this->LoadLightObject(temp, dict);
			}
			else if(type.compare("Entity Object") == 0)
			{
				this->LoadEntityObject(temp, dict);
			}
			else
			{
				LogMakeStream() << "[OgitorWorld::LoadStaticObject] Error, unknown static object type: " << type << "\n";
				return false;
			}

			temp.Commit(object);

			//Check if we have a directional light after commit, to avoid dangling pointers
			if((object.m_pclLight != NULL) && (object.m_pclLight->getType() == Ogre::Light::LT_DIRECTIONAL))
				m_pclTerrainLight = object.m_pclLight;

			return true;
		}
Exemplo n.º 4
0
bool Phobos::System::KeyboardInputDevice::TryGetActionId(const String_t &name, UInt_t &out) const
{	
	if(name.length() == 1)
	{
		Char_t ch = name[0];

		if(IS_ASCII_CHAR(ch))
		{
			out = static_cast<UInt_t>(ch);
			return true;
		}
		else
			return false;
	}
	else
	{
		UInt_t i = 0;
		for(;stInputKeyNames_g[i].pstrzName != NULL; ++i)
		{				
			if(name.compare(stInputKeyNames_g[i].pstrzName) == 0)
			{
				out = stInputKeyNames_g[i].uKey;
				return true;
			}
		}

		return false;
	}
}
Exemplo n.º 5
0
bool zip::ZipArchiveInput::Index()
{
	static const int UNZ_MAXFILENAMEINZIP = 256;

	int err = unzGoToFirstFile(uf);
	if( err != UNZ_OK )
	{
		m_errorMessage << "Can't go to first file" << std::endl;
		return false;
	}

	while (err == UNZ_OK)
	{
		char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
		err = unzGetCurrentFileInfo64(uf, NULL,	szCurrentFileName, sizeof(szCurrentFileName)-1,NULL,0,NULL,0);
		if(err == UNZ_OK)
		{
#ifdef SCARAB_WCHAR_MODE
			String_t fileNameKey = utf_convert::as_wide( szCurrentFileName );
#else
			String_t fileNameKey = szCurrentFileName;
#endif
			if( !m_caseSensitive )
				for (size_t i = 0; i < fileNameKey.size(); ++i )
					fileNameKey[i] = _ttolower( fileNameKey[i] );

			unz_file_pos pos;
			err = unzGetFilePos( uf, &pos );
			if( err != UNZ_OK )
			{
				m_errorMessage << "Can't get file position for " << fileNameKey << std::endl;
				return false;
			}

			ZipEntry zipEntry;
			zipEntry.pos_in_zip_directory = pos.pos_in_zip_directory;
			zipEntry.num_of_file = pos.num_of_file;
			m_nameToEntry.insert( std::make_pair( fileNameKey, zipEntry ) );

			err = unzGoToNextFile(uf);
			if( err != UNZ_OK && err != UNZ_END_OF_LIST_OF_FILE )
			{
				m_errorMessage << "Can't go to next file" << std::endl;
				return false;
			}
		}
		else
		{
			m_errorMessage << "Can't get file info" << std::endl;
			return false;
		}
	}

	return err == UNZ_END_OF_LIST_OF_FILE;
}
Exemplo n.º 6
0
void Phobos::Register::Table::SetString(const String_t &key, const String_t &value)
{	
	CheckForKeyword(key);

	m_mapValues[key] = Value_s(value);

	if(key.compare(INHERIT_KEY) == 0)
	{			
		m_strInherit = value;
		m_pclInherit = NULL;
	}
	if(key.compare(BASE_HIVE_KEY) == 0)
	{			
		m_strBaseHive = value;
		m_pclInherit = NULL;
	}
}
Exemplo n.º 7
0
void Phobos::Engine::PluginManager::OnUpdate()
{
	if(!m_fSystemReady)
		return;

	while(!m_lstPluginsToActivate.empty())
	{
		String_t pluginName;
		pluginName.swap(m_lstPluginsToActivate.front());
		m_lstPluginsToActivate.pop_front();

		PluginInstance *plugin = static_cast<PluginInstance *>(this->TryGetChild(pluginName));
		if(plugin)
		{
			plugin->Init();
		}
	}
}
Exemplo n.º 8
0
void Phobos::Register::Table::SetCharMatrix(const String_t &key, const String_t &data, UInt16_t numRows, UInt16_t numColumns)
{	
	CheckForKeyword(key);
	this->CheckInvalidKey(key, parszStringOnlyKeys_g, "should be string data, not matrix");

	if(numRows * numColumns == 0)
	{
		PH_RAISE(INVALID_PARAMETER_EXCEPTION, "Phobos::Register::Table::ParseSpecialValue", "Matrix cannot be empty");
	}

	if(numRows * numColumns != data.length())
	{
		std::stringstream stream;
		stream << "Matrix data size (" << data.length() << ") does not match width (" << numColumns << ") and height (" << numRows << ") parameters";
		PH_RAISE(INVALID_PARAMETER_EXCEPTION, "Phobos::Register::Table::ParseSpecialValue", stream.str());
	}		

	m_mapValues[key] = Value_s(data, numRows, numColumns);
}
Exemplo n.º 9
0
void Phobos::Register::Table::CheckInvalidKey(const String_t &key, const char *keys[], const char *message) const
{
	for(int i = 0;keys[i]; ++i)
	{
		if(key.compare(keys[i]) == 0)
		{
			std::stringstream stream;
			stream << "Value " << key << " " << message;
			PH_RAISE(INVALID_PARAMETER_EXCEPTION, "Phobos::Register::Table::CheckInvalidKey", stream.str());
		}
	}
}
Exemplo n.º 10
0
int32_t equals(String_t* self, String_t* anObject) {
    if (self == anObject) {
        return 1;
    }

    String_t *anotherString = (String_t*) anObject;
    int32_t n = self->length(self);
    if (n == anotherString->length(anotherString)) {
        char* v1 = self->toString(self);
        char* v2 = anotherString->toString(anotherString);
        int i = 0;
        while (n-- != 0) {
            if (v1[i] != v2[i]) {
                return 0;
            }
            i++;
        }
        return 1;
    }
    return 0;
}
Exemplo n.º 11
0
void Phobos::System::WindowSDL::Open(const String_t &name, const UIntSize_t &size, void *parentWindow)
{

	SDL_Init(SDL_INIT_VIDEO);

	SDL_EnableUNICODE(1);

        #ifdef PH_WIN32
			unsigned int flags = 0;

			HWND parent = reinterpret_cast<HWND>(parentWindow);
			if(parent)
				flags = SDL_NOFRAME | SDL_RESIZABLE;

            SDL_SetVideoMode(size.m_tWidth, size.m_tHeight, 32, flags);

			if(parent)
			{
				HWND sdlHwnd = reinterpret_cast<HWND>(this->GetHandler());

				//not 100% trusted, but give us an extra check
				if(!IsWindow(parent))
				{
					PH_RAISE(INVALID_PARAMETER_EXCEPTION, "[WindowSDL::Open]", "Invalid parent window handle");
				}

				RECT parentRec;					
				GetClientRect(parent, &parentRec);
					
				//SetWindowPos( sdlHwnd, parent, 0, 0, parentRec.right, parentRec.bottom, ( 0 /*SWP_NOSIZE*/ | SWP_SHOWWINDOW ));
				MoveWindow(sdlHwnd, 0, 0,  parentRec.right, parentRec.bottom, true);
				SetParent(sdlHwnd, parent);			

				//SetWindowLong(sdlHwnd, GWL_STYLE, WS_MAXIMIZE);
			}

        #else
            SDL_SetVideoMode(rect.tWidth, rect.tHeight, 0, SDL_OPENGL);
        #endif

        #ifdef PH_LINUX
            SDL_GL_SetAttribute( SDL_GL_RED_SIZE,           8  );
            SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE,         8  );
            SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE,          8  );
            SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE,         16 );
        #endif

        SDL_WM_SetCaption(name.c_str(), NULL);
}
Exemplo n.º 12
0
    bool read_string( const String_t& s, Value_t& value )
    {
        typename String_t::const_iterator begin = s.begin();

        return read_range( begin, s.end(), value );
    }
Exemplo n.º 13
0
 void read_string_or_throw( const String_t& s, Value_t& value )
 {
     add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
 }
Exemplo n.º 14
0
void Phobos::Register::Table::Load(Parser &parser)
{
	String_t idName;
	String_t value;

	ParserTokens_e token = parser.GetToken(&value);

	if(token != TOKEN_OPEN_BRACE)
		RaiseParseException(parser, TOKEN_OPEN_BRACE, token, value, "Phobos::Register::Table::Load");

	for(;;)
	{
		token = parser.GetToken(&value);
		if(token == TOKEN_CLOSE_BRACE)
			break;

		idName.clear();
		//Accepts name in the format:
		//model=
		//RenderCompoenent.model=
		for(;;)
		{
			if(token != TOKEN_ID)
				RaiseParseException(parser, TOKEN_ID, token, value, "Phobos::Register::Table::Load");

			idName.append(value);
			token = parser.GetToken(&value);
			if(token == TOKEN_DOT)
			{
				idName.append(value);
				token = parser.GetToken(&value);
				continue;
			}

			if(token == TOKEN_EQUAL)
				break;

			RaiseParseException(parser, TOKEN_EQUAL, token, value, "Phobos::Register::Table::Load");
		}

		token = parser.GetToken(&value);
		switch(token)
		{
			case TOKEN_ID:
				if(value.compare("new") == 0)
				{
					this->ParseSpecialValue(idName, parser);
					break;
				}
				//not special, just store it
				//fall thought

			case TOKEN_NUMBER:
			case TOKEN_STRING:
				this->SetString(idName, value);
				break;

			default:
				RaiseParseException(parser, TOKEN_STRING, token, idName, "Phobos::Register::Table::Load");
				break;
		}

		token = parser.GetToken(&value);
		if(token != TOKEN_SEMI_COLON)
			RaiseParseException(parser, TOKEN_SEMI_COLON, token, value, "Phobos::Register::Table::Load");
	}
}
Exemplo n.º 15
0
void Phobos::Register::Table::ParseSpecialValue(const String_t &idName, Parser &parser)
{
	String_t type;

	ParserTokens_e token;
	if((token = parser.GetToken(&type)) != TOKEN_ID)
	{
		RaiseParseException(parser, TOKEN_ID, token, type, "Phobos::Register::Table::ParseSpecialValue");
	}

	if(type.compare("CharMatrix") == 0)
	{
		if((token = parser.GetToken(NULL)) != TOKEN_OPEN_PAREN)
		{
			RaiseParseException(parser, TOKEN_OPEN_PAREN, token, type, "Phobos::Register::Table::ParseSpecialValue");
		}

		String_t matrix;
		String_t row;

		UInt16_t numColumns = 0;
		UInt16_t numRows = 0;

		bool first = true;
		for(;;)
		{
			token = parser.GetToken(&row);
			if(token == TOKEN_CLOSE_PAREN)
			{
				if(first)
				{
					//do not allow empty matrix
					RaiseParseException(parser, "matrix data", "closing parenthesis", "Phobos::Register::Table::ParseSpecialValue");
				}
					
				this->SetCharMatrix(idName, matrix, numRows, numColumns);
				break;
			}
			else if(token == TOKEN_STRING)
			{
				if(first)
				{
					numColumns = row.length();

					if(numColumns == 0)
						PH_RAISE(PARSER_EXCEPTION, "Phobos::Register::Table::ParseSpecialValue", "Matrix cannot be empty");

					first = false;
				}
				else if(numColumns != row.length())
				{
					PH_RAISE(PARSER_EXCEPTION, "Phobos::Register::Table::ParseSpecialValue", "Matrix rows should always have the same length");
				}

				matrix.append(row);
				++numRows;
			}
			else
			{
				RaiseParseException(parser, TOKEN_STRING, token, row, "Phobos::Register::Table::ParseSpecialValue");
			}
		}
	}	
	else
	{
		RaiseParseException(parser, " valid especial type, ie CharMatrix", type.c_str(), "Phobos::Register::Table::ParseSpecialValue");
	}
}
Exemplo n.º 16
0
bool hatch::RegistryParser::ParseFile( Registry& registry, RegistryAction& action )
{
	if( !SkipEndLines() )
	{
		m_errorMessage << "Parameters expected after 'file {'";
		return false;
	}

	bool process = true;
	do
	{
		if( m_tokenizer.IsWord() )
		{
			const char* key = m_tokenizer.GetWord();
			if( Cmp( "action", key ) )
			{
				String_t value;
				if( !ParseWordValue( value ) )
				{
					m_errorMessage << "for action";
					return false;
				}

				if( !dung::StringToAction( value.c_str(), action.action ) )
				{
					m_errorMessage << _T("Unknown action ") << value;
					return false;
				}
			}
			else if( Cmp( "diff_path", key ) )
			{
				if( !ParseStringValue( action.diff_path ) )
				{
					m_errorMessage << _T("for diff_path");
					return false;
				}
			}
			else if( Cmp( "old_path", key ) )
			{
				if( !ParseStringValue( action.old_path ) )
				{
					m_errorMessage << _T("for old_path");
					return false;
				}
			}
			else if( Cmp( "new_path", key ) )
			{
				if( !ParseStringValue( action.new_path ) )
				{
					m_errorMessage << "for new_path";
					return false;
				}
			}
			else if( Cmp( "diff_method", key ) )
			{
				if( !ParseWordValue( action.diff_method ) )
				{
					m_errorMessage << "for diff_method";
					return false;
				}
			}
			else if( Cmp( "old_sha1", key ) )
			{
				String_t value;
				if( !ParseStringValue( value ) )
				{
					m_errorMessage << "for old_sha1";
					return false;
				}

				if( !dung::StringToSHA1( value.c_str(), action.oldSha1 ))
				{
					m_errorMessage << "Can't convert " << value << " to old_sha1";
					return false;
				}

				SCARAB_ASSERT( dung::SHA1_TO_TSTRING( action.oldSha1 ) == value );
			}
			else if( Cmp( "new_sha1", key ) )
			{
				String_t value;
				if( !ParseStringValue( value ) )
				{
					m_errorMessage << "for new_sha1";
					return false;
				}

				if( !dung::StringToSHA1( value.c_str(), action.newSha1 ))
				{
					m_errorMessage << "Can't convert " << value << " to new_sha1";
					return false;
				}

				SCARAB_ASSERT( dung::SHA1_TO_TSTRING( action.newSha1 ) == value );
			}
			else if( Cmp( "old_size", key ) )
			{
				String_t value;
				if( !ParseNumValue( value ) )
				{
					m_errorMessage << "for old_size";
					return false;
				}
				action.oldSize = _tchar_to_long( value.c_str() );
			}
			else if( Cmp( "new_size", key ) )
			{
				String_t value;
				if( !ParseNumValue( value ) )
				{
					m_errorMessage << "for new_size";
					return false;
				}
				action.newSize = _tchar_to_long( value.c_str() );
			}
		}
		else if( m_tokenizer.IsSymbol() && m_tokenizer.GetSymbol() == '}' )
			return true;

		if( !m_tokenizer.ParseNext() )
		{
			m_errorMessage << "'}' expected for 'file'";
			process = false;
		}
	} while( process );

	return false;
}