bool decompose(const QString &source, QString &name, std::vector<std::string> *args) {
QString arg;
int count = 0;
int pos = 0, begin = 0, end;
int brack = 0;
bool valid = true;
args->clear();
while (pos < source.size() && valid) {
if (source.at(pos).toLatin1() == '(') brack++;
if (source.at(pos).toLatin1() == ')') brack--;
if (source.at(pos).toLatin1() == ',' && brack == 0) {
end = pos - begin;
if (count == 0) {
name = source.left(end);
killEmptyEnds(name);
}
else {
arg = source.mid(begin,end);
valid = valid && checkArg(arg);
args->push_back(arg.toUtf8().constData());
}
count++;
begin = pos + 1;
}
pos++;
}
if (count == 0) name = source.left(end);
else {
arg = source.mid(begin,end);
valid = valid && checkArg(arg);
args->push_back(arg.toUtf8().constData());
}
return valid;
}
/// set_device_specs - tcl command to add device information
int set_device_specs(ClientData clientData, Tcl_Interp *interp, int
argc, const char *argv[]) {
static char error[100];
if (argc != 13) {
sprintf(error, "%s", "Expecting 13 arguments.");
interp->result = error;
return(TCL_ERROR);
}
LegupConfig *config = (LegupConfig*)clientData;
if (!checkArg(argv, 2, "-Family", error) ||
!checkArg(argv, 4, "-Device", error) ||
!checkArg2(argv, 6, "-MaxLEs", "-MaxALMs", error) ||
!checkArg2(argv, 8, "-MaxM4Ks", "-MaxM9KMemBlocks", error) ||
!checkArg(argv, 10, "-MaxRAMBits", error) ||
!checkArg(argv, 12, "-MaxDSPs", error))
{
interp->result = error;
return(TCL_ERROR);
}
int MaxLEs = atoi(argv[6]);
int MaxM4Ks = atoi(argv[8]);
int MaxRAMBits = atoi(argv[10]);
int MaxDSPs = atoi(argv[12]);
config->setDeviceSpecs(argv[2], argv[4], MaxLEs, MaxM4Ks, MaxRAMBits, MaxDSPs);
return(TCL_OK);
}
int emuCheckResetArgument(char* cmdLine) {
int i;
char* argument;
for (i = 0; (argument = extractToken(cmdLine, i)) != NULL; i++) {
if (checkArg(argument, "reset")) {
return 1;
}
if (checkArg(argument, "resetregs")) {
return 2;
}
}
return 0;
}
/// loop_pipeline - tcl command to pipeline a loop. Example:
/// loop_pipeline "loop" -ii 1
/// the ii is optional and specifies an pipeline initiation interval
int loop_pipeline(ClientData clientData, Tcl_Interp *interp, int argc, const
char *argv[]) {
static char error[100];
if (argc != 2 && argc != 4) {
static char error[] = "wrong # args: should be "
"\"loop_pipeline \"loop\" [ -ii 1 ]\"";
interp->result = error;
assert(0);
return(TCL_ERROR);
}
// check arguments are correct
bool user_II = false;
int II = 0;
if (argc == 4) {
if (!checkArg(argv, 3, "-ii", error)) {
interp->result = error;
return(TCL_ERROR);
}
user_II = true;
II = atoi(argv[3]);
assert(II >= 0 && "Initiation interval must be non-negative");
}
const char *label = argv[1];
LegupConfig *config = (LegupConfig*)clientData;
config->addLoopPipeline(label, user_II, II);
return(TCL_OK);
}
int lh_saveimage(lua_State *L) {
checkArg(L, 2, "saveimage");
Image *o = luaO(1, Image);
if(useGL(o)) screenshotGL(luaStr(2));
else SDL_SaveBMP(o->s, luaStr(2));
return 0;
}
int lh_internal(lua_State *L) {
checkArg(L, 3, "internal");
P = new InternalProcess(luaO(1, Screen), luaO(2, Font), luaStr(3));
return retObjectEv(L, P);
}
std::string CommandParser::getArg(const std::string& f_arg,
const std::string& defaultVal,
const std::string& description)
{
std::vector<std::string> names;
tokenize(f_arg,names,",;:");
std::vector<std::string>::const_iterator namesIter = names.begin();
std::string found = (*(names.begin()));
for (;namesIter!=names.end();++namesIter) {
argIter_ = argMap_.find((*namesIter));
if(argIter_ != argMap_.end() ) {
found = (*namesIter);
}
}
checkArg(found,defaultVal,description);
requestedArgs_.push_back((*(names.begin())));
argIter_ = argMap_.find(found);
for (namesIter = names.begin();namesIter!=names.end();++namesIter) {
argIter_->second->addAlt(*namesIter);
if (found.compare((*namesIter)) != 0) {
argMap_.insert(std::pair<std::string,ArgInfo*>
((*namesIter),argIter_->second));
}
}
return argIter_->second->value;
}
int lh_hydrainfo(lua_State *L) {
checkArg(L, 2, "hydramap");
int x = luaInt(1);
int y = luaInt(2);
helpAbout(x, y);
return 0;
}
int lh_hydracache(lua_State *L) {
checkArg(L, 2, "hydracache");
int id = luaInt(1);
int val = luaInt(2);
cacheMap(id, val);
return 1;
}
int lh_imggetsize(lua_State *L) {
checkArg(L, 1, "imggetsize");
Image *img = luaO(1, Image);
lua_newtable(L);
setfield(L, "x", img->s->w);
setfield(L, "y", img->s->h);
return 1;
}
int lh_hydramap(lua_State *L) {
checkArg(L, 3, "hydramap");
int x = luaInt(1);
int y = luaInt(2);
int m = luaInt(3);
drawMapLua(L, x, y, m);
return 1;
}
int lh_isosizes(lua_State *L) {
checkArg(L, 1, "isosizes");
IsoParam *P = luaO(1, IsoParam);
lua_newtable(L);
setfield(L, "floor", P->floor);
setfield(L, "x", P->sx);
setfield(L, "y", P->sy);
return 1;
}
int lh_logopen(lua_State *L) {
checkArg(L, 1, "argv");
logfile && logfile != stdin && fclose(logfile);
const char *buf = luaStr(1);
if(strcmp(buf, "-") == 0) logfile = stdout;
else logfile = fopen(buf, "wt");
errfile = logfile;
return 0;
}
std::pair<T, bool> checkArg(int i, Checker checker, Accessor acc) const
{
if (!checkArg(i, checker))
{
return std::make_pair(T(), false);
}
return std::make_pair((this->*acc)(i), true);
}
// Command line parser
int parseCmdLine(int argc, char *argv[], const char *optString, struct arguments *arguments){
int status = 0;
int c=0;
while (c != -1) {
c=getopt(argc,argv,optString);
switch(c){
case 'd':
arguments->scale=true;
sscanf(optarg,"%lf:%lf",&(arguments->dMin),&(arguments->dMax));
break;
case 's':
arguments->resize=true;
sscanf(optarg,"%i:%i",&(arguments->NX),&(arguments->NY));
if (checkUserSize(arguments)) return 1;
break;
case 'f':
arguments->fpsU=true;
sscanf(optarg,"%i",&(arguments->fps));
break;
case 'h':
arguments->hFlag=true;
printHelp(argv[0]);
break;
case '?':
if (optopt == 'd' || optopt == 's' || optopt == 'f'){
fprintf(stderr,"\033[31mOption %c requires an arguments.\033[0m\n",optopt);
return 1;
} else if (isprint(optopt)){
fprintf(stderr,"\033[31mUnknown options -%c.\033[0m\n",optopt);
return 1;
} else {
fprintf(stderr,"\033[31mUnknown option Character '\\x%x'.\033[0m\n",optopt);
return 1;
}
break;
// default:
// printUsage(argv[0]);
// return 1;
}
}
if (arguments->hFlag) return 1;
if (c == -1 && optind != argc-1) {
arguments->argInd=optind;
if (checkArg(argv[optind])){
arguments->output=argv[optind];
arguments->itStart=optind+1;
return 0;
} else {
return 1;
}
} else {
return c;
}
}
int lh_delete(lua_State *L) {
checkArg(L, 1, "delete");
int i = luaInt(1);
if(i < 0 || i > size(objs)) {
noteyeError(17, "delete: no such object", NULL, i);
return 0;
}
deleteobj(i); // todo: reuse this index?
return 0;
}
int lh_sethydrabox(lua_State *L) {
checkArg(L, 2, "sethydrabox");
extern SDL_Surface *hydrabox, *hydraheads;
extern int *hydraboxc;
Image *I1 = luaO(1, Image);
Image *I2 = luaO(2, Image);
hydrabox = I1->s;
hydraheads = I2->s;
hydraboxc = &I1->changes;
return 0;
}
int lh_hydramain(lua_State *L) {
checkArg(L, 2, "hydramain");
InternalProcess *P = luaO(1, InternalProcess);
noteye_setinternal(P, L, 2);
P->exitcode = hydraMain(gargc, gargv);
P->isActive = false;
return 0;
}
int lh_getpixel(lua_State *L) {
checkArg(L, 3, "getpixel");
Image *srcI = luaO(1, Image);
int srcX = luaInt(2);
int srcY = luaInt(3);
#ifdef OPENGL
if(useGL(srcI)) return retInt(L, getpixelGL(srcX, srcY));
#endif
srcI->setLock(true);
int res = qpixel(srcI->s, srcX, srcY);
return retInt(L, res);
}
int lh_isoparam(lua_State *L) {
checkArg(L, 4, "isoparam");
IsoParam *P = new IsoParam;
P->floor = luaInt(1);
P->wall = luaInt(2);
P->icon = luaInt(3);
P->iconh = luaInt(4);
P->build();
return retObject(L, P);
}
bool decompose(const QString &source, std::vector<std::string> &args) {
QString midString;
int pos = 0, begin = 0, end;
int brack = 0;
bool valid = true;
args.clear();
while (pos < source.size() && valid) {
if (source.at(pos).toLatin1() == '(') brack++;
if (source.at(pos).toLatin1() == ')') brack--;
if (source.at(pos).toLatin1() == ',' && brack == 0) {
end = pos - begin;
midString = source.mid(begin,end);
valid = valid && checkArg(midString);
args.push_back(midString.toUtf8().constData());
begin = pos + 1;
}
pos++;
}
midString = source.mid(begin,end);
valid = valid && checkArg(midString);
args.push_back(midString.toUtf8().constData());
return valid;
}
int lh_setfont(lua_State *L) {
checkArg(L, 2, "setfont");
Font *f = luaO(2, Font);
Process *p = dluaO(1, Process);
if(p) {
p->f = f;
}
Screen *s= p ? p->s : dluaO(1, Screen);
if(s) {
for(int y=0; y<s->sx * s->sy; y++)
s->v[y] = tileSetFont(s->v[y], f);
}
Tile *t = dluaO(1, Tile);
if(t) return retInt(L, tileSetFont(t->id, f));
return 0;
}
int lh_setpixel(lua_State *L) {
checkArg(L, 4, "setpixel");
Image *srcI = luaO(1, Image);
int srcX = luaInt(2);
int srcY = luaInt(3);
#ifdef OPENGL
if(useGL(srcI)) return 0;
#endif
srcI->setLock(true);
qpixel(srcI->s, srcX, srcY) = luaInt(4);
srcI->changes++;
return 0;
}
int lh_fillimage(lua_State *L) {
checkArg(L, 6, "fillimage");
SDL_Rect rect;
rect.x = luaInt(2);
rect.y = luaInt(3);
rect.w = luaInt(4);
rect.h = luaInt(5);
int col = luaInt(6);
Image *img = luaO(1,Image);
#ifdef OPENGL
if(useGL(img)) fillRectGL(rect.x, rect.y, rect.w, rect.h, col); else
#endif
SDL_FillRect(img->s, &rect, col);
img->changes++;
return 0;
}
void emuCheckFullscreenArgument(Properties* properties, char* cmdLine){
int i;
char* argument;
if (NULL == extractToken(cmdLine, 0)) {
return;
}
// properties->video.windowSize = P_VIDEO_SIZEX2;
for (i = 0; (argument = extractToken(cmdLine, i)) != NULL; i++) {
if (checkArg(argument, "fullscreen")) {
properties->video.windowSize = P_VIDEO_SIZEFULLSCREEN;
}
}
}
int lh_iso(lua_State *L) {
checkArg(L, 2, "isoproject");
IsoParam *P = luaO(2, IsoParam);
int t0;
int ti = luaInt(1);
t0 = addFreeform(distill(ti, spIFloor), P->Floor);
t0 = addMerge(t0, addFreeform(addRecolor(distill(ti, spIWallL), 0xFF808080, recMult), P->WalL), false);
t0 = addMerge(t0, addFreeform(addRecolor(distill(ti, spIWallR), 0xFFC0C0C0, recMult), P->WalR), false);
//t0 = addMerge(t0, addFreeform(distill(ti, spIWallL), P->WalL), false);
//t0 = addMerge(t0, addFreeform(distill(ti, spIWallR), P->WalR), false);
t0 = addMerge(t0, addFreeform(distill(ti, spICeil), P->Ceil), false);
t0 = addMerge(t0, addFreeform(distill(ti, spIItem), P->Item), false);
return retInt(L, t0);
// return retInt(L, renderAsIso(luaInt(1), spIFloor | spIItem | spIWallL | spIWallR | spICeil, luaO(2, IsoParam)));
}
char* emuCheckThemeArgument(char* cmdLine){
static char themeName[PROP_MAXPATH];
int i;
char* argument;
themeName[0] = 0;
for (i = 0; (argument = extractToken(cmdLine, i)) != NULL; i++) {
if (checkArg(argument, "theme")) {
argument = extractToken(cmdLine, i + 1);
if (argument != NULL) {
strcat(themeName, argument);
}
return themeName;
}
}
return NULL;
}
/// set_operation_attributes - tcl command to add hardware operation data
int set_operation_attributes(ClientData clientData, Tcl_Interp *interp, int
argc, const char *argv[]) {
static char error[100];
if (argc != 21) {
sprintf(error, "%s", "Expecting 21 arguments.");
interp->result = error;
return(TCL_ERROR);
}
LegupConfig *config = (LegupConfig*)clientData;
// check arguments are correct
if (!checkArg(argv, 2, "-Name", error) ||
!checkArg(argv, 4, "-Fmax", error) ||
!checkArg(argv, 6, "-CritDelay", error) ||
!checkArg(argv, 8, "-StaticPower", error) ||
!checkArg(argv, 10, "-DynamicPower", error) ||
!checkArg2(argv, 12, "-LUTs", "-ALUTs", error) ||
!checkArg(argv, 14, "-Registers", error) ||
!checkArg2(argv, 16, "-LEs", "-ALMs", error) ||
!checkArg(argv, 18, "-DSP", error) ||
!checkArg(argv, 20, "-Latency", error))
{
interp->result = error;
return(TCL_ERROR);
}
float FMax=atof(argv[4]);
float CritDelay=atof(argv[6]);
float StaticPower=atof(argv[8]);
float DynamicPower=atof(argv[10]);
int LUTs=atoi(argv[12]);
int Registers=atoi(argv[14]);
int LogicElements=atoi(argv[16]);
int DSPElements=atoi(argv[18]);
int Latency=atoi(argv[20]);
config->addOperation(argv[2], FMax, CritDelay, StaticPower, DynamicPower,
LUTs, Registers, LogicElements, DSPElements, Latency);
return(TCL_OK);
}
int lh_imgcopy(lua_State *L) {
checkArg(L, 8, "fillimage");
Image *srcI = luaO(1, Image);
int srcX = luaInt(2);
int srcY = luaInt(3);
Image *tgtI = luaO(4, Image);
int tgtX = luaInt(5);
int tgtY = luaInt(6);
int six = luaInt(7);
int siy = luaInt(8);
srcI->setLock(false);
tgtI->setLock(false);
SDL_Rect srcR; srcR.x = srcX; srcR.y = srcY; srcR.w = six; srcR.h = siy;
SDL_Rect tgtR; tgtR.x = tgtX; tgtR.y = tgtY;
SDL_BlitSurface(srcI->s, &srcR, tgtI->s, &tgtR);
tgtI->changes++;
return 0;
}
int main(int argc, char** argv)
{
#if 0
testRandomShit();
exit(1);
#endif
int index = checkArg(argc, argv, "-w");
if(index && index < argc-1){
WIDTH = std::stoi(argv[index+1]);
}
index = checkArg(argc, argv, "-h");
if(index && index < argc-1){
HEIGHT = std::stoi(argv[index+1]);
}
Window win(TITLE, WIDTH, HEIGHT);
win.setClearColor(0.01f, 0.01f, 0.2f, 1.f);
win.setVSync(VSYNC_MODE::OFF);
myCheckForGlErrors(); // some casual error lmao
index = checkArg(argc, argv, "-full_screen");
if(index){
win.setVideoMode(VIDEO_MODE::FULLSCREEN_DESKTOP);
glViewport(0, 0, win.getWidth(), win.getHeight());
}
index = checkArg(argc, argv, "-tick_rate");
if(index && index < argc-1){
TICK_RATE = std::stoi(argv[index+1]);
}
printf("\tUsing glew %s\n", glewGetString(GLEW_VERSION));
printf("\tVendor: %s\n", glGetString (GL_VENDOR));
printf("\tRenderer: %s\n", glGetString (GL_RENDERER));
printf("\tVersion: %s\n", glGetString (GL_VERSION));
printf("\tGLSL: %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION));
printf("%s %d %d\n", win.getTitle(), win.getWidth(), win.getHeight());
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallbackARB(myErrorCallback, nullptr);
GameState game;
Graphics graphics;
Time dt = Time::seconds(1.f/TICK_RATE);
Time accumulator = Time::zero();
Time accum_time = Time::zero();
u32 frames = 0;
Clock perf_clock;
Clock clk;
game.init();
game.win = &win;
graphics.init();
perf_clock.restart();
clk.restart();
while(game.running){
accumulator = clk.time();
if(accumulator.microseconds() >= dt.microseconds()){
accum_time += clk.restart();
tick(&game, dt);
win.clear();
draw(&graphics, &game);
win.update();
accumulator -= dt;
++frames;
}else{
SDL_Delay((dt-accumulator).milliseconds());
}
if(perf_clock.time().seconds() > 1.f){
Time avg_time = accum_time/frames;
char title[128];
sprintf(title, "Game time: %.2fs\tAverage frame took %ldus\tFPS: %d",
game.game_time.seconds(), avg_time.microseconds(), frames);
win.setTitle(title);
accum_time = Time::zero();
frames = 0;
perf_clock.restart();
}
}
game.quit();
graphics.uninit();
}
