/*
=============
main
=============
*/
int main (int argc, char **argv)
{
if (argc == 1)
{
printf ("qfiles -pak <0 / 1> : build a .pak file\n");
printf ("qfiles -bspmodels : regenerates all brush models\n");
exit (1);
}
SetQdirFromPath ("");
ReadFiles ();
if (!strcmp (argv[1], "-pak"))
{
CopyQFiles (atoi(argv[2]));
}
else if (!strcmp (argv[1], "-bspmodels"))
{
BspModels ();
}
else
Error ("unknown command: %s", argv[1]);
return 0;
}
/*this function starts the first pass procedure*/
void FirstPass(char **files,int filesCount)
{
static int zeroInt;
zeroPointer=&zeroInt;
printf("\nBegining first pass...\r");
FirstPassInitialization(files,filesCount);
ReadFiles(filesCount);
}
/*===========================================================================
*
* Class CSrBsaFolder Method - bool ReadContents (File);
*
*=========================================================================*/
bool CSrBsaFolder::ReadContents (CSrFile& File) {
bool Result;
Result = SrReadBString(m_FolderName, File);
if (!Result) return (false);
Result = ReadFiles(File);
if (!Result) return (false);
return (true);
}
int main(int argc, char *argv[])
{
int w,h;
Rect gb;
HNN=MakeHashTable();
HEL=MakeHashTable();
HLI=MakeHashTable();
HVC=MakeHashTable();
CM=MakeQueueTable();
SetOptions(argc,argv);
ReadFiles(argc,argv);
CheckNodes(HNN,HEL,HLI,HVC);
if( OpCheck )
CheckMore(HNN,HEL,HLI);
InitMinMax(&gb);
GetNodeMinMax(HNN,&gb);
GetNodeMinMax(HVC,&gb);
SetMinMax(&gb);
printf("Min/Max values : %f %f %f %f\n",
gb.low.x,gb.low.y,gb.high.x,gb.high.y);
printf("Center values : %f %f \n",
(gb.low.x+gb.high.x)/2.,(gb.low.y+gb.high.y)/2.);
GbAll = GbPlo = gb;
QGraphInit();
QNewPen(PlotCol);
SetColors(OpCol);
QWindowMaxXY(&w,&h);
ResizeWindow(w,h);
ScaleFactor(HVC);
MakeGridMenu();
/* MouseInit(); */
QInitEvent();
LoopForInput();
QGraphClose();
WriteFiles();
return 0;
}
void sortio_Class::IO_Tasks_Work()
{
assert(initialized_);
int thread_id = omp_get_thread_num();
grvy_printf(INFO,"[sortio]:IO[%i]: thread id for Master thread = %i\n",ioRank_,thread_id);
ReadFiles();
grvy_printf(INFO,"[sortio][IO/Read][%.4i]: ALL DONE with Read\n",ioRank_);
return;
}
//____________________________________________________________________
void WriteNewBias(const char * inputDBName, const char * inputMapName,
const char * previousVoltageFileName, const char * gainFactorFileName,
const char * outputFileName)
{
ofstream outputFile(outputFileName);
ReadFiles(previousVoltageFileName, gainFactorFileName);
SetBiasVoltage(inputDBName, inputMapName);
for (int icol=0; icol<fgkEmCalCols; icol++) {
for (int irow=0; irow<fgkEmCalRows; irow++) {
outputFile << icol << " " << irow << " " << biasVoltage[icol][irow] << endl;
}
}
outputFile.close();
}
///////////////////////////////////////////////////////////////////////////
// C'tor
///////////////////////////////////////////////////////////////////////////
Binpressor::Binpressor(int argc, char* argv[])
{
// Set up console.
SetConsoleTitle("Binpressor");
std::cout << "Binpressor - V" << MAJOR_VERSION << "." << MINOR_VERSION;
#if defined (_WIN64)
std::cout << " - (x64)";
#endif
std::cout << std::endl;
std::cout << "Proprietary binary packaging tool." << std::endl;
std::cout << "Copyright (C) 2012 Johan Rensenbrink." << std::endl;
std::cout << "----------------------------------" << std::endl;
// Grab files and folders.
for(int i = 1; i < argc; i++)
{
if (IsFileOrFolder(argv[i]) == 1)
{
if (boost::filesystem::extension(argv[i]) != ".bin")
m_filePaths.push_back(argv[i]);
else
m_packages.push_back(argv[i]);
}
else if (IsFileOrFolder(argv[i]) == 2)
CollectFilePaths(argv[i]);
}
CollectFileInfo();
Package();
ReadFiles();
Unpackage();
if (!m_filePaths.empty())
PrintFilePaths();
if (!m_descriptors.empty())
PrintFileDescriptors();
}
int main(int argc, char *argv[])
{
Int4 entries;
FL_IOPT opt;
CheckHost();
/* There is a conflict between forms and xew about the meaning of
the arguments: The "-p" option is taken as "-privat" by
fl_initialize(), forcing a private colourmap. This is what we
want anyway, so ok... :-). We just call GetArgs() first, because
fl_initialize() removes the "-p" from argv[] .... */
GetArgs(argc, argv);
/* Force private colourmap (why do I need opt?) */
fl_set_defaults( FL_PDPrivateMap, &opt );
fl_initialize(&argc, argv, "XEw", NULL, 0);
/* Set up our signal handlers */
signal(SIGINT, SigHandler);
signal(SIGTERM, SigHandler);
create_the_forms();
set_object_defaults();
/* load logo */
fl_set_pixmap_data(img_pxm, xew_logo_xpm);
fl_show_form(xew_mainf,FL_PLACE_MOUSE, FL_FULLBORDER, "xew");
entries = ReadFiles();
FillBrowser( entries );
fl_do_forms();
return EXIT_FAILURE ; /* shouldn't be reached */
}
int main(int argc, char *argv[])
{
int ntotal,external;
NodeList hull, intern, boundary, given;
HNN=MakeHashTable();
HEL=MakeHashTable();
HLI=MakeHashTable();
NEL=MakeListTable();
CM=MakeQueueTable();
SetOptions(argc,argv);
ReadFiles(argc,argv);
/* CheckBoundary(); */
ntotal = CheckInput();
hull = MakeNodeList(ntotal);
intern = MakeNodeList(ntotal);
printf("Making convex hull... %d\n",hull->count);
ConvexHull(hull,intern);
/*
CheckConvex(hull,intern);
PrintNodeList("hull",hull);
PrintNodeList("intern",intern);
*/
printf("Making maxi elements...\n");
MakeMaxiTriang(hull);
CheckNeibor(-1);
printf("Inserting convex hull... %d\n",hull->count);
InsertBoundaryNodes(hull);
CheckCircumCircle();
CheckNeibor(-2);
WriteAll("M_hull.grd",hull);
CheckNeibor(-3);
printf("Inserting internal boundary points... %d\n",intern->count);
InsertBoundaryNodes(intern);
CheckCircumCircle();
CheckNeibor(-4);
WriteAll("M_orgbound.grd",NULL);
SetResolution(hull);
CopyBoundaryLine();
printf("Recovering boundary lines 1...\n");
RecoverBoundary();
CheckCircumCircle();
CheckNeibor(-43);
WriteAll("M_bndrecover.grd",NULL);
printf("Refining boundary points 1...\n");
boundary = RefineBoundary();
if( boundary ) {
printf("Inserting new boundary points... %d\n",boundary->count);
InsertBoundaryNodes(boundary);
CheckCircumCircle();
CheckCircumCircleProperty();
CheckNeibor(-5);
}
TestVersion();
printf("Marking external elements...");
external=MarkExternalElements( hull );
printf(" %d / %d\n",external,NTotElems);
WriteGrd("M_finebound.grd");
/*
printf("Marking outer elements...");
external=MarkOuterElements();
printf(" %d / %d\n",external,NTotElems);
WriteGrd("M_test.grd");
*/
FreeNodeList(hull);
FreeNodeList(intern);
FreeNodeList(boundary);
given = GivenNodes();
printf("Inserting internal given points... %d\n",given->count);
InsertNodes(given);
FreeNodeList(given);
CheckCircumCircle();
CheckNeibor(-44);
WriteAll("M_given.grd",NULL);
printf("Recovering boundary lines 2...\n");
RecoverBoundary();
CheckCircumCircle();
CheckNeibor(-45);
WriteAll("M_intrecover.grd",NULL);
CheckArea();
printf("Inserting internal points...\n");
InsertInternalNodes();
CheckCircumCircle();
CheckCircumCircleProperty();
WriteGrd("M_insert.grd");
TestVersion();
CheckArea();
printf("Refining internal points... %f\n",OpAspect);
RefineInternalNodes();
CheckArea();
CheckCircumCircle();
CheckCircumCircleProperty();
WriteGrd("M_refine.grd");
CheckArea();
printf("Recovering boundary lines 3...\n");
RecoverBoundary();
printf("Recovering fault lines...\n");
RecoverInternalFault();
CheckCircumCircle();
CheckNeibor(-48);
WriteAll("M_intrecover2.grd",NULL);
printf("Marking outer elements...");
external=MarkOuterElements();
printf(" %d / %d\n",external,NTotElems);
printf("Marking outer nodes...");
external=MarkOuterNodes();
printf(" %d / %d\n",external,NTotNodes);
WriteGrd("M_test.grd");
TestVersion();
CheckArea();
printf("Smoothing internal points... %f\n",OpSmoothOmega);
SmoothInternalNodes();
CheckArea();
WriteGrd("final.grd");
return 0;
}
int main(int argc,char *argv[])
{
LALFrStreamPos pos;
int i,j,k;
if (ReadCommandLine(argc,argv,&CommandLineArgs)) return 1;
if (ReadFiles(CommandLineArgs)) return 3;
if (GetChannelNames(CommandLineArgs)) return 4;
for(i=0;i<numsegs;i++)
{
for(j=0;j<SL[i].nseg;j++)
{
REAL4 magexc, magdarm, magasq;
REAL8 t=SL[i].tgps+j*SL[i].seglength;
FloatToTime(&epoch, &t);
LALFrSeek(&status,&epoch,framestream);
LALFrGetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&exc,&chanin_exc,framestream);
LALFrSetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&darm,&chanin_darm,framestream);
LALFrSetPos(&status,&pos,framestream);
LALFrGetREAL4TimeSeries(&status,&asq,&chanin_asq,framestream);
LALFrSetPos(&status,&pos,framestream);
/*Windowing*/
for(k=0;k<(INT4)(SL[i].seglength/asq.deltaT +0.5);k++)
{
asq.data->data[k] *= 2.0*asqwin->data[k];
}
for(k=0;k<(INT4)(SL[i].seglength/darm.deltaT +0.5);k++)
{
darm.data->data[k] *= 2.0*darmwin->data[k];
}
for(k=0;k<(INT4)(SL[i].seglength/exc.deltaT +0.5);k++)
{
exc.data->data[k] *= 2.0*excwin->data[k];
}
/* set params to call LALComputeCalibrationFactors */
params.darmCtrl = &darm;
params.asQ = &asq;
params.exc = &exc;
params.lineFrequency = CommandLineArgs.f;
params.outputMatrix = CommandLineArgs.k;
params.actuationFactor.re = Af0.re/4000.0; /*ACHTUNG: HARDWIRED !!*/
params.actuationFactor.im = Af0.im/4000.0; /*ACHTUNG: HARDWIRED !!*/
params.responseFactor = Rf0;
params.sensingFactor = Cf0;
LALComputeCalibrationFactors(&status,&factors,¶ms);
magexc=sqrt(factors.exc.re*factors.exc.re+factors.exc.im*factors.exc.im)*2/SL[i].seglength;
magasq=sqrt(factors.asq.re*factors.asq.re+factors.asq.im*factors.asq.im)*2/SL[i].seglength;
magdarm=sqrt(factors.darm.re*factors.darm.re+factors.darm.im*factors.darm.im)*2/SL[i].seglength;
fprintf(stdout,"%20.15f %20.15f %20.15f %20.15f %20.15f %20.15f %20.15f %20.15f\n",t,
factors.alpha.re,factors.alpha.im,factors.alphabeta.re,
factors.alphabeta.im,magexc,magdarm,magasq);
fflush(stdout);
}
}
if(FreeMem()) return 4;
return 0;
}
// called from ---GUI--- thread
bool NetPlayServer::SyncSaveData()
{
m_save_data_synced_players = 0;
u8 save_count = 0;
constexpr size_t exi_device_count = 2;
for (size_t i = 0; i < exi_device_count; i++)
{
if (m_settings.m_EXIDevice[i] == ExpansionInterface::EXIDEVICE_MEMORYCARD ||
SConfig::GetInstance().m_EXIDevice[i] == ExpansionInterface::EXIDEVICE_MEMORYCARDFOLDER)
{
save_count++;
}
}
const auto game = m_dialog->FindGameFile(m_selected_game);
if (game == nullptr)
{
PanicAlertT("Selected game doesn't exist in game list!");
return false;
}
bool wii_save = false;
if (m_settings.m_CopyWiiSave && (game->GetPlatform() == DiscIO::Platform::WiiDisc ||
game->GetPlatform() == DiscIO::Platform::WiiWAD))
{
wii_save = true;
save_count++;
}
{
sf::Packet pac;
pac << static_cast<MessageId>(NP_MSG_SYNC_SAVE_DATA);
pac << static_cast<MessageId>(SYNC_SAVE_DATA_NOTIFY);
pac << save_count;
SendAsyncToClients(std::move(pac));
}
if (save_count == 0)
return true;
const std::string region =
SConfig::GetDirectoryForRegion(SConfig::ToGameCubeRegion(game->GetRegion()));
for (size_t i = 0; i < exi_device_count; i++)
{
const bool is_slot_a = i == 0;
if (m_settings.m_EXIDevice[i] == ExpansionInterface::EXIDEVICE_MEMORYCARD)
{
std::string path = is_slot_a ? Config::Get(Config::MAIN_MEMCARD_A_PATH) :
Config::Get(Config::MAIN_MEMCARD_B_PATH);
MemoryCard::CheckPath(path, region, is_slot_a);
bool mc251;
IniFile gameIni = SConfig::LoadGameIni(game->GetGameID(), game->GetRevision());
gameIni.GetOrCreateSection("Core")->Get("MemoryCard251", &mc251, false);
if (mc251)
path.insert(path.find_last_of('.'), ".251");
sf::Packet pac;
pac << static_cast<MessageId>(NP_MSG_SYNC_SAVE_DATA);
pac << static_cast<MessageId>(SYNC_SAVE_DATA_RAW);
pac << is_slot_a << region << mc251;
if (File::Exists(path))
{
if (!CompressFileIntoPacket(path, pac))
return false;
}
else
{
// No file, so we'll say the size is 0
pac << sf::Uint64{0};
}
SendAsyncToClients(std::move(pac));
}
else if (SConfig::GetInstance().m_EXIDevice[i] ==
ExpansionInterface::EXIDEVICE_MEMORYCARDFOLDER)
{
const std::string path = File::GetUserPath(D_GCUSER_IDX) + region + DIR_SEP +
StringFromFormat("Card %c", is_slot_a ? 'A' : 'B');
sf::Packet pac;
pac << static_cast<MessageId>(NP_MSG_SYNC_SAVE_DATA);
pac << static_cast<MessageId>(SYNC_SAVE_DATA_GCI);
pac << is_slot_a;
if (File::IsDirectory(path))
{
std::vector<std::string> files =
GCMemcardDirectory::GetFileNamesForGameID(path + DIR_SEP, game->GetGameID());
pac << static_cast<u8>(files.size());
for (const std::string& file : files)
{
pac << file.substr(file.find_last_of('/') + 1);
if (!CompressFileIntoPacket(file, pac))
return false;
}
}
else
{
pac << static_cast<u8>(0);
}
SendAsyncToClients(std::move(pac));
}
}
if (wii_save)
{
const auto configured_fs = IOS::HLE::FS::MakeFileSystem(IOS::HLE::FS::Location::Configured);
const auto save = WiiSave::MakeNandStorage(configured_fs.get(), game->GetTitleID());
sf::Packet pac;
pac << static_cast<MessageId>(NP_MSG_SYNC_SAVE_DATA);
pac << static_cast<MessageId>(SYNC_SAVE_DATA_WII);
if (save->SaveExists())
{
const std::optional<WiiSave::Header> header = save->ReadHeader();
const std::optional<WiiSave::BkHeader> bk_header = save->ReadBkHeader();
const std::optional<std::vector<WiiSave::Storage::SaveFile>> files = save->ReadFiles();
if (!header || !bk_header || !files)
return false;
pac << true; // save exists
// Header
pac << sf::Uint64{header->tid};
pac << header->banner_size << header->permissions << header->unk1;
for (size_t i = 0; i < header->md5.size(); i++)
pac << header->md5[i];
pac << header->unk2;
for (size_t i = 0; i < header->banner_size; i++)
pac << header->banner[i];
// BkHeader
pac << bk_header->size << bk_header->magic << bk_header->ngid << bk_header->number_of_files
<< bk_header->size_of_files << bk_header->unk1 << bk_header->unk2
<< bk_header->total_size;
for (size_t i = 0; i < bk_header->unk3.size(); i++)
pac << bk_header->unk3[i];
pac << sf::Uint64{bk_header->tid};
for (size_t i = 0; i < bk_header->mac_address.size(); i++)
pac << bk_header->mac_address[i];
// Files
for (const WiiSave::Storage::SaveFile& file : *files)
{
pac << file.mode << file.attributes << static_cast<u8>(file.type) << file.path;
if (file.type == WiiSave::Storage::SaveFile::Type::File)
{
const std::optional<std::vector<u8>>& data = *file.data;
if (!data || !CompressBufferIntoPacket(*data, pac))
return false;
}
}
}
else
{
pac << false; // save does not exist
}
SendAsyncToClients(std::move(pac));
}
return true;
}
