void CameraSpotsManager::LoadFromXML()
{
r3dString path = ConstructXMLPath( false );
r3dFile* f = r3d_open(path.c_str(), "r");
if (!f) return;
r3dTL::TArray<char> fileBuffer(f->size + 1);
fread(&fileBuffer[0], f->size, 1, f);
fileBuffer[f->size] = 0;
pugi::xml_document xmlDoc;
pugi::xml_parse_result parseResult = xmlDoc.load_buffer_inplace(&fileBuffer[0], f->size);
fclose(f);
if (!parseResult) return;
pugi::xml_node xmlSpotData = xmlDoc.child("camera_spot");
while (!xmlSpotData.empty())
{
CameraSpotData csd;
csd.name = xmlSpotData.attribute("name").value();
GetXMLVal("pos", xmlSpotData, &csd.pos);
GetXMLVal("up", xmlSpotData, &csd.up);
GetXMLVal("target", xmlSpotData, &csd.target);
AddSpot(csd);
xmlSpotData = xmlSpotData.next_sibling();
}
}
bool Engine::CWorld::Reload()
{
if (!CheckReloadFileExist())
{
return false;
}
std::ifstream fileBuffer("./data/ReloadFile.reload", std::ifstream::in);
std::stringstream sData;
sData << fileBuffer.rdbuf();
fileBuffer.close();
if (sData.str().size() == 0)
{
return false;
}
int zStartOffset = 0;
int zEndOffset = 0;
std::vector<std::string> vsReloadFiles;
while (sData.str().find('\n', zStartOffset) != std::string::npos)
{
zEndOffset = sData.str().find('\n', zStartOffset);
vsReloadFiles.push_back(sData.str().substr(zStartOffset, zEndOffset - zStartOffset));
zStartOffset = zEndOffset + 1;
}
for (size_t zIndex = 0; zIndex < vsReloadFiles.size(); ++zIndex)
{
if (vsReloadFiles[zIndex].find(".scene") != std::string::npos)
{
GetSceneFiles();
if (GetSceneFileIndexByPath(vsReloadFiles[zIndex].c_str()) == m_zCurrentScene)
{
SetupScene(vsReloadFiles[zIndex].c_str());
}
}
}
FILE* pFile;
pFile = fopen("./data/ReloadFile.reload", "w");
fclose(pFile);
return true;
}
void ConfigurationFile::Save()
{
std::string output;
m_ini->Save(output);
char* outputBuffer = new char[ output.length() + 1 ];
memcpy(outputBuffer, output.c_str(), output.length());
outputBuffer[ output.length() ] = '\0';
FileBuffer fileBuffer(outputBuffer, output.length(), m_filePath);
m_fileSystem->SaveFile(fileBuffer);
}
unsigned int MaterialList::addMaterial(const char* directory, const char* prefix, const char* materialName)
{
char filename[256];
physx::string::sprintf_s(filename, 256, "%s/%s%s", directory, prefix, materialName);
XmlParser parser((unsigned int)mPaths.size());
FAST_XML::FastXml* fastXml = FAST_XML::createFastXml(&parser);
if (fastXml != NULL)
{
physx::PxFileBuffer fileBuffer(filename, physx::PxFileBuf::OPEN_READ_ONLY);
fastXml->processXml(fileBuffer);
int errorLineNumber = 0;
const char* xmlError = fastXml->getError(errorLineNumber);
if (xmlError != NULL)
{
if (strncmp(xmlError, "User aborted", 12) == 0)
{
}
else
{
#ifdef PX_WINDOWS
char error[512];
sprintf_s(error, 512, "%s\n%s", filename, xmlError);
::MessageBox(NULL, error, "MaterialList XML Parse error", MB_OK);
#endif
}
}
fastXml->release();
}
if (parser.isMaterial())
{
char saneFileName[128];
physx::string::sprintf_s(saneFileName, 128, "%s%s", prefix, materialName);
if (mMaterialNames.find(saneFileName) != mMaterialNames.end())
{
PX_ASSERT(!"Duplicated material name found");
}
else
{
mMaterialNames[saneFileName] = parser.getMaterialInfo();
return 1;
}
}
return 0;
}
/*virtual*/ U32 get_body(LLChannelDescriptors const& channels, buffer_ptr_t& buffer)
{
LLBufferStream ostream(channels, buffer.get());
LLVFile vfile(gVFS, mUUID, mAssetType, LLVFile::READ);
S32 fileSize = vfile.getSize();
std::vector<U8> fileBuffer(fileSize);
vfile.read(&fileBuffer[0], fileSize);
ostream.write((char*)&fileBuffer[0], fileSize);
ostream << std::flush;
return fileSize;
}
void buffer(void) {
int source[] = {1, 2, 3, 4};
int target[] = {0, 0, 0, 0};
int n;
FILE *file;
file = fopen("test", "wr");
fwrite(source, sizeof(source), 1, file);
fileBuffer(file, &target, &n);
assert(memcmp(source, target, sizeof(source)));
fclose(file);
remove("test");
}
// Test if a file contains an unencrypted database.
bool Database::isUnencrypted(const std::string& aFilename)
{
if (aFilename.length() > 0) {
std::ifstream fileBuffer(aFilename.c_str(), std::ios::in | std::ios::binary);
char header[16];
if (fileBuffer.is_open()) {
fileBuffer.seekg(0, std::ios::beg);
fileBuffer.getline(header, 16);
fileBuffer.close();
} else {
const SQLite::Exception exception("Error opening file: " + aFilename);
throw exception;
}
return strncmp(header, "SQLite format 3\000", 16) == 0;
}
const SQLite::Exception exception("Could not open database, the aFilename parameter was empty.");
throw exception;
}
void ConfigurationFile::Load(const std::string& fileName)
{
std::stringstream configPath;
configPath <<m_platformManager->GetPathInformation()->GetLocalConfigPath() <<"/" <<fileName;
if (!m_fileSystem->FileExists(configPath.str()))
{
FileBuffer fileBuffer(0, 0, configPath.str());
m_fileSystem->SaveFile(fileBuffer);
}
FileBuffer* buffer = m_fileSystem->GetFile(configPath.str(), true);
// m_ini->Load(buffer->fileBytes);
m_filePath = buffer->filePath;
delete buffer;
}
void XmlTreeSerializer::saveTreeAsFile(const TreeIterator& treeIterator, const String& fileName, bool unicode, const NumberFormat* numberFormat)
{
LocalFile::removeIfExists(fileName);
BinaryFileBuffer fileBuffer(fileName, false, true);
BinaryOutputStream outputStream(fileBuffer);
if (unicode == true)
{
outputStream.setStringEncoding(BinaryStreamEncoding::CHAR16);
outputStream << "<?xml version='1.0' encoding='UTF-16' ?>" << newLine;
}
else
{
outputStream.setStringEncoding(BinaryStreamEncoding::CHAR8);
outputStream << "<?xml version='1.0' encoding='UTF-8' ?>" << newLine;
}
saveTree(treeIterator, outputStream, 0, numberFormat);
fileBuffer.close();
}
static nsresult openPrefFile(nsIFile* aFile)
{
nsCOMPtr<nsIInputStream> inStr;
#if MOZ_TIMELINE
{
nsCAutoString str;
aFile->GetNativePath(str);
NS_TIMELINE_MARK_FUNCTION1("load pref file", str.get());
}
#endif
nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inStr), aFile);
if (NS_FAILED(rv))
return rv;
PRInt64 fileSize;
rv = aFile->GetFileSize(&fileSize);
if (NS_FAILED(rv))
return rv;
nsAutoArrayPtr<char> fileBuffer(new char[fileSize]);
if (fileBuffer == nsnull)
return NS_ERROR_OUT_OF_MEMORY;
PrefParseState ps;
PREF_InitParseState(&ps, PREF_ReaderCallback, NULL);
// Read is not guaranteed to return a buf the size of fileSize,
// but usually will.
nsresult rv2 = NS_OK;
for (;;) {
PRUint32 amtRead = 0;
rv = inStr->Read((char*)fileBuffer, fileSize, &amtRead);
if (NS_FAILED(rv) || amtRead == 0)
break;
if (!PREF_ParseBuf(&ps, fileBuffer, amtRead))
rv2 = NS_ERROR_FILE_CORRUPTED;
}
PREF_FinalizeParseState(&ps);
return NS_FAILED(rv) ? rv : rv2;
}
boost::shared_ptr<TiXmlDocument> FileRead::readXMLDocument(const std::string& filename)
{
// create and load file
FileRead file(filename);
// thats quite ugly
int fileLength = file.length();
boost::scoped_array<char> fileBuffer(new char[fileLength + 1]);
file.readRawBytes( fileBuffer.get(), fileLength );
// null-terminate
fileBuffer[fileLength] = 0;
// parse file
boost::shared_ptr<TiXmlDocument> xml = boost::shared_ptr<TiXmlDocument> (new TiXmlDocument());
xml->Parse(fileBuffer.get());
/// \todo do error handling here?
return xml;
}
inline std::vector<uint8_t> read_file_binary(const std::string pathToFile)
{
FILE * f = fopen(pathToFile.c_str(), "rb");
if (!f)
throw std::runtime_error("file not found");
fseek(f, 0, SEEK_END);
size_t lengthInBytes = ftell(f);
fseek(f, 0, SEEK_SET);
std::vector<uint8_t> fileBuffer(lengthInBytes);
size_t elementsRead = fread(fileBuffer.data(), 1, lengthInBytes, f);
if (elementsRead == 0 || fileBuffer.size() < 4)
throw std::runtime_error("error reading file or file too small");
fclose(f);
return fileBuffer;
}
RawFile::RawFile(const std::string& name, sfl::AudioCodec *codec, unsigned int sampleRate)
: AudioFile(name), audioCodec_(codec)
{
if (filepath_.empty())
throw AudioFileException("Unable to open audio file: filename is empty");
std::fstream file;
file.open(filepath_.c_str(), std::fstream::in);
if (!file.is_open())
throw AudioFileException("Unable to open audio file");
file.seekg(0, std::ios::end);
size_t length = file.tellg();
file.seekg(0, std::ios::beg);
std::vector<char> fileBuffer(length);
file.read(&fileBuffer[0], length);
file.close();
const unsigned int frameSize = audioCodec_->getFrameSize();
const unsigned int bitrate = audioCodec_->getBitRate() * 1000 / 8;
const unsigned int audioRate = audioCodec_->getClockRate();
const unsigned int encFrameSize = frameSize * bitrate / audioRate;
const unsigned int decodedSize = length * (frameSize / encFrameSize);
SFLDataFormat *monoBuffer = new SFLDataFormat[decodedSize];
SFLDataFormat *bufpos = monoBuffer;
unsigned char *filepos = reinterpret_cast<unsigned char *>(&fileBuffer[0]);
size_ = decodedSize;
while (length >= encFrameSize) {
bufpos += audioCodec_->decode(bufpos, filepos, encFrameSize);
filepos += encFrameSize;
length -= encFrameSize;
}
if (sampleRate == audioRate)
buffer_ = monoBuffer;
else {
double factord = (double) sampleRate / audioRate;
float* floatBufferIn = new float[size_];
int sizeOut = ceil(factord * size_);
src_short_to_float_array(monoBuffer, floatBufferIn, size_);
delete [] monoBuffer;
delete [] buffer_;
buffer_ = new SFLDataFormat[sizeOut];
SRC_DATA src_data;
src_data.data_in = floatBufferIn;
src_data.input_frames = size_;
src_data.output_frames = sizeOut;
src_data.src_ratio = factord;
float* floatBufferOut = new float[sizeOut];
src_data.data_out = floatBufferOut;
src_simple(&src_data, SRC_SINC_BEST_QUALITY, 1);
src_float_to_short_array(floatBufferOut, buffer_, src_data.output_frames_gen);
delete [] floatBufferOut;
delete [] floatBufferIn;
size_ = src_data.output_frames_gen;
}
}
//------------------------------------------------------------------------
bool MaterialTypes::Load()
{
pugi::xml_attribute attrib;
r3dFile* f = r3d_open( MATERIAL_CFG_PATH, "rb" );
if ( ! f )
{
return false;
}
r3dTL::TArray< char > fileBuffer( f->size + 1 );
fread( &fileBuffer[ 0 ], f->size, 1, f );
fileBuffer[ f->size ] = 0;
pugi::xml_document xmlLevelFile;
pugi::xml_parse_result parseResult = xmlLevelFile.load_buffer_inplace( &fileBuffer[0], f->size );
fclose( f );
if( !parseResult )
{
r3dArtBug( "MaterialTypes::Load: Failed to parse %s, error: %s", MATERIAL_CFG_PATH, parseResult.description() );
return false;
}
mEntries.Clear();
mDefaultMaterial.entries.Clear();
mDefaultMaterial.footStepsSound = -1;
pugi::xml_node root = xmlLevelFile.child( "root" );
pugi::xml_node xmlDefDecs = root.child( "def_decals" );
pugi::xml_node xmlDefDec = xmlDefDecs.child( "def_decal" );
while( !xmlDefDec.empty() )
{
DecalMapEntry en;
FillDecalEntry( en, xmlDefDec );
for( uint32_t i = 0, e = mDefaultMaterial.entries.Count(); i < e; i ++ )
{
if( mDefaultMaterial.entries[ i ].SourceNameHash == en.SourceNameHash )
{
r3dError( "MaterialTypes::Load: duplicate default decal with hash '%d'!", en.SourceNameHash );
}
}
mDefaultMaterial.entries.PushBack( en );
xmlDefDec = xmlDefDec.next_sibling();
}
pugi::xml_node xmlTypes = root.child( "types" );
pugi::xml_node xmlType = xmlTypes.child( "type" );
while( !xmlType.empty() )
{
Entry en;
en.name = xmlType.attribute( "name" ).value();
en.nameHash = r3dHash::MakeHash(en.name.c_str());
pugi::xml_node xmlEntry = xmlType.child( "entry" );
while( !xmlEntry.empty() )
{
DecalMapEntry entry;
FillDecalEntry( entry, xmlEntry );
for( uint32_t i = 0, e = en.type.entries.Count(); i < e; i ++ )
{
if( en.type.entries[ i ].SourceNameHash == entry.SourceNameHash )
r3dError( "MaterialTypes::Load: duplicate source with hashID '%d' entries...", entry.SourceNameHash );
}
en.type.entries.PushBack( entry );
xmlEntry = xmlEntry.next_sibling();
}
// Footsteps sound
xmlEntry = xmlType.child("footsteps");
#ifndef WO_SERVER
en.type.footStepsSound = SoundSys.GetEventIDByPath(xmlEntry.attribute("sound").value());
en.type.crouchFootstepsSound = SoundSys.GetEventIDByPath(xmlEntry.attribute("crouch").value());
en.type.proneFootstepsSound = SoundSys.GetEventIDByPath(xmlEntry.attribute("prone").value());
#endif
mEntries.PushBack( en );
xmlType = xmlType.next_sibling();
}
// make a direct array references to impact particle
ImpactParticleEntry::NumRegistered = 0;
FillImpactArray(mDefaultMaterial);
for(uint32_t i = 0; i < mEntries.Count(); i++)
FillImpactArray(mEntries[i].type);
return true;
}
void Project::_saveFile(const Json::Value& fileData)
{
ofBuffer fileBuffer(fileData["fileContents"].asString());
ofBufferToFile(getPath() + "/sketch/" + fileData["fileName"].asString(), fileBuffer);
}
HRESULT ProfileInfo::Read() {
HRESULT hr = S_OK;
LFile profileFile(m_csFilename);
if (!profileFile.Exists())
hr = E_PM_FILE_NOTEXIST;
if (SUCCEEDED(hr)) {
LURESULT lr = profileFile.Open();
if (lr == LFILE_ERR_OPEN || lr == LFILE_ERR_ALREADY_OPEN)
hr = E_PM_FILE_OPEN;
}
if (SUCCEEDED(hr)) {
LBuffer fileBuffer(256);
DWORD dwBytesRead;
CStringW csLine;
UINT uiLinesRead = 0;
// Read BOM (first 2 bytes)
LURESULT lr = profileFile.ReadRaw(&fileBuffer, 0, 2, &dwBytesRead);
if (lr != S_OK)
hr = E_PM_FILE_READ;
bool bFirstBlock = true;
if (SUCCEEDED(hr)) {
do {
lr = profileFile.ReadRaw(&fileBuffer, 0, fileBuffer.GetSize(), &dwBytesRead);
if (lr != S_OK)
hr = E_PM_FILE_READ;
if (SUCCEEDED(hr) && bFirstBlock) {
WCHAR *pIdent = (WCHAR *)fileBuffer.GetBuffer();
if (wcsncmp(pIdent, L"lpp_", 4) != 0)
hr = E_PM_WRONG_FORMAT;
bFirstBlock = false;
}
if (SUCCEEDED(hr)) {
WCHAR *pBuffer = (WCHAR *)fileBuffer.GetBuffer();
UINT dwCharsRead = dwBytesRead / sizeof(WCHAR);
for (int i = 0; i < dwCharsRead; ++i) {
if (pBuffer[i] == L'\n') {
CString csKey;
CString csValue;
//Ignore lines which begins with % or #
if (csLine[0] != L'%' && csLine[0] != L'#') {
int iBlankPos = csLine.Find(L'=');
if (iBlankPos >= 0) {
#ifdef _UNICODE
csKey = csLine.Left(iBlankPos);
csValue = csLine.Right(csLine.GetLength() - (iBlankPos+1));
#else
CStringW csKeyW = csLine.Left(iBlankPos);
int nLen = csKeyW.GetLength();
char *szRet = new char[nLen + 1];
WideCharToMultiByte(CP_ACP, 0, csKeyW, -1,
szRet, nLen + 1, NULL, NULL);
csKey = szRet;
delete szRet;
CStringW csValueW = csLine.Right(csLine.GetLength() - (iBlankPos+1));
nLen = csValueW.GetLength();
szRet = new char[nLen + 1];
WideCharToMultiByte(CP_ACP, 0, csValueW, -1,
szRet, nLen + 1, NULL, NULL);
csValue = szRet;
delete szRet;
#endif
if (csKey == _T("lpp_id")) {
m_iProfileID = _ttoi64((LPCTSTR)csValue);
} else if (csKey == _T("lpp_version")) {
m_iProfileVersion = _ttoi((LPCTSTR)csValue);
} else if (csKey == _T("lpp_title")) {
m_csTitle = csValue;
} else if (csKey == _T("lpp_type")) {
m_iProfileType = _ttoi((LPCTSTR)csValue);
} else {
m_aKeys.Add(csKey);
m_aValues.Add(csValue);
}
}
}
csLine.Empty();
} else {
csLine += pBuffer[i];
}
}
}
} while (dwBytesRead == fileBuffer.GetSize());
}
profileFile.Close();
}
ExtractTargetFormat();
ExtractStorageDistribution();
return hr;
}
