bool LuaState::ExecuteFromStream(Stream& stream, int errorHandler)
{
if (!LoadFromStream(stream))
return false;
return CallWithHandler(errorHandler, 0);
}
//
// 从文件加载资源
//
BOOL CRenderFlow::LoadFromFile(const CHAR *szFileName, FLOAT scalePPI)
{
//
// 1. 参数安全检查
//
if (szFileName == NULL) {
return FALSE;
}
//
// 2. 释放资源
//
Free();
//
// 3. 加载资源
//
try {
WriteLogI("Load RenderFlow from file: %s\n", szFileName);
if (m_stream.LoadFromFile(szFileName) == FALSE) throw "Load file failed.";
if (LoadFromStream(&m_stream, scalePPI) == FALSE) throw "Load from stream failed.";
return TRUE;
}
catch (const CHAR *szError) {
WriteLogE("Error CRenderFlow::LoadFromFile: %s %s %d\n", szError, __FILE__, __LINE__);
Free();
return FALSE;
}
}
boost::optional<Data> Data::LoadFromFile(const bf::path &filepath) {
ifstream file(filepath.c_str(), ios::binary);
if (!file.good()) {
return boost::none;
}
return LoadFromStream(file);
}
// Load functions
void Parser::LoadFromFilename(Puzzle * puz, const std::string & filename)
{
std::ifstream stream(filename.c_str(),
std::ios_base::binary | std::ios_base::in);
if (stream.fail())
throw FileError(filename);
LoadFromStream(puz, stream);
}
Bool TgaFile::LoadFromMemory( const std::string & p_Memory )
{
// Load a string stream
std::stringstream ss;
ss.str( p_Memory );
// Read the stream
Bool status = LoadFromStream( ss );
// Return the status
return status;
}
Bool Md2File::LoadFromMemory( const std::string & p_Memory )
{
// Load a string stream
std::stringstream ss;
ss.rdbuf( )->pubsetbuf( const_cast<char*>( p_Memory.c_str( ) ), p_Memory.size( ) );
// Read the stream
Bool status = LoadFromStream( ss );
// Return the status
return status;
}
StVKReducedInternalForces::StVKReducedInternalForces(const char * filename, int rTarget, int bigEndianMachine, int verbose_) : unitReducedGravityForce(NULL), reducedGravityForce(NULL), addGravity(false), g(9.81), useSingleThread(0), shallowCopy(0), verbose(verbose_)
{
FILE * fin = fopen(filename, "rb");
if (!fin)
{
printf("Error: could not read from the input cubic polynomial file.\n");
throw 1;
}
LoadFromStream(fin, rTarget, bigEndianMachine);
fclose(fin);
}
bool IStateStore::LoadFromFile( const wxString& fileName, bool useMemory /* true */ )
{
STOPWATCH_BEGIN;
wxFileInputStream stream(fileName);
bool res = false;
void* block = NULL;
if (stream.IsOk())
{
wxBusyInfo info("Loading, please wait...");
if (useMemory)
{
size_t size = stream.GetSize();
block = malloc(size);
stream.Read( block, size );
res = LoadFromStream( wxMemoryInputStream(block, size) );
}
else
{
res = LoadFromStream( stream );
}
}
else
{
wxLogError(wxString::Format("%s::LoadFromFile: can't open file (%s) to read data!", mMyName, fileName));
}
if (block)
{
free(block);
}
STOPWATCH_END(wxString("IStateStore::LoadFromFile ").Append(fileName));
return res;
}
//
// 重新加载资源
//
BOOL CRenderFlow::Reload(FLOAT scalePPI)
{
//
// 1. 重定位数据流
//
if (m_stream.Seek(0, CStream::SEEK_MODE_SET) == FALSE) {
return FALSE;
}
//
// 2. 重新加载
//
return LoadFromStream(&m_stream, scalePPI);
}
rXMLReaderError rXMLDocument::LoadFromFile(const rString& path){
Clear();
rIFileStream stream(path);
rXMLReaderError error = rXML_READER_NO_ERROR;
if (stream)
error = LoadFromStream(stream);
else
error = rXML_READER_FILE_NOT_FOUND;
stream.Close();
return error;
}
Bool Md2File::LoadFromFile( const std::string & p_Filename )
{
// Open the file.
std::ifstream fin( p_Filename.c_str( ), std::ifstream::binary );
if( fin.is_open( ) == false )
{
bitLogGraErr( "Can not open the file." );
return false;
}
Bool status = LoadFromStream( fin );
fin.close( );
// Return the status
return status;
}
bool cTextureFont::Load( const Uint32& TexId, const std::string& CoordinatesDatPath ) {
if ( FileSystem::FileExists( CoordinatesDatPath ) ) {
cIOStreamFile IOS( CoordinatesDatPath, std::ios::in | std::ios::binary );
return LoadFromStream( TexId, IOS );
} else if ( cPackManager::instance()->FallbackToPacks() ) {
std::string tPath( CoordinatesDatPath );
cPack * tPack = cPackManager::instance()->Exists( tPath );
if ( NULL != tPack ) {
return LoadFromPack( TexId, tPack, tPath );
}
}
return false;
}
bool setupGraphics(int w, int h, std::string bundlePath) {
gProgram = createProgram(gVertexShaderTexture, gFragmentShaderTexture);
if (!gProgram) {
return false;
}
gvPositionHandle = glGetAttribLocation(gProgram, "vPosition");
gvUVHandle = glGetAttribLocation(gProgram, "vUV");
glViewport(0, 0, w, h);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
std::string fullTexturePath = "Candy_Person.png";
std::vector<char> buffer;
AssetLoader::GetAssetStream(fullTexturePath.c_str(), buffer);
std::string pngDataString;
for (int i = 0; i < buffer.size(); i++)
{
pngDataString += buffer[i];
}
std::istringstream pngDataStream( pngDataString );
GLuint texture = LoadFromStream(pngDataStream);
glBindTexture(GL_TEXTURE_2D, texture);
return true;
}
//
// 从压缩包加载资源
//
BOOL CSceneManager::LoadFromZip(const CHAR *szZipName, const CHAR *szFileName)
{
//
// 1. 参数安全检查
//
if (szZipName == NULL) {
return FALSE;
}
if (szFileName == NULL) {
return FALSE;
}
//
// 2. 释放资源
//
Free();
//
// 3. 加载资源
//
try {
WriteLogI("Load from zip: %s<%s>\n", szZipName, szFileName);
if (m_stream.LoadFromZip(szZipName, szFileName) == FALSE) throw "Load zip failed.";
if (LoadFromStream(&m_stream) == FALSE) throw "Load from stream failed.";
return TRUE;
}
catch (const CHAR *szError) {
WriteLogE("Error CSceneManager::LoadFromZip: %s %s %d\n", szError, __FILE__, __LINE__);
Free();
return FALSE;
}
}
//
// 从压缩包文件加载数据流
//
BOOL CRenderFlow::LoadFromZip(ZZIP_DIR *pZipPack, const CHAR *szFileName, FLOAT scalePPI)
{
//
// 1. 参数安全检查
//
if (pZipPack == NULL) {
return FALSE;
}
if (szFileName == NULL) {
return FALSE;
}
//
// 2. 释放资源
//
Free();
//
// 3. 加载资源
//
try {
WriteLogI("Load RenderFlow from zip: <%s>\n", szFileName);
if (m_stream.LoadFromZip(pZipPack, szFileName) == FALSE) throw "Load zip failed.";
if (LoadFromStream(&m_stream, m_scalePPI) == FALSE) throw "Load from stream failed.";
return TRUE;
}
catch (const CHAR *szError) {
WriteLogE("Error CRenderFlow::LoadFromZip: %s %s %d\n", szError, __FILE__, __LINE__);
Free();
return FALSE;
}
}
bool cTextureFont::LoadFromMemory( const Uint32& TexId, const char* CoordData, const Uint32& CoordDataSize ) {
cIOStreamMemory IOS( CoordData, CoordDataSize );
return LoadFromStream( TexId, IOS );
}
CategoriesHolder::CategoriesHolder(unique_ptr<Reader> && reader)
{
ReaderStreamBuf buffer(move(reader));
istream s(&buffer);
LoadFromStream(s);
}
void clMesh::LoadFromBinaryFile( const LString& FName )
{
iIStream* InStream = Env->FileSystem->CreateFileReader( FName );
LoadFromStream( InStream );
delete InStream;
}
static void window_title_editor_mouseup(rct_window * w, rct_widgetindex widgetIndex)
{
bool commandEditorOpen = (window_find_by_class(WC_TITLE_COMMAND_EDITOR) != nullptr);
switch (widgetIndex)
{
case WIDX_TITLE_EDITOR_CLOSE:
window_close(w);
break;
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Presets tab
//////////////////////////////////////////////////////////////////////////////////////////////////////
case WIDX_TITLE_EDITOR_NEW_BUTTON:
if (!commandEditorOpen)
{
// TODO: This should probably be 'NEW'
window_text_input_open(w, widgetIndex, STR_TITLE_EDITOR_ACTION_DUPLICATE, STR_TITLE_EDITOR_ENTER_NAME_FOR_SEQUENCE, STR_NONE, 0, 64);
}
break;
case WIDX_TITLE_EDITOR_DUPLICATE_BUTTON:
if (!commandEditorOpen && _editingTitleSequence != nullptr)
{
window_text_input_open(w, widgetIndex, STR_TITLE_EDITOR_ACTION_DUPLICATE, STR_TITLE_EDITOR_ENTER_NAME_FOR_SEQUENCE, STR_STRING, (uintptr_t)_sequenceName, 64);
}
break;
case WIDX_TITLE_EDITOR_DELETE_BUTTON:
if (window_title_editor_check_can_edit())
{
title_sequence_manager_delete(_selectedTitleSequence);
window_title_editor_load_sequence(0);
}
break;
case WIDX_TITLE_EDITOR_RENAME_BUTTON:
if (window_title_editor_check_can_edit() && _editingTitleSequence != nullptr)
{
window_text_input_open(w, widgetIndex, STR_TRACK_MANAGE_RENAME, STR_TITLE_EDITOR_ENTER_NAME_FOR_SEQUENCE, STR_STRING, (uintptr_t)_sequenceName, 64);
}
break;
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Editor tab
//////////////////////////////////////////////////////////////////////////////////////////////////////
case WIDX_TITLE_EDITOR_ADD_SAVE:
if (!_isSequenceReadOnly && !title_is_previewing_sequence() && !commandEditorOpen)
{
auto intent = Intent(WC_LOADSAVE);
intent.putExtra(INTENT_EXTRA_LOADSAVE_TYPE, LOADSAVETYPE_LOAD | LOADSAVETYPE_GAME);
intent.putExtra(INTENT_EXTRA_CALLBACK, (void *) window_title_editor_add_park_callback);
context_open_intent(&intent);
}
break;
case WIDX_TITLE_EDITOR_REMOVE_SAVE:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1)
{
TitleSequenceRemovePark(_editingTitleSequence, w->selected_list_item);
if (w->selected_list_item >= (sint16)_editingTitleSequence->NumSaves)
{
w->selected_list_item--;
}
}
}
break;
case WIDX_TITLE_EDITOR_RENAME_SAVE:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1)
{
window_text_input_open(w, widgetIndex, STR_FILEBROWSER_RENAME_SAVE_TITLE, STR_TITLE_EDITOR_ENTER_NAME_FOR_SAVE, STR_STRING, (uintptr_t)_editingTitleSequence->Saves[w->selected_list_item], 52 - 1);
}
}
break;
case WIDX_TITLE_EDITOR_LOAD_SAVE:
if (w->selected_list_item >= 0 && w->selected_list_item < (sint16)_editingTitleSequence->NumSaves)
{
auto handle = TitleSequenceGetParkHandle(_editingTitleSequence, w->selected_list_item);
auto stream = (IStream *)handle->Stream;
auto hintPath = String::ToStd(handle->HintPath);
bool isScenario = ParkImporter::ExtensionIsScenario(hintPath);
auto objectMgr = OpenRCT2::GetContext()->GetObjectManager();
auto parkImporter = std::unique_ptr<IParkImporter>(ParkImporter::Create(hintPath));
auto result = parkImporter->LoadFromStream(stream, isScenario);
objectMgr->LoadObjects(result.RequiredObjects.data(), result.RequiredObjects.size());
parkImporter->Import();
if (isScenario)
scenario_begin();
else
game_load_init();
TitleSequenceCloseParkHandle(handle);
window_title_editor_open(WINDOW_TITLE_EDITOR_TAB_SAVES);
}
break;
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Commands tab
//////////////////////////////////////////////////////////////////////////////////////////////////////
case WIDX_TITLE_EDITOR_INSERT:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1)
window_title_command_editor_open(_editingTitleSequence, w->selected_list_item + 1, true);
else
window_title_command_editor_open(_editingTitleSequence, (sint32)_editingTitleSequence->NumCommands, true);
}
break;
case WIDX_TITLE_EDITOR_EDIT:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1 && w->selected_list_item < (sint16)_editingTitleSequence->NumCommands)
{
window_title_command_editor_open(_editingTitleSequence, w->selected_list_item, false);
}
}
break;
case WIDX_TITLE_EDITOR_DELETE:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1 && w->selected_list_item < (sint16)_editingTitleSequence->NumCommands)
{
for (sint32 i = w->selected_list_item; i < (sint16)_editingTitleSequence->NumCommands - 1; i++)
{
_editingTitleSequence->Commands[i] = _editingTitleSequence->Commands[i + 1];
}
_editingTitleSequence->NumCommands--;
if (w->selected_list_item >= (sint16)_editingTitleSequence->NumCommands)
{
w->selected_list_item--;
}
TitleSequenceSave(_editingTitleSequence);
}
}
break;
case WIDX_TITLE_EDITOR_SKIP_TO:
{
sint32 position = w->selected_list_item;
if (title_is_previewing_sequence() && position != -1 && position < (sint32)_editingTitleSequence->NumCommands)
{
ITitleSequencePlayer * player = window_title_editor_get_player();
title_sequence_player_seek(player, position);
title_sequence_player_update(player);
}
break;
}
case WIDX_TITLE_EDITOR_MOVE_DOWN:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item != -1 && w->selected_list_item < (sint16)_editingTitleSequence->NumCommands - 1)
{
TitleCommand * a = &_editingTitleSequence->Commands[w->selected_list_item];
TitleCommand * b = &_editingTitleSequence->Commands[w->selected_list_item + 1];
TitleCommand tmp = *a;
*a = *b;
*b = tmp;
w->selected_list_item++;
TitleSequenceSave(_editingTitleSequence);
}
}
break;
case WIDX_TITLE_EDITOR_MOVE_UP:
if (window_title_editor_check_can_edit())
{
if (w->selected_list_item > 0 && w->selected_list_item < (sint16)_editingTitleSequence->NumCommands)
{
TitleCommand * a = &_editingTitleSequence->Commands[w->selected_list_item - 1];
TitleCommand * b = &_editingTitleSequence->Commands[w->selected_list_item];
TitleCommand tmp = *b;
*b = *a;
*a = tmp;
w->selected_list_item--;
TitleSequenceSave(_editingTitleSequence);
}
}
break;
case WIDX_TITLE_EDITOR_REPLAY:
if (title_is_previewing_sequence())
{
ITitleSequencePlayer * player = window_title_editor_get_player();
title_sequence_player_reset(player);
title_sequence_player_update(player);
}
break;
case WIDX_TITLE_EDITOR_STOP:
if (title_is_previewing_sequence())
{
title_stop_previewing_sequence();
}
break;
case WIDX_TITLE_EDITOR_PLAY:
if (!title_is_previewing_sequence() || _selectedTitleSequence != title_get_current_sequence())
{
if (!title_preview_sequence(_selectedTitleSequence))
{
context_show_error(STR_ERR_FAILED_TO_LOAD_TITLE_SEQUENCE, STR_NONE);
}
else if (!(gScreenFlags & SCREEN_FLAGS_TITLE_DEMO))
{
gPreviewingTitleSequenceInGame = true;
}
}
break;
case WIDX_TITLE_EDITOR_SKIP:
if (title_is_previewing_sequence())
{
ITitleSequencePlayer * player = window_title_editor_get_player();
sint32 position = title_sequence_player_get_current_position(player) + 1;
if (position >= (sint32)_editingTitleSequence->NumCommands)
{
position = 0;
}
title_sequence_player_seek(player, position);
title_sequence_player_update(player);
}
break;
}
}
bool LuaState::LoadFromMemory(const void* data, std::size_t size)
{
MemoryView stream(data, size);
return LoadFromStream(stream);
}
StVKReducedInternalForces::StVKReducedInternalForces(FILE * fin, int rTarget, int bigEndianMachine, int verbose_) : unitReducedGravityForce(NULL), reducedGravityForce(NULL), addGravity(false), g(9.81), useSingleThread(0), shallowCopy(0), verbose(verbose_)
{
LoadFromStream(fin, rTarget, bigEndianMachine);
}
