void AppendBinaryFile(const tstring & file, schar * buffer, uint32 size,
DirectoryMode directory)
{
#ifdef ANDROID
bool succesfull = directory != DirectoryMode::assets;
ASSERT(succesfull, _T("Android doesn't support writing to a binary file in the assets directory."));
if(succesfull)
{
auto app = StarEngine::GetInstance()->GetAndroidApp();
sstringstream strstr;
if(directory == DirectoryMode::internal)
{
strstr << app->activity->internalDataPath << "/";
}
else if(directory == DirectoryMode::external)
{
strstr << app->activity->internalDataPath << "/";
}
strstr << string_cast<sstring>(file);
sofstream binary_file(strstr.str(),
std::ios::out | std::ios::binary | std::ios::app);
succesfull = binary_file.is_open();
ASSERT(succesfull, (_T("Couldn't open the binary file '") +
strstr.str() + _T("'.")).c_str());
if (succesfull)
{
for(uint32 i = 0 ; i < size ; ++i)
{
binary_file << buffer[i];
}
binary_file.close();
}
}
#else
tstring file_path(EMPTY_STRING);
Filepath::GetCorrectPath(file, file_path, directory);
sofstream binary_file(file_path,
std::ios::out | std::ios::binary | std::ios::app);
bool succes = binary_file.is_open();
ASSERT(succes, (_T("Couldn't open the binary file '") +
file_path + _T("'.")).c_str());
if (succes)
{
for(uint32 i = 0 ; i < size ; ++i)
{
binary_file << buffer[i];
}
binary_file.close();
}
#endif
}
bool EagleeyeIO::write(const Matrix<T>& mat,std::string id,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case WRITE_BINARY_MODE:
{
std::ofstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//write id
int str_len=id.length();
binary_file.write((char*)(&str_len),sizeof(int));
binary_file.write(id.c_str(),sizeof(char)*str_len);
//write matrix data
int rows=mat.rows();
int cols=mat.cols();
binary_file.write((char*)(&rows),sizeof(int));
binary_file.write((char*)(&cols),sizeof(int));
for (int i=0;i<rows;++i)
{
binary_file.write(mat.row(i),sizeof(T)*cols);
}
binary_file.close();
return true;
}
}
case WRITE_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ofstream asc_file(file_path.c_str());
if (asc_file)
{
asc_file<<id<<'\n';
asc_file<<mat;
asc_file.close();
return true;
}
return false;
}
}
return false;
}
bool EagleeyeIO::write(const DynamicArray<T>& arr,std::string id,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case WRITE_BINARY_MODE:
{
std::ofstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//write id
int str_len=id.length();
binary_file.write((char*)(&str_len),sizeof(int));
binary_file.write(id.c_str(),sizeof(char)*str_len);
//write array data
int arr_size=arr.size();
binary_file.write((char*)(&arr_size),sizeof(int));
binary_file.write((char*)arr.dataptr(),sizeof(T)*arr_size);
binary_file.close();
return true;
}
}
case WRITE_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ofstream asc_file(file_path.c_str());
if (asc_file)
{
asc_file<<id<<'\n';
asc_file<<arr;
asc_file.close();
return true;
}
return false;
}
default:
{
return false;
}
}
return false;
}
bool EagleeyeIO::read(DynamicArray<T>& arr,std::string& id,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case READ_BINARY_MODE:
{
std::ifstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//write id
int str_len;
binary_file.read((char*)(&str_len),sizeof(int));
char* id_data=new char[str_len];
binary_file.read(id_data,sizeof(char)*str_len);
id=std::string(id_data);
delete[] id_data;
//write array data
int arr_size=arr.size();
binary_file.read((char*)(&arr_size),sizeof(int));
arr=DynamicArray(arr_size);
binary_file.read((char*)(arr.dataptr()),sizeof(T)*arr_size);
binary_file.close();
return true;
}
}
case READ_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ifstream ascii_file(file_path.c_str());
file_path>>id;
file_path>>arr;
ascii_file.close();
return false;
}
default:
{
return false;
}
}
return false;
}
bool EagleeyeIO::read(Matrix<T>& mat,std::string& id,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case READ_BINARY_MODE:
{
std::ifstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//write id
int str_len;
binary_file.read((char*)(&str_len),sizeof(int));
char* id_data=new char[str_len];
binary_file.read(id_data,sizeof(char)*str_len);
id=std::string(id_data);
delete[] id_data;
//read mat data
int rows;
int cols;
binary_file.read((char*)(&rows),sizeof(int));
binary_file.read((char*)(&cols),sizeof(int));
mat=Matrix<T>(rows*cols);
binary_file.read((char*)(mat.dataptr()),sizeof(T)*rows*cols);
binary_file.close();
return true;
}
}
case READ_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ifstream ascii_file(file_path.c_str());
ascii_file>>id;
ascii_file>>mat;
ascii_file.close();
return false;
}
}
return false;
}
bool EagleeyeIO::read(DynamicArray<T>& arr,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case READ_BINARY_MODE:
{
std::ifstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//write array data
int arr_size;
binary_file.read((char*)(&arr_size),sizeof(int));
arr=DynamicArray<T>(arr_size);
binary_file.read((char*)(arr.dataptr()),sizeof(T)*arr_size);
binary_file.close();
return true;
}
}
case READ_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ifstream ascii_file(file_path.c_str());
if (!ascii_file)
{
return false;
}
else
{
ascii_file>>arr;
return true;
}
}
default:
{
return false;
}
}
return false;
}
bool EagleeyeIO::read(Matrix<T>& mat,std::string file_path,EagleeyeIOMode iomode)
{
switch(iomode)
{
case READ_BINARY_MODE:
{
std::locale::global(std::locale(""));
std::ifstream binary_file(file_path.c_str(),std::ios::binary);
if (!binary_file)
{
return false;
}
else
{
//read mat data
int rows;
int cols;
binary_file.read((char*)(&rows),sizeof(int));
binary_file.read((char*)(&cols),sizeof(int));
mat=Matrix<T>(rows,cols);
binary_file.read((char*)(mat.dataptr()),sizeof(T)*rows*cols);
binary_file.close();
return true;
}
}
case READ_ASCII_MODE:
{
std::locale::global( std::locale( "",std::locale::all^std::locale::numeric ) );
std::ifstream ascii_file(file_path.c_str());
ascii_file>>mat;
ascii_file.close();
return false;
}
}
return false;
}
void content_manager::load_binary( u32 str_hash, void* ptr, type_name type )
{
if( type == type_name::geometry )
{
crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
CRAP_ASSERT_DEBUG( binary_file.readable(), "Cannot read binary file." );
geometry_content* idx_mem = (geometry_content*) ptr;
u8* buffer = (u8*)_content_pool->allocate( (size_t32)binary_file.size() );
binary_file.read_bytes( buffer, (size_t32)binary_file.size() );
binary_file.close();
u32 offset = 0;
memcpy( &idx_mem->indices_size, buffer + offset, sizeof(u32) );
offset += sizeof(u32);
memcpy( &idx_mem->vertices_size, buffer + offset, sizeof(u32) );
offset += sizeof(u32);
idx_mem->indices = (u16*)_content_pool->allocate(sizeof(u16)*idx_mem->indices_size);
idx_mem->positions = (crap::vector3f*)_content_pool->allocate( sizeof(crap::vector3f)*idx_mem->vertices_size );
idx_mem->uvs = (crap::vector2f*)_content_pool->allocate( sizeof(crap::vector2f)*idx_mem->vertices_size );
idx_mem->normals = (crap::vector3f*)_content_pool->allocate( sizeof(crap::vector3f)*idx_mem->vertices_size );
idx_mem->tangents = (crap::vector3f*)_content_pool->allocate( sizeof(crap::vector3f)*idx_mem->vertices_size );
idx_mem->binormals = (crap::vector3f*)_content_pool->allocate( sizeof(crap::vector3f)*idx_mem->vertices_size );
memcpy( idx_mem->indices, buffer + offset, sizeof(u16)*idx_mem->indices_size );
offset += sizeof(u16)*idx_mem->indices_size;
memcpy( idx_mem->positions, buffer + offset, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( idx_mem->uvs, buffer + offset, sizeof(crap::vector2f)*idx_mem->vertices_size );
offset += sizeof(crap::vector2f)*idx_mem->vertices_size;
memcpy( idx_mem->normals, buffer + offset, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( idx_mem->tangents, buffer + offset, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( idx_mem->binormals, buffer + offset, sizeof(crap::vector3f)*idx_mem->vertices_size );
_content_pool->deallocate( buffer );
return;
}
if( type == type_name::texture )
{
CRAP_ASSERT_ERROR("Not implemented yet");
/*crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
CRAP_ASSERT_DEBUG( binary_file.readable(), "Cannot read binary file." );
texture_content* tex_mem = (texture_content*) ptr;
u8* buffer = (u8*)_content_pool->allocate( (size_t32)binary_file.size() );
binary_file.read_bytes( buffer, (size_t32)binary_file.size() );
binary_file.close();
u32 offset = 0;
memcpy( &tex_mem->width, buffer + offset, sizeof(i32) );
offset += sizeof(i32);
memcpy( &tex_mem->height, buffer + offset, sizeof(i32) );
offset += sizeof(i32);
memcpy( &tex_mem->format, buffer + offset, sizeof(i32) );
offset += sizeof(i32);
memcpy( &tex_mem->bpp, buffer + offset, sizeof(i32) );
offset += sizeof(i32);
tex_mem->data = (u8*)_content_pool->allocate( tex_mem->width * tex_mem->height * tex_mem->bpp );
memcpy( tex_mem->data, buffer + offset, tex_mem->width * tex_mem->height * tex_mem->bpp );
_content_pool->deallocate( buffer );*/
return;
}
if( type == type_name::shader )
{
crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
CRAP_ASSERT_DEBUG( binary_file.readable(), "Cannot read binary file." );
shader_content* sdr_mem = (shader_content*) ptr;
u8* buffer = (u8*)_content_pool->allocate( (size_t32)binary_file.size() );
binary_file.read_bytes( buffer, (size_t32)binary_file.size() );
binary_file.close();
u32 offset = 0;
memcpy( &sdr_mem->size, buffer + offset, sizeof(size_t32) );
offset += sizeof(size_t32);
sdr_mem->data = (c8*)_content_pool->allocate( sdr_mem->size );
memcpy( &sdr_mem->data, buffer + offset, sdr_mem->size );
_content_pool->deallocate( buffer );
return;
}
}
void content_manager::save_binary( u32 str_hash, void* ptr, type_name type )
{
if( type == type_name::geometry )
{
crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
CRAP_ASSERT_DEBUG( binary_file.writeable(), "Cannot wirte binary file." );
geometry_content* idx_mem = (geometry_content*) ptr;
u32 total_size = sizeof(u32)*2 + sizeof(u16)*idx_mem->indices_size +
sizeof(crap::vector3f)*4*idx_mem->vertices_size + sizeof(crap::vector2f)*idx_mem->vertices_size;
u8* buffer = (u8*)_content_pool->allocate( total_size );
u32 offset = 0;
memcpy( buffer + offset, &idx_mem->indices_size, sizeof(u32) );
offset += sizeof(u32);
memcpy( buffer + offset, &idx_mem->vertices_size, sizeof(u32) );
offset += sizeof(u32);
memcpy( buffer + offset, idx_mem->indices, sizeof(u16)*idx_mem->indices_size );
offset += sizeof(u16)*idx_mem->indices_size;
memcpy( buffer + offset, idx_mem->positions, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( buffer + offset, idx_mem->uvs, sizeof(crap::vector2f)*idx_mem->vertices_size );
offset += sizeof(crap::vector2f)*idx_mem->vertices_size;
memcpy( buffer + offset, idx_mem->normals, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( buffer + offset, idx_mem->tangents, sizeof(crap::vector3f)*idx_mem->vertices_size );
offset += sizeof(crap::vector3f)*idx_mem->vertices_size;
memcpy( buffer + offset, idx_mem->binormals, sizeof(crap::vector3f)*idx_mem->vertices_size );
binary_file.write_bytes( buffer, total_size );
binary_file.close();
_content_pool->deallocate( buffer );
return;
}
if( type == type_name::texture )
{
CRAP_ASSERT_ERROR("Not implemented yet");
//crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
//CRAP_ASSERT_DEBUG( binary_file.writeable(), "Cannot wirte binary file." );
//texture_content* tex_mem = (texture_content*) ptr;
//u32 total_size = sizeof(texture_content) + tex_mem->width * tex_mem->height * tex_mem->bpp;
//u8* buffer = (u8*)_content_pool->allocate( total_size );
//u32 offset = 0;
//memcpy( buffer + offset, &tex_mem->width, sizeof(i32) );
//offset += sizeof(i32);
//memcpy( buffer + offset, &tex_mem->height, sizeof(i32) );
//offset += sizeof(i32);
//memcpy( buffer + offset, &tex_mem->format, sizeof(i32) );
//offset += sizeof(i32);
//memcpy( buffer + offset, &tex_mem->bpp, sizeof(i32) );
//offset += sizeof(i32);
//memcpy( buffer + offset, tex_mem->data, tex_mem->width * tex_mem->height * tex_mem->bpp );
//binary_file.write_bytes( buffer, total_size );
//binary_file.close();
//_content_pool->deallocate( buffer );
//return;
}
if( type == type_name::shader )
{
crap::file binary_file( BINARY_PATH + crap::convert<u32, crap::string256>(str_hash) );
CRAP_ASSERT_DEBUG( binary_file.writeable(), "Cannot wirte binary file." );
shader_content* sdr_mem = (shader_content*) ptr;
u32 total_size = sizeof(shader_content) + sdr_mem->size;
u8* buffer = (u8*)_content_pool->allocate( total_size );
u32 offset = 0;
memcpy( buffer + offset, &sdr_mem->size, sizeof(size_t32) );
offset += sizeof(size_t32);
memcpy( buffer + offset, &sdr_mem->data, sdr_mem->size );
binary_file.write_bytes( buffer, total_size );
binary_file.close();
_content_pool->deallocate( buffer );
return;
}
}
void OfficeDriveAPI::updateDaemonCallback(const FB::JSObjectPtr& callback, bool success,
const FB::HeaderMap& headers, const boost::shared_array<uint8_t>& data, const size_t size) {
int ret = -1;
if (success) {
std::string dstr(reinterpret_cast<const char*>(data.get()), size);
// m_host->htmlLog(std::string(headers));
m_host->htmlLog("Downloading new OfficeDriveClient.jar");
char jarFile[512];
memset(&jarFile, 0, sizeof(jarFile));
char * appData;
#ifdef FB_WIN
appData = getenv("LOCALAPPDATA");
sprintf(jarFile, "%s\\OfficeDrive\\OfficeDriveClient.jar", appData);
#endif
#ifdef FB_MACOSX
appData = getenv("HOME");
sprintf(jarFile, "%s/LocalAppData/OfficeDrive/OfficeDriveClient.jar", appData);
/*
char launchAgent[512];
char launchAgent_src[512];
memset(&launchAgent, 0, sizeof(launchAgent));
memset(&launchAgent, 0, sizeof(launchAgent_src));
sprintf(launchAgent, "%s/Library/LaunchAgents/net.officedrive.agent.plist", appData);
sprintf(launchAgent, "%s/LocalAppData/OfficeDrive/net.officedrive.agent.plist", appData);
boost::filesystem::fstream xml_file_in(launchAgent_src ,std::ios::in);
boost::filesystem::fstream xml_file_out(launchAgent ,std::ios::out);
xml_file_out.write(reinterpret_cast<const char*>(xml_file_in.get()), sizeof(xml_file_in));
xml_file_out.close();
xml_file_in.close();
*/
#endif
boost::filesystem::fstream binary_file(jarFile ,std::ios::out|std::ios::binary);
binary_file.write(reinterpret_cast<const char*>(data.get()), size);
binary_file.close();
m_host->htmlLog("Finished downloading: " + std::string(jarFile));
ret = size;
callback->Invoke("",FB::variant_list_of(ret));
//#ifdef FB_MACOSX
// <key>LimitLoadToSessionType</key>
// <string>Aqua</string>
// <key>ProgramArguments</key>
// <array>
// <string>/usr/bin/java</string>
// <string>-jar</string>
// <string>LocalAppData/OfficeDrive/OfficeDriveClient.jar</string>
// </array>
// <key>RunAtLoad</key>
// <true/>
// <key>StartInterval</key>
// <integer>1337</integer>
// <key>StandardErrorPath</key>
// <string>OfficeDriveClient.stderr.log</string>
// <key>StandardOutPath</key>
// <string>OfficeDriveClient.stdout.log</string>
//</dict>
//</plist>
//#endif
//
} else {
callback->Invoke("",FB::variant_list_of(ret));
// The request could not be completed
}
}
