Mercurial > vba-linux

annotate src/common/lua-engine.cpp @ 19:5e8e5083da94

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
brought in common and gba, fixed problems with outdated Makefile.am files in both of these packages
author Robert McIntyre <rlm@mit.edu>
date Sun, 04 Mar 2012 14:33:52 -0600
parents f9f4f1b99eed
children bf9169ad4222
rev   line source
rlm@1 1 #include <cstdio>
rlm@1 2 #include <cstdlib>
rlm@1 3 #include <malloc.h>
rlm@1 4 #include <string>
rlm@1 5 #include <cassert>
rlm@1 6 #include <cctype>
rlm@1 7 #include <cmath>
rlm@1 8 #include <ctime>
rlm@1 9
rlm@1 10 #include <vector>
rlm@1 11 #include <map>
rlm@1 12 #include <string>
rlm@1 13 #include <algorithm>
rlm@1 14
rlm@1 15 using namespace std;
rlm@1 16
rlm@1 17 #ifdef __linux
rlm@1 18 #include <unistd.h> // for unlink
rlm@1 19 #include <sys/types.h>
rlm@1 20 #include <sys/wait.h>
rlm@1 21 #endif
rlm@1 22 #if (defined(WIN32) && !defined(SDL))
rlm@1 23 #include <direct.h>
rlm@1 24 #include "../win32/stdafx.h"
rlm@1 25 #include "../win32/Input.h"
rlm@1 26 #include "../win32/MainWnd.h"
rlm@1 27 #include "../win32/VBA.h"
rlm@1 28 #include "../win32/LuaOpenDialog.h"
rlm@1 29 #else
rlm@1 30 #define stricmp strcasecmp
rlm@1 31 #define strnicmp strncasecmp
rlm@1 32 #endif
rlm@1 33
rlm@1 34 #include "../Port.h"
rlm@1 35 #include "System.h"
rlm@1 36 #include "movie.h"
rlm@1 37 #include "../gba/GBA.h"
rlm@1 38 #include "../gba/GBAGlobals.h"
rlm@1 39 #include "../gb/GB.h"
rlm@1 40 #include "../gb/gbGlobals.h"
rlm@1 41 #include "../gba/GBASound.h"
rlm@1 42
rlm@1 43 #ifdef _WIN32
rlm@1 44 #include "../win32/Sound.h"
rlm@1 45 //#include "../win32/WinMiscUtil.h"
rlm@1 46 extern CString winGetSavestateFilename(const CString &LogicalRomName, int nID);
rlm@1 47 #else
rlm@1 48 #endif
rlm@1 49
rlm@1 50 extern "C"
rlm@1 51 {
rlm@1 52 #include "../lua/src/lua.h"
rlm@1 53 #include "../lua/src/lauxlib.h"
rlm@1 54 #include "../lua/src/lualib.h"
rlm@1 55 #include "../lua/src/lstate.h"
rlm@1 56 }
rlm@1 57 #include "vbalua.h"
rlm@1 58
rlm@1 59 #include "../SFMT/SFMT.c"
rlm@1 60
rlm@1 61 static void (*info_print)(int uid, const char *str);
rlm@1 62 static void (*info_onstart)(int uid);
rlm@1 63 static void (*info_onstop)(int uid);
rlm@1 64 static int info_uid;
rlm@1 65
rlm@1 66 #ifndef countof
rlm@1 67 #define countof(a) (sizeof(a) / sizeof(a[0]))
rlm@1 68 #endif
rlm@1 69
rlm@1 70 static lua_State *LUA;
rlm@1 71
rlm@1 72 // Are we running any code right now?
rlm@1 73 static char *luaScriptName = NULL;
rlm@1 74
rlm@1 75 // Are we running any code right now?
rlm@1 76 static bool8 luaRunning = false;
rlm@1 77
rlm@1 78 // True at the frame boundary, false otherwise.
rlm@1 79 static bool8 frameBoundary = false;
rlm@1 80
rlm@1 81 // The execution speed we're running at.
rlm@1 82 static enum { SPEED_NORMAL, SPEED_NOTHROTTLE, SPEED_TURBO, SPEED_MAXIMUM } speedmode = SPEED_NORMAL;
rlm@1 83
rlm@1 84 // Rerecord count skip mode
rlm@1 85 static bool8 skipRerecords = false;
rlm@1 86
rlm@1 87 // Used by the registry to find our functions
rlm@1 88 static const char *frameAdvanceThread = "VBA.FrameAdvance";
rlm@1 89 static const char *guiCallbackTable = "VBA.GUI";
rlm@1 90
rlm@1 91 // True if there's a thread waiting to run after a run of frame-advance.
rlm@1 92 static bool8 frameAdvanceWaiting = false;
rlm@1 93
rlm@1 94 // We save our pause status in the case of a natural death.
rlm@1 95 //static bool8 wasPaused = false;
rlm@1 96
rlm@1 97 // Transparency strength. 255=opaque, 0=so transparent it's invisible
rlm@1 98 static int transparencyModifier = 255;
rlm@1 99
rlm@1 100 // Our joypads.
rlm@1 101 static uint32 lua_joypads[4];
rlm@1 102 static uint8 lua_joypads_used = 0;
rlm@1 103
rlm@1 104 static bool8 gui_used = false;
rlm@1 105 static uint8 *gui_data = NULL; // BGRA
rlm@1 106
rlm@1 107 // Protects Lua calls from going nuts.
rlm@1 108 // We set this to a big number like 1000 and decrement it
rlm@1 109 // over time. The script gets knifed once this reaches zero.
rlm@1 110 static int numTries;
rlm@1 111
rlm@1 112 // number of registered memory functions (1 per hooked byte)
rlm@1 113 static unsigned int numMemHooks;
rlm@1 114
rlm@1 115 // Look in inputglobal.h for macros named like BUTTON_MASK_UP to determine the order.
rlm@1 116 static const char *button_mappings[] = {
rlm@1 117 "A", "B", "select", "start", "right", "left", "up", "down", "R", "L"
rlm@1 118 };
rlm@1 119
rlm@1 120 #ifdef _MSC_VER
rlm@1 121 #define snprintf _snprintf
rlm@1 122 #define vscprintf _vscprintf
rlm@1 123 #else
rlm@1 124 #define stricmp strcasecmp
rlm@1 125 #define strnicmp strncasecmp
rlm@1 126 #define __forceinline __attribute__((always_inline))
rlm@1 127 #endif
rlm@1 128
rlm@1 129 static const char *luaCallIDStrings[] =
rlm@1 130 {
rlm@1 131 "CALL_BEFOREEMULATION",
rlm@1 132 "CALL_AFTEREMULATION",
rlm@1 133 "CALL_BEFOREEXIT"
rlm@1 134 };
rlm@1 135
rlm@1 136 //make sure we have the right number of strings
rlm@1 137 CTASSERT(sizeof(luaCallIDStrings) / sizeof(*luaCallIDStrings) == LUACALL_COUNT)
rlm@1 138
rlm@1 139 static const char *luaMemHookTypeStrings [] =
rlm@1 140 {
rlm@1 141 "MEMHOOK_WRITE",
rlm@1 142 "MEMHOOK_READ",
rlm@1 143 "MEMHOOK_EXEC",
rlm@1 144
rlm@1 145 "MEMHOOK_WRITE_SUB",
rlm@1 146 "MEMHOOK_READ_SUB",
rlm@1 147 "MEMHOOK_EXEC_SUB",
rlm@1 148 };
rlm@1 149
rlm@1 150 //make sure we have the right number of strings
rlm@1 151 CTASSERT(sizeof(luaMemHookTypeStrings) / sizeof(*luaMemHookTypeStrings) == LUAMEMHOOK_COUNT)
rlm@1 152
rlm@1 153 static char *rawToCString(lua_State * L, int idx = 0);
rlm@1 154 static const char *toCString(lua_State *L, int idx = 0);
rlm@1 155
rlm@1 156 // GBA memory I/O functions copied from win32/MemoryViewerDlg.cpp
rlm@1 157 static inline u8 CPUReadByteQuick(u32 addr)
rlm@1 158 {
rlm@1 159 return ::map[addr >> 24].address[addr & ::map[addr >> 24].mask];
rlm@1 160 }
rlm@1 161
rlm@1 162 static inline void CPUWriteByteQuick(u32 addr, u8 b)
rlm@1 163 {
rlm@1 164 ::map[addr >> 24].address[addr & ::map[addr >> 24].mask] = b;
rlm@1 165 }
rlm@1 166
rlm@1 167 static inline u16 CPUReadHalfWordQuick(u32 addr)
rlm@1 168 {
rlm@1 169 return *((u16 *) &::map[addr >> 24].address[addr & ::map[addr >> 24].mask]);
rlm@1 170 }
rlm@1 171
rlm@1 172 static inline void CPUWriteHalfWordQuick(u32 addr, u16 b)
rlm@1 173 {
rlm@1 174 *((u16 *) &::map[addr >> 24].address[addr & ::map[addr >> 24].mask]) = b;
rlm@1 175 }
rlm@1 176
rlm@1 177 static inline u32 CPUReadMemoryQuick(u32 addr)
rlm@1 178 {
rlm@1 179 return *((u32 *) &::map[addr >> 24].address[addr & ::map[addr >> 24].mask]);
rlm@1 180 }
rlm@1 181
rlm@1 182 static inline void CPUWriteMemoryQuick(u32 addr, u32 b)
rlm@1 183 {
rlm@1 184 *((u32 *) &::map[addr >> 24].address[addr & ::map[addr >> 24].mask]) = b;
rlm@1 185 }
rlm@1 186
rlm@1 187 // GB
rlm@1 188 static inline u8 gbReadMemoryQuick8(u16 addr)
rlm@1 189 {
rlm@1 190 return gbReadMemoryQuick(addr);
rlm@1 191 }
rlm@1 192
rlm@1 193 static inline void gbWriteMemoryQuick8(u16 addr, u8 b)
rlm@1 194 {
rlm@1 195 gbWriteMemoryQuick(addr, b);
rlm@1 196 }
rlm@1 197
rlm@1 198 static inline u16 gbReadMemoryQuick16(u16 addr)
rlm@1 199 {
rlm@1 200 return (gbReadMemoryQuick(addr + 1) << 8) | gbReadMemoryQuick(addr);
rlm@1 201 }
rlm@1 202
rlm@1 203 static inline void gbWriteMemoryQuick16(u16 addr, u16 b)
rlm@1 204 {
rlm@1 205 gbWriteMemoryQuick(addr, b & 0xff);
rlm@1 206 gbWriteMemoryQuick(addr + 1, (b >> 8) & 0xff);
rlm@1 207 }
rlm@1 208
rlm@1 209 static inline u32 gbReadMemoryQuick32(u16 addr)
rlm@1 210 {
rlm@1 211 return (gbReadMemoryQuick(addr + 3) << 24) |
rlm@1 212 (gbReadMemoryQuick(addr + 2) << 16) |
rlm@1 213 (gbReadMemoryQuick(addr + 1) << 8) |
rlm@1 214 gbReadMemoryQuick(addr);
rlm@1 215 }
rlm@1 216
rlm@1 217 static inline void gbWriteMemoryQuick32(u16 addr, u32 b)
rlm@1 218 {
rlm@1 219 gbWriteMemoryQuick(addr, b & 0xff);
rlm@1 220 gbWriteMemoryQuick(addr + 1, (b >> 8) & 0xff);
rlm@1 221 gbWriteMemoryQuick(addr + 2, (b >> 16) & 0xff);
rlm@1 222 gbWriteMemoryQuick(addr + 1, (b >> 24) & 0xff);
rlm@1 223 }
rlm@1 224
rlm@1 225 static inline u8 gbReadROMQuick8(u32 addr)
rlm@1 226 {
rlm@1 227 return gbReadROMQuick(addr & gbRomSizeMask);
rlm@1 228 }
rlm@1 229
rlm@1 230 static inline u8 gbReadROMQuick16(u32 addr)
rlm@1 231 {
rlm@1 232 return (gbReadROMQuick(addr+1 & gbRomSizeMask) << 8) | gbReadROMQuick(addr & gbRomSizeMask);
rlm@1 233 }
rlm@1 234
rlm@1 235 static inline u8 gbReadROMQuick32(u32 addr)
rlm@1 236 {
rlm@1 237 return (gbReadROMQuick(addr+3 & gbRomSizeMask) << 24) |
rlm@1 238 (gbReadROMQuick(addr+2 & gbRomSizeMask) << 16) |
rlm@1 239 (gbReadROMQuick(addr+1 & gbRomSizeMask) << 8) |
rlm@1 240 gbReadROMQuick(addr & gbRomSizeMask);
rlm@1 241 }
rlm@1 242
rlm@1 243 typedef void (*GetColorFunc)(const uint8 *, uint8 *, uint8 *, uint8 *);
rlm@1 244 typedef void (*SetColorFunc)(uint8 *, uint8, uint8, uint8);
rlm@1 245
rlm@1 246 static void getColor16(const uint8 *s, uint8 *r, uint8 *g, uint8 *b)
rlm@1 247 {
rlm@1 248 u16 v = *(const uint16 *)s;
rlm@1 249 *r = ((v >> systemBlueShift) & 0x001f) << 3;
rlm@1 250 *g = ((v >> systemGreenShift) & 0x001f) << 3;
rlm@1 251 *b = ((v >> systemRedShift) & 0x001f) << 3;
rlm@1 252 }
rlm@1 253
rlm@1 254 static void getColor24(const uint8 *s, uint8 *r, uint8 *g, uint8 *b)
rlm@1 255 {
rlm@1 256 if (systemRedShift > systemBlueShift)
rlm@1 257 *b = s[0], *g = s[1], *r = s[2];
rlm@1 258 else
rlm@1 259 *r = s[0], *g = s[1], *b = s[2];
rlm@1 260 }
rlm@1 261
rlm@1 262 static void getColor32(const uint8 *s, uint8 *r, uint8 *g, uint8 *b)
rlm@1 263 {
rlm@1 264 u32 v = *(const uint32 *)s;
rlm@1 265 *b = ((v >> systemBlueShift) & 0x001f) << 3;
rlm@1 266 *g = ((v >> systemGreenShift) & 0x001f) << 3;
rlm@1 267 *r = ((v >> systemRedShift) & 0x001f) << 3;
rlm@1 268 }
rlm@1 269
rlm@1 270 static void setColor16(uint8 *s, uint8 r, uint8 g, uint8 b)
rlm@1 271 {
rlm@1 272 *(uint16 *)s = ((b >> 3) & 0x01f) <<
rlm@1 273 systemBlueShift |
rlm@1 274 ((g >> 3) & 0x01f) <<
rlm@1 275 systemGreenShift |
rlm@1 276 ((r >> 3) & 0x01f) <<
rlm@1 277 systemRedShift;
rlm@1 278 }
rlm@1 279
rlm@1 280 static void setColor24(uint8 *s, uint8 r, uint8 g, uint8 b)
rlm@1 281 {
rlm@1 282 if (systemRedShift > systemBlueShift)
rlm@1 283 s[0] = b, s[1] = g, s[2] = r;
rlm@1 284 else
rlm@1 285 s[0] = r, s[1] = g, s[2] = b;
rlm@1 286 }
rlm@1 287
rlm@1 288 static void setColor32(uint8 *s, uint8 r, uint8 g, uint8 b)
rlm@1 289 {
rlm@1 290 *(uint32 *)s = ((b >> 3) & 0x01f) <<
rlm@1 291 systemBlueShift |
rlm@1 292 ((g >> 3) & 0x01f) <<
rlm@1 293 systemGreenShift |
rlm@1 294 ((r >> 3) & 0x01f) <<
rlm@1 295 systemRedShift;
rlm@1 296 }
rlm@1 297
rlm@1 298 static bool getColorIOFunc(int depth, GetColorFunc *getColor, SetColorFunc *setColor)
rlm@1 299 {
rlm@1 300 switch (depth)
rlm@1 301 {
rlm@1 302 case 16:
rlm@1 303 if (getColor)
rlm@1 304 *getColor = getColor16;
rlm@1 305 if (setColor)
rlm@1 306 *setColor = setColor16;
rlm@1 307 return true;
rlm@1 308 case 24:
rlm@1 309 if (getColor)
rlm@1 310 *getColor = getColor24;
rlm@1 311 if (setColor)
rlm@1 312 *setColor = setColor24;
rlm@1 313 return true;
rlm@1 314 case 32:
rlm@1 315 if (getColor)
rlm@1 316 *getColor = getColor32;
rlm@1 317 if (setColor)
rlm@1 318 *setColor = setColor32;
rlm@1 319 return true;
rlm@1 320 default:
rlm@1 321 return false;
rlm@1 322 }
rlm@1 323 }
rlm@1 324
rlm@1 325 /**
rlm@1 326 * Resets emulator speed / pause states after script exit.
rlm@1 327 */
rlm@1 328 static void VBALuaOnStop(void)
rlm@1 329 {
rlm@1 330 luaRunning = false;
rlm@1 331 lua_joypads_used = 0;
rlm@1 332 gui_used = false;
rlm@1 333 //if (wasPaused)
rlm@1 334 // systemSetPause(true);
rlm@1 335 }
rlm@1 336
rlm@1 337 /**
rlm@1 338 * Asks Lua if it wants control of the emulator's speed.
rlm@1 339 * Returns 0 if no, 1 if yes. If yes, we also tamper with the
rlm@1 340 * IPPU's settings for speed ourselves, so the calling code
rlm@1 341 * need not do anything.
rlm@1 342 */
rlm@1 343 int VBALuaSpeed(void)
rlm@1 344 {
rlm@1 345 if (!LUA || !luaRunning)
rlm@1 346 return 0;
rlm@1 347
rlm@1 348 //printf("%d\n", speedmode);
rlm@1 349 switch (speedmode)
rlm@1 350 {
rlm@1 351 /*
rlm@1 352 case SPEED_NORMAL:
rlm@1 353 return 0;
rlm@1 354 case SPEED_NOTHROTTLE:
rlm@1 355 IPPU.RenderThisFrame = true;
rlm@1 356 return 1;
rlm@1 357
rlm@1 358 case SPEED_TURBO:
rlm@1 359 IPPU.SkippedFrames++;
rlm@1 360 if (IPPU.SkippedFrames >= 40) {
rlm@1 361 IPPU.SkippedFrames = 0;
rlm@1 362 IPPU.RenderThisFrame = true;
rlm@1 363 }
rlm@1 364 else
rlm@1 365 IPPU.RenderThisFrame = false;
rlm@1 366 return 1;
rlm@1 367
rlm@1 368 // In mode 3, SkippedFrames is set to zero so that the frame
rlm@1 369 // skipping code doesn't try anything funny.
rlm@1 370 case SPEED_MAXIMUM:
rlm@1 371 IPPU.SkippedFrames=0;
rlm@1 372 IPPU.RenderThisFrame = false;
rlm@1 373 return 1;
rlm@1 374 */
rlm@1 375 case 0: // FIXME: to get rid of the warning
rlm@1 376 default:
rlm@1 377 assert(false);
rlm@1 378 return 0;
rlm@1 379 }
rlm@1 380 }
rlm@1 381
rlm@1 382 ///////////////////////////
rlm@1 383 // vba.speedmode(string mode)
rlm@1 384 //
rlm@1 385 // Takes control of the emulation speed
rlm@1 386 // of the system. Normal is normal speed (60fps, 50 for PAL),
rlm@1 387 // nothrottle disables speed control but renders every frame,
rlm@1 388 // turbo renders only a few frames in order to speed up emulation,
rlm@1 389
rlm@1 390 // maximum renders no frames
rlm@1 391 static int vba_speedmode(lua_State *L)
rlm@1 392 {
rlm@1 393 const char *mode = luaL_checkstring(L, 1);
rlm@1 394
rlm@1 395 if (strcasecmp(mode, "normal") == 0)
rlm@1 396 {
rlm@1 397 speedmode = SPEED_NORMAL;
rlm@1 398 }
rlm@1 399 else if (strcasecmp(mode, "nothrottle") == 0)
rlm@1 400 {
rlm@1 401 speedmode = SPEED_NOTHROTTLE;
rlm@1 402 }
rlm@1 403 else if (strcasecmp(mode, "turbo") == 0)
rlm@1 404 {
rlm@1 405 speedmode = SPEED_TURBO;
rlm@1 406 }
rlm@1 407 else if (strcasecmp(mode, "maximum") == 0)
rlm@1 408 {
rlm@1 409 speedmode = SPEED_MAXIMUM;
rlm@1 410 }
rlm@1 411 else
rlm@1 412 luaL_error(L, "Invalid mode %s to vba.speedmode", mode);
rlm@1 413
rlm@1 414 //printf("new speed mode: %d\n", speedmode);
rlm@1 415 return 0;
rlm@1 416 }
rlm@1 417
rlm@1 418 // vba.frameadvnace()
rlm@1 419 //
rlm@1 420 // Executes a frame advance. Occurs by yielding the coroutine, then re-running
rlm@1 421
rlm@1 422 // when we break out.
rlm@1 423 static int vba_frameadvance(lua_State *L)
rlm@1 424 {
rlm@1 425 // We're going to sleep for a frame-advance. Take notes.
rlm@1 426 if (frameAdvanceWaiting)
rlm@1 427 return luaL_error(L, "can't call vba.frameadvance() from here");
rlm@1 428
rlm@1 429 frameAdvanceWaiting = true;
rlm@1 430
rlm@1 431 // Don't do this! The user won't like us sending their emulator out of control!
rlm@1 432 // Settings.FrameAdvance = true;
rlm@1 433 // Now we can yield to the main
rlm@1 434 return lua_yield(L, 0);
rlm@1 435
rlm@1 436 // It's actually rather disappointing...
rlm@1 437 }
rlm@1 438
rlm@1 439 // vba.pause()
rlm@1 440 //
rlm@1 441 // Pauses the emulator, function "waits" until the user unpauses.
rlm@1 442 // This function MAY be called from a non-frame boundary, but the frame
rlm@1 443
rlm@1 444 // finishes executing anwyays. In this case, the function returns immediately.
rlm@1 445 static int vba_pause(lua_State *L)
rlm@1 446 {
rlm@1 447 systemSetPause(true);
rlm@1 448 speedmode = SPEED_NORMAL;
rlm@1 449
rlm@1 450 // Return control if we're midway through a frame. We can't pause here.
rlm@1 451 if (frameAdvanceWaiting)
rlm@1 452 {
rlm@1 453 return 0;
rlm@1 454 }
rlm@1 455
rlm@1 456 // If it's on a frame boundary, we also yield.
rlm@1 457 frameAdvanceWaiting = true;
rlm@1 458 return lua_yield(L, 0);
rlm@1 459 }
rlm@1 460
rlm@1 461 static int vba_registerbefore(lua_State *L)
rlm@1 462 {
rlm@1 463 if (!lua_isnil(L, 1))
rlm@1 464 luaL_checktype(L, 1, LUA_TFUNCTION);
rlm@1 465 lua_settop(L, 1);
rlm@1 466 lua_getfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_BEFOREEMULATION]);
rlm@1 467 lua_insert(L, 1);
rlm@1 468 lua_setfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_BEFOREEMULATION]);
rlm@1 469
rlm@1 470 //StopScriptIfFinished(luaStateToUIDMap[L]);
rlm@1 471 return 1;
rlm@1 472 }
rlm@1 473
rlm@1 474 static int vba_registerafter(lua_State *L)
rlm@1 475 {
rlm@1 476 if (!lua_isnil(L, 1))
rlm@1 477 luaL_checktype(L, 1, LUA_TFUNCTION);
rlm@1 478 lua_settop(L, 1);
rlm@1 479 lua_getfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_AFTEREMULATION]);
rlm@1 480 lua_insert(L, 1);
rlm@1 481 lua_setfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_AFTEREMULATION]);
rlm@1 482
rlm@1 483 //StopScriptIfFinished(luaStateToUIDMap[L]);
rlm@1 484 return 1;
rlm@1 485 }
rlm@1 486
rlm@1 487 static int vba_registerexit(lua_State *L)
rlm@1 488 {
rlm@1 489 if (!lua_isnil(L, 1))
rlm@1 490 luaL_checktype(L, 1, LUA_TFUNCTION);
rlm@1 491 lua_settop(L, 1);
rlm@1 492 lua_getfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_BEFOREEXIT]);
rlm@1 493 lua_insert(L, 1);
rlm@1 494 lua_setfield(L, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_BEFOREEXIT]);
rlm@1 495
rlm@1 496 //StopScriptIfFinished(luaStateToUIDMap[L]);
rlm@1 497 return 1;
rlm@1 498 }
rlm@1 499
rlm@1 500 static inline bool isalphaorunderscore(char c)
rlm@1 501 {
rlm@1 502 return isalpha(c) || c == '_';
rlm@1 503 }
rlm@1 504
rlm@1 505 static std::vector<const void *> s_tableAddressStack; // prevents infinite recursion of a table within a table (when cycle is
rlm@1 506 // found, print something like table:parent)
rlm@1 507 static std::vector<const void *> s_metacallStack; // prevents infinite recursion if something's __tostring returns another table
rlm@1 508 // that contains that something (when cycle is found, print the inner result
rlm@1 509 // without using __tostring)
rlm@1 510
rlm@1 511 #define APPENDPRINT { int _n = snprintf(ptr, remaining,
rlm@1 512 #define END ); if (_n >= 0) { ptr += _n; remaining -= _n; } else { remaining = 0; } }
rlm@1 513 static void toCStringConverter(lua_State *L, int i, char * &ptr, int &remaining)
rlm@1 514 {
rlm@1 515 if (remaining <= 0)
rlm@1 516 return;
rlm@1 517
rlm@1 518 const char *str = ptr; // for debugging
rlm@1 519
rlm@1 520 // if there is a __tostring metamethod then call it
rlm@1 521 int usedMeta = luaL_callmeta(L, i, "__tostring");
rlm@1 522 if (usedMeta)
rlm@1 523 {
rlm@1 524 std::vector<const void *>::const_iterator foundCycleIter = std::find(s_metacallStack.begin(), s_metacallStack.end(), lua_topointer(L, i));
rlm@1 525 if (foundCycleIter != s_metacallStack.end())
rlm@1 526 {
rlm@1 527 lua_pop(L, 1);
rlm@1 528 usedMeta = false;
rlm@1 529 }
rlm@1 530 else
rlm@1 531 {
rlm@1 532 s_metacallStack.push_back(lua_topointer(L, i));
rlm@1 533 i = lua_gettop(L);
rlm@1 534 }
rlm@1 535 }
rlm@1 536
rlm@1 537 switch (lua_type(L, i))
rlm@1 538 {
rlm@1 539 case LUA_TNONE:
rlm@1 540 break;
rlm@1 541 case LUA_TNIL:
rlm@1 542 APPENDPRINT "nil" END break;
rlm@1 543 case LUA_TBOOLEAN:
rlm@1 544 APPENDPRINT lua_toboolean(L, i) ? "true" : "false" END break;
rlm@1 545 case LUA_TSTRING : APPENDPRINT "%s", lua_tostring(L, i) END break;
rlm@1 546 case LUA_TNUMBER:
rlm@1 547 APPENDPRINT "%.12Lg", lua_tonumber(L, i) END break;
rlm@1 548 case LUA_TFUNCTION:
rlm@1 549 if ((L->base + i - 1)->value.gc->cl.c.isC)
rlm@1 550 {
rlm@1 551 //lua_CFunction func = lua_tocfunction(L, i);
rlm@1 552 //std::map<lua_CFunction, const char*>::iterator iter = s_cFuncInfoMap.find(func);
rlm@1 553 //if(iter == s_cFuncInfoMap.end())
rlm@1 554 goto defcase;
rlm@1 555 //APPENDPRINT "function(%s)", iter->second END
rlm@1 556 }
rlm@1 557 else
rlm@1 558 {
rlm@1 559 APPENDPRINT "function(" END
rlm@1 560 Proto * p = (L->base + i - 1)->value.gc->cl.l.p;
rlm@1 561 int numParams = p->numparams + (p->is_vararg ? 1 : 0);
rlm@1 562 for (int n = 0; n < p->numparams; n++)
rlm@1 563 {
rlm@1 564 APPENDPRINT "%s", getstr(p->locvars[n].varname) END
rlm@1 565 if (n != numParams - 1)
rlm@1 566 APPENDPRINT "," END
rlm@1 567 }
rlm@1 568 if (p->is_vararg)
rlm@1 569 APPENDPRINT "..." END
rlm@1 570 APPENDPRINT ")" END
rlm@1 571 }
rlm@1 572 break;
rlm@1 573 defcase: default:
rlm@1 574 APPENDPRINT "%s:%p", luaL_typename(L, i), lua_topointer(L, i) END break;
rlm@1 575 case LUA_TTABLE:
rlm@1 576 {
rlm@1 577 // first make sure there's enough stack space
rlm@1 578 if (!lua_checkstack(L, 4))
rlm@1 579 {
rlm@1 580 // note that even if lua_checkstack never returns false,
rlm@1 581 // that doesn't mean we didn't need to call it,
rlm@1 582 // because calling it retrieves stack space past LUA_MINSTACK
rlm@1 583 goto defcase;
rlm@1 584 }
rlm@1 585
rlm@1 586 std::vector<const void *>::const_iterator foundCycleIter =
rlm@1 587 std::find(s_tableAddressStack.begin(), s_tableAddressStack.end(), lua_topointer(L, i));
rlm@1 588 if (foundCycleIter != s_tableAddressStack.end())
rlm@1 589 {
rlm@1 590 int parentNum = s_tableAddressStack.end() - foundCycleIter;
rlm@1 591 if (parentNum > 1)
rlm@1 592 APPENDPRINT "%s:parent^%d", luaL_typename(L, i), parentNum END
rlm@1 593 else
rlm@1 594 APPENDPRINT "%s:parent", luaL_typename(L, i) END
rlm@1 595 }
rlm@1 596 else
rlm@1 597 {
rlm@1 598 s_tableAddressStack.push_back(lua_topointer(L, i));
rlm@1 599 struct Scope { ~Scope(){ s_tableAddressStack. pop_back(); } } scope;
rlm@1 600
rlm@1 601 APPENDPRINT "{" END
rlm@1 602
rlm@1 603 lua_pushnil(L); // first key
rlm@1 604 int keyIndex = lua_gettop(L);
rlm@1 605 int valueIndex = keyIndex + 1;
rlm@1 606 bool first = true;
rlm@1 607 bool skipKey = true; // true if we're still in the "array part" of the table
rlm@1 608 lua_Number arrayIndex = (lua_Number)0;
rlm@1 609 while (lua_next(L, i))
rlm@1 610 {
rlm@1 611 if (first)
rlm@1 612 first = false;
rlm@1 613 else
rlm@1 614 APPENDPRINT ", " END
rlm@1 615 if (skipKey)
rlm@1 616 {
rlm@1 617 arrayIndex += (lua_Number)1;
rlm@1 618 bool keyIsNumber = (lua_type(L, keyIndex) == LUA_TNUMBER);
rlm@1 619 skipKey = keyIsNumber && (lua_tonumber(L, keyIndex) == arrayIndex);
rlm@1 620 }
rlm@1 621 if (!skipKey)
rlm@1 622 {
rlm@1 623 bool keyIsString = (lua_type(L, keyIndex) == LUA_TSTRING);
rlm@1 624 bool invalidLuaIdentifier = (!keyIsString || !isalphaorunderscore(*lua_tostring(L, keyIndex)));
rlm@1 625 if (invalidLuaIdentifier)
rlm@1 626 if (keyIsString)
rlm@1 627 APPENDPRINT "['" END
rlm@1 628 else
rlm@1 629 APPENDPRINT "[" END
rlm@1 630
rlm@1 631 toCStringConverter(L, keyIndex, ptr, remaining);
rlm@1 632 // key
rlm@1 633
rlm@1 634 if (invalidLuaIdentifier)
rlm@1 635 if (keyIsString)
rlm@1 636 APPENDPRINT "']=" END
rlm@1 637 else
rlm@1 638 APPENDPRINT "]=" END
rlm@1 639 else
rlm@1 640 APPENDPRINT "=" END
rlm@1 641 }
rlm@1 642
rlm@1 643 bool valueIsString = (lua_type(L, valueIndex) == LUA_TSTRING);
rlm@1 644 if (valueIsString)
rlm@1 645 APPENDPRINT "'" END
rlm@1 646
rlm@1 647 toCStringConverter(L, valueIndex, ptr, remaining); // value
rlm@1 648
rlm@1 649 if (valueIsString)
rlm@1 650 APPENDPRINT "'" END
rlm@1 651
rlm@1 652 lua_pop(L, 1);
rlm@1 653
rlm@1 654 if (remaining <= 0)
rlm@1 655 {
rlm@1 656 lua_settop(L, keyIndex - 1); // stack might not be clean yet if we're breaking
rlm@1 657 // early
rlm@1 658 break;
rlm@1 659 }
rlm@1 660 }
rlm@1 661 APPENDPRINT "}" END
rlm@1 662 }
rlm@1 663 }
rlm@1 664 break;
rlm@1 665 }
rlm@1 666
rlm@1 667 if (usedMeta)
rlm@1 668 {
rlm@1 669 s_metacallStack.pop_back();
rlm@1 670 lua_pop(L, 1);
rlm@1 671 }
rlm@1 672 }
rlm@1 673
rlm@1 674 static const int s_tempStrMaxLen = 64 * 1024;
rlm@1 675 static char s_tempStr [s_tempStrMaxLen];
rlm@1 676
rlm@1 677 static char *rawToCString(lua_State *L, int idx)
rlm@1 678 {
rlm@1 679 int a = idx > 0 ? idx : 1;
rlm@1 680 int n = idx > 0 ? idx : lua_gettop(L);
rlm@1 681
rlm@1 682 char *ptr = s_tempStr;
rlm@1 683 *ptr = 0;
rlm@1 684
rlm@1 685 int remaining = s_tempStrMaxLen;
rlm@1 686 for (int i = a; i <= n; i++)
rlm@1 687 {
rlm@1 688 toCStringConverter(L, i, ptr, remaining);
rlm@1 689 if (i != n)
rlm@1 690 APPENDPRINT " " END
rlm@1 691 }
rlm@1 692
rlm@1 693 if (remaining < 3)
rlm@1 694 {
rlm@1 695 while (remaining < 6)
rlm@1 696 remaining++, ptr--;
rlm@1 697 APPENDPRINT "..." END
rlm@1 698 }
rlm@1 699 APPENDPRINT "\r\n" END
rlm@1 700 // the trailing newline is so print() can avoid having to do wasteful things to print its newline
rlm@1 701 // (string copying would be wasteful and calling info.print() twice can be extremely slow)
rlm@1 702 // at the cost of functions that don't want the newline needing to trim off the last two characters
rlm@1 703 // (which is a very fast operation and thus acceptable in this case)
rlm@1 704
rlm@1 705 return s_tempStr;
rlm@1 706 }
rlm@1 707 #undef APPENDPRINT
rlm@1 708 #undef END
rlm@1 709
rlm@1 710 // replacement for luaB_tostring() that is able to show the contents of tables (and formats numbers better, and show function
rlm@1 711 // prototypes)
rlm@1 712 // can be called directly from lua via tostring(), assuming tostring hasn't been reassigned
rlm@1 713 static int tostring(lua_State *L)
rlm@1 714 {
rlm@1 715 char *str = rawToCString(L);
rlm@1 716 str[strlen(str) - 2] = 0; // hack: trim off the \r\n (which is there to simplify the print function's
rlm@1 717 // task)
rlm@1 718 lua_pushstring(L, str);
rlm@1 719 return 1;
rlm@1 720 }
rlm@1 721
rlm@1 722 // like rawToCString, but will check if the global Lua function tostring()
rlm@1 723 // has been replaced with a custom function, and call that instead if so
rlm@1 724 static const char *toCString(lua_State *L, int idx)
rlm@1 725 {
rlm@1 726 int a = idx > 0 ? idx : 1;
rlm@1 727 int n = idx > 0 ? idx : lua_gettop(L);
rlm@1 728 lua_getglobal(L, "tostring");
rlm@1 729 lua_CFunction cf = lua_tocfunction(L, -1);
rlm@1 730 if (cf == tostring || lua_isnil(L, -1)) // optimization: if using our own C tostring function, we can
rlm@1 731 // bypass the call through Lua and all the string object
rlm@1 732 // allocation that would entail
rlm@1 733 {
rlm@1 734 lua_pop(L, 1);
rlm@1 735 return rawToCString(L, idx);
rlm@1 736 }
rlm@1 737 else // if the user overrided the tostring function, we have to actually call it and store the
rlm@1 738 // temporarily allocated string it returns
rlm@1 739 {
rlm@1 740 lua_pushstring(L, "");
rlm@1 741 for (int i = a; i <= n; i++)
rlm@1 742 {
rlm@1 743 lua_pushvalue(L, -2); // function to be called
rlm@1 744 lua_pushvalue(L, i); // value to print
rlm@1 745 lua_call(L, 1, 1);
rlm@1 746 if (lua_tostring(L, -1) == NULL)
rlm@1 747 luaL_error(L, LUA_QL("tostring") " must return a string to " LUA_QL("print"));
rlm@1 748 lua_pushstring(L, (i < n) ? " " : "\r\n");
rlm@1 749 lua_concat(L, 3);
rlm@1 750 }
rlm@1 751 const char *str = lua_tostring(L, -1);
rlm@1 752 strncpy(s_tempStr, str, s_tempStrMaxLen);
rlm@1 753 s_tempStr[s_tempStrMaxLen - 1] = 0;
rlm@1 754 lua_pop(L, 2);
rlm@1 755 return s_tempStr;
rlm@1 756 }
rlm@1 757 }
rlm@1 758
rlm@1 759 // replacement for luaB_print() that goes to the appropriate textbox instead of stdout
rlm@1 760 static int print(lua_State *L)
rlm@1 761 {
rlm@1 762 const char *str = toCString(L);
rlm@1 763
rlm@1 764 int uid = info_uid; //luaStateToUIDMap[L->l_G->mainthread];
rlm@1 765 //LuaContextInfo& info = GetCurrentInfo();
rlm@1 766
rlm@1 767 if (info_print)
rlm@1 768 info_print(uid, str);
rlm@1 769 else
rlm@1 770 puts(str);
rlm@1 771
rlm@1 772 //worry(L, 100);
rlm@1 773 return 0;
rlm@1 774 }
rlm@1 775
rlm@1 776 static int printerror(lua_State *L, int idx)
rlm@1 777 {
rlm@1 778 lua_checkstack(L, lua_gettop(L) + 4);
rlm@1 779
rlm@1 780 if (idx < 0)
rlm@1 781 idx = lua_gettop(L) + 1 + idx;
rlm@1 782
rlm@1 783 const char *str = rawToCString(L, idx);
rlm@1 784
rlm@1 785 int uid = info_uid; //luaStateToUIDMap[L->l_G->mainthread];
rlm@1 786 //LuaContextInfo& info = GetCurrentInfo();
rlm@1 787
rlm@1 788 if (info_print)
rlm@1 789 info_print(uid, str);
rlm@1 790 else
rlm@1 791 fputs(str, stderr);
rlm@1 792
rlm@1 793 //worry(L, 100);
rlm@1 794 return 0;
rlm@1 795 }
rlm@1 796
rlm@1 797 // vba.message(string msg)
rlm@1 798 //
rlm@1 799 // Displays the given message on the screen.
rlm@1 800 static int vba_message(lua_State *L)
rlm@1 801 {
rlm@1 802 const char *msg = luaL_checkstring(L, 1);
rlm@1 803 systemScreenMessage(msg);
rlm@1 804
rlm@1 805 return 0;
rlm@1 806 }
rlm@1 807
rlm@1 808 // provides an easy way to copy a table from Lua
rlm@1 809 // (simple assignment only makes an alias, but sometimes an independent table is desired)
rlm@1 810 // currently this function only performs a shallow copy,
rlm@1 811 // but I think it should be changed to do a deep copy (possibly of configurable depth?)
rlm@1 812 // that maintains the internal table reference structure
rlm@1 813 static int copytable(lua_State *L)
rlm@1 814 {
rlm@1 815 int origIndex = 1; // we only care about the first argument
rlm@1 816 int origType = lua_type(L, origIndex);
rlm@1 817 if (origType == LUA_TNIL)
rlm@1 818 {
rlm@1 819 lua_pushnil(L);
rlm@1 820 return 1;
rlm@1 821 }
rlm@1 822 if (origType != LUA_TTABLE)
rlm@1 823 {
rlm@1 824 luaL_typerror(L, 1, lua_typename(L, LUA_TTABLE));
rlm@1 825 lua_pushnil(L);
rlm@1 826 return 1;
rlm@1 827 }
rlm@1 828
rlm@1 829 lua_createtable(L, lua_objlen(L, 1), 0);
rlm@1 830 int copyIndex = lua_gettop(L);
rlm@1 831
rlm@1 832 lua_pushnil(L); // first key
rlm@1 833 int keyIndex = lua_gettop(L);
rlm@1 834 int valueIndex = keyIndex + 1;
rlm@1 835
rlm@1 836 while (lua_next(L, origIndex))
rlm@1 837 {
rlm@1 838 lua_pushvalue(L, keyIndex);
rlm@1 839 lua_pushvalue(L, valueIndex);
rlm@1 840 lua_rawset(L, copyIndex); // copytable[key] = value
rlm@1 841 lua_pop(L, 1);
rlm@1 842 }
rlm@1 843
rlm@1 844 // copy the reference to the metatable as well, if any
rlm@1 845 if (lua_getmetatable(L, origIndex))
rlm@1 846 lua_setmetatable(L, copyIndex);
rlm@1 847
rlm@1 848 return 1; // return the new table
rlm@1 849 }
rlm@1 850
rlm@1 851 // because print traditionally shows the address of tables,
rlm@1 852 // and the print function I provide instead shows the contents of tables,
rlm@1 853 // I also provide this function
rlm@1 854 // (otherwise there would be no way to see a table's address, AFAICT)
rlm@1 855 static int addressof(lua_State *L)
rlm@1 856 {
rlm@1 857 const void *ptr = lua_topointer(L, -1);
rlm@1 858 lua_pushinteger(L, (lua_Integer)ptr);
rlm@1 859 return 1;
rlm@1 860 }
rlm@1 861
rlm@1 862 struct registerPointerMap
rlm@1 863 {
rlm@1 864 const char * registerName;
rlm@1 865 unsigned int *pointer;
rlm@1 866 int dataSize;
rlm@1 867 };
rlm@1 868
rlm@1 869 #define RPM_ENTRY(name, var) \
rlm@1 870 { name, (unsigned int *)&var, sizeof(var) \
rlm@1 871 } \
rlm@1 872 ,
rlm@1 873
rlm@1 874 extern gbRegister AF;
rlm@1 875 extern gbRegister BC;
rlm@1 876 extern gbRegister DE;
rlm@1 877 extern gbRegister HL;
rlm@1 878 extern gbRegister SP;
rlm@1 879 extern gbRegister PC;
rlm@1 880 extern u16 IFF;
rlm@1 881
rlm@1 882 registerPointerMap regPointerMap [] = {
rlm@1 883 // gba registers
rlm@1 884 RPM_ENTRY("r0", reg[0].I)
rlm@1 885 RPM_ENTRY("r1", reg[1].I)
rlm@1 886 RPM_ENTRY("r2", reg[2].I)
rlm@1 887 RPM_ENTRY("r3", reg[3].I)
rlm@1 888 RPM_ENTRY("r4", reg[4].I)
rlm@1 889 RPM_ENTRY("r5", reg[5].I)
rlm@1 890 RPM_ENTRY("r6", reg[6].I)
rlm@1 891 RPM_ENTRY("r7", reg[7].I)
rlm@1 892 RPM_ENTRY("r8", reg[8].I)
rlm@1 893 RPM_ENTRY("r9", reg[9].I)
rlm@1 894 RPM_ENTRY("r10", reg[10].I)
rlm@1 895 RPM_ENTRY("r11", reg[11].I)
rlm@1 896 RPM_ENTRY("r12", reg[12].I)
rlm@1 897 RPM_ENTRY("r13", reg[13].I)
rlm@1 898 RPM_ENTRY("r14", reg[14].I)
rlm@1 899 RPM_ENTRY("r15", reg[15].I)
rlm@1 900 RPM_ENTRY("cpsr", reg[16].I)
rlm@1 901 RPM_ENTRY("spsr", reg[17].I)
rlm@1 902 // gb registers
rlm@1 903 RPM_ENTRY("a", AF.B.B1)
rlm@1 904 RPM_ENTRY("f", AF.B.B0)
rlm@1 905 RPM_ENTRY("b", BC.B.B1)
rlm@1 906 RPM_ENTRY("c", BC.B.B0)
rlm@1 907 RPM_ENTRY("d", DE.B.B1)
rlm@1 908 RPM_ENTRY("e", DE.B.B0)
rlm@1 909 RPM_ENTRY("h", HL.B.B1)
rlm@1 910 RPM_ENTRY("l", HL.B.B0)
rlm@1 911 RPM_ENTRY("af", AF.W)
rlm@1 912 RPM_ENTRY("bc", BC.W)
rlm@1 913 RPM_ENTRY("de", DE.W)
rlm@1 914 RPM_ENTRY("hl", HL.W)
rlm@1 915 RPM_ENTRY("sp", SP.W)
rlm@1 916 RPM_ENTRY("pc", PC.W)
rlm@1 917 {}
rlm@1 918 };
rlm@1 919
rlm@1 920 struct cpuToRegisterMap
rlm@1 921 {
rlm@1 922 const char *cpuName;
rlm@1 923 registerPointerMap *rpmap;
rlm@1 924 }
rlm@1 925 cpuToRegisterMaps [] =
rlm@1 926 {
rlm@1 927 { "", regPointerMap },
rlm@1 928 };
rlm@1 929
rlm@1 930 //DEFINE_LUA_FUNCTION(memory_getregister, "cpu_dot_registername_string")
rlm@1 931 static int memory_getregister(lua_State *L)
rlm@1 932 {
rlm@1 933 const char *qualifiedRegisterName = luaL_checkstring(L, 1);
rlm@1 934 lua_settop(L, 0);
rlm@1 935 for (int cpu = 0; cpu < sizeof(cpuToRegisterMaps) / sizeof(*cpuToRegisterMaps); cpu++)
rlm@1 936 {
rlm@1 937 cpuToRegisterMap ctrm = cpuToRegisterMaps[cpu];
rlm@1 938 int cpuNameLen = strlen(ctrm.cpuName);
rlm@1 939 if (!strnicmp(qualifiedRegisterName, ctrm.cpuName, cpuNameLen))
rlm@1 940 {
rlm@1 941 qualifiedRegisterName += cpuNameLen;
rlm@1 942 for (int reg = 0; ctrm.rpmap[reg].dataSize; reg++)
rlm@1 943 {
rlm@1 944 registerPointerMap rpm = ctrm.rpmap[reg];
rlm@1 945 if (!stricmp(qualifiedRegisterName, rpm.registerName))
rlm@1 946 {
rlm@1 947 switch (rpm.dataSize)
rlm@1 948 {
rlm@1 949 default:
rlm@1 950 case 1:
rlm@1 951 lua_pushinteger(L, *(unsigned char *)rpm.pointer); break;
rlm@1 952 case 2:
rlm@1 953 lua_pushinteger(L, *(unsigned short *)rpm.pointer); break;
rlm@1 954 case 4:
rlm@1 955 lua_pushinteger(L, *(unsigned long *)rpm.pointer); break;
rlm@1 956 }
rlm@1 957 return 1;
rlm@1 958 }
rlm@1 959 }
rlm@1 960 lua_pushnil(L);
rlm@1 961 return 1;
rlm@1 962 }
rlm@1 963 }
rlm@1 964 lua_pushnil(L);
rlm@1 965 return 1;
rlm@1 966 }
rlm@1 967
rlm@1 968 //DEFINE_LUA_FUNCTION(memory_setregister, "cpu_dot_registername_string,value")
rlm@1 969 static int memory_setregister(lua_State *L)
rlm@1 970 {
rlm@1 971 const char * qualifiedRegisterName = luaL_checkstring(L, 1);
rlm@1 972 unsigned long value = (unsigned long)(luaL_checkinteger(L, 2));
rlm@1 973 lua_settop(L, 0);
rlm@1 974 for (int cpu = 0; cpu < sizeof(cpuToRegisterMaps) / sizeof(*cpuToRegisterMaps); cpu++)
rlm@1 975 {
rlm@1 976 cpuToRegisterMap ctrm = cpuToRegisterMaps[cpu];
rlm@1 977 int cpuNameLen = strlen(ctrm.cpuName);
rlm@1 978 if (!strnicmp(qualifiedRegisterName, ctrm.cpuName, cpuNameLen))
rlm@1 979 {
rlm@1 980 qualifiedRegisterName += cpuNameLen;
rlm@1 981 for (int reg = 0; ctrm.rpmap[reg].dataSize; reg++)
rlm@1 982 {
rlm@1 983 registerPointerMap rpm = ctrm.rpmap[reg];
rlm@1 984 if (!stricmp(qualifiedRegisterName, rpm.registerName))
rlm@1 985 {
rlm@1 986 switch (rpm.dataSize)
rlm@1 987 {
rlm@1 988 default:
rlm@1 989 case 1:
rlm@1 990 *(unsigned char *)rpm.pointer = (unsigned char)(value & 0xFF); break;
rlm@1 991 case 2:
rlm@1 992 *(unsigned short *)rpm.pointer = (unsigned short)(value & 0xFFFF); break;
rlm@1 993 case 4:
rlm@1 994 *(unsigned long *)rpm.pointer = value; break;
rlm@1 995 }
rlm@1 996 return 0;
rlm@1 997 }
rlm@1 998 }
rlm@1 999 return 0;
rlm@1 1000 }
rlm@1 1001 }
rlm@1 1002 return 0;
rlm@1 1003 }
rlm@1 1004
rlm@1 1005 void HandleCallbackError(lua_State *L)
rlm@1 1006 {
rlm@1 1007 if (L->errfunc || L->errorJmp)
rlm@1 1008 luaL_error(L, "%s", lua_tostring(L, -1));
rlm@1 1009 else
rlm@1 1010 {
rlm@1 1011 lua_pushnil(LUA);
rlm@1 1012 lua_setfield(LUA, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 1013
rlm@1 1014 // Error?
rlm@1 1015 //#if (defined(WIN32) && !defined(SDL))
rlm@1 1016 // info_print(info_uid, lua_tostring(LUA, -1)); //Clear_Sound_Buffer();
rlm@1 1017 // AfxGetApp()->m_pMainWnd->MessageBox(lua_tostring(LUA, -1), "Lua run error", MB_OK | MB_ICONSTOP);
rlm@1 1018 //#else
rlm@1 1019 // fprintf(stderr, "Lua thread bombed out: %s\n", lua_tostring(LUA, -1));
rlm@1 1020 //#endif
rlm@1 1021 printerror(LUA, -1);
rlm@1 1022 VBALuaStop();
rlm@1 1023 }
rlm@1 1024 }
rlm@1 1025
rlm@1 1026 void CallRegisteredLuaFunctions(LuaCallID calltype)
rlm@1 1027 {
rlm@1 1028 assert((unsigned int)calltype < (unsigned int)LUACALL_COUNT);
rlm@1 1029
rlm@1 1030 const char *idstring = luaCallIDStrings[calltype];
rlm@1 1031
rlm@1 1032 if (!LUA)
rlm@1 1033 return;
rlm@1 1034
rlm@1 1035 lua_settop(LUA, 0);
rlm@1 1036 lua_getfield(LUA, LUA_REGISTRYINDEX, idstring);
rlm@1 1037
rlm@1 1038 int errorcode = 0;
rlm@1 1039 if (lua_isfunction(LUA, -1))
rlm@1 1040 {
rlm@1 1041 errorcode = lua_pcall(LUA, 0, 0, 0);
rlm@1 1042 if (errorcode)
rlm@1 1043 HandleCallbackError(LUA);
rlm@1 1044 }
rlm@1 1045 else
rlm@1 1046 {
rlm@1 1047 lua_pop(LUA, 1);
rlm@1 1048 }
rlm@1 1049 }
rlm@1 1050
rlm@1 1051 // the purpose of this structure is to provide a way of
rlm@1 1052 // QUICKLY determining whether a memory address range has a hook associated with it,
rlm@1 1053 // with a bias toward fast rejection because the majority of addresses will not be hooked.
rlm@1 1054 // (it must not use any part of Lua or perform any per-script operations,
rlm@1 1055 // otherwise it would definitely be too slow.)
rlm@1 1056 // calculating the regions when a hook is added/removed may be slow,
rlm@1 1057 // but this is an intentional tradeoff to obtain a high speed of checking during later execution
rlm@1 1058 struct TieredRegion
rlm@1 1059 {
rlm@1 1060 template<unsigned int maxGap>
rlm@1 1061 struct Region
rlm@1 1062 {
rlm@1 1063 struct Island
rlm@1 1064 {
rlm@1 1065 unsigned int start;
rlm@1 1066 unsigned int end;
rlm@1 1067 __forceinline bool Contains(unsigned int address, int size) const { return address < end && address + size > start; }
rlm@1 1068 };
rlm@1 1069 std::vector<Island> islands;
rlm@1 1070
rlm@1 1071 void Calculate(const std::vector<unsigned int> &bytes)
rlm@1 1072 {
rlm@1 1073 islands. clear();
rlm@1 1074
rlm@1 1075 unsigned int lastEnd = ~0;
rlm@1 1076
rlm@1 1077 std::vector<unsigned int>::const_iterator iter = bytes.begin();
rlm@1 1078 std::vector<unsigned int>::const_iterator end = bytes.end();
rlm@1 1079 for (; iter != end; ++iter)
rlm@1 1080 {
rlm@1 1081 unsigned int addr = *iter;
rlm@1 1082 if (addr < lastEnd || addr > lastEnd + (long long)maxGap)
rlm@1 1083 {
rlm@1 1084 islands. push_back(Island());
rlm@1 1085 islands. back().start = addr;
rlm@1 1086 }
rlm@1 1087 islands.back(). end = addr + 1;
rlm@1 1088 lastEnd = addr + 1;
rlm@1 1089 }
rlm@1 1090 }
rlm@1 1091
rlm@1 1092 bool Contains(unsigned int address, int size) const
rlm@1 1093 {
rlm@1 1094 for (size_t i = 0; i != islands.size(); ++i)
rlm@1 1095 {
rlm@1 1096 if (islands[i].Contains(address, size))
rlm@1 1097 return true;
rlm@1 1098 }
rlm@1 1099 return false;
rlm@1 1100 }
rlm@1 1101 };
rlm@1 1102
rlm@1 1103 Region<0xFFFFFFFF> broad;
rlm@1 1104 Region<0x1000> mid;
rlm@1 1105 Region<0> narrow;
rlm@1 1106
rlm@1 1107 void Calculate(std::vector<unsigned int> &bytes)
rlm@1 1108 {
rlm@1 1109 std:: sort(bytes.begin(), bytes.end());
rlm@1 1110
rlm@1 1111 broad. Calculate(bytes);
rlm@1 1112 mid. Calculate(bytes);
rlm@1 1113 narrow. Calculate(bytes);
rlm@1 1114 }
rlm@1 1115
rlm@1 1116 TieredRegion()
rlm@1 1117 {
rlm@1 1118 std::vector <unsigned int> temp;
rlm@1 1119 Calculate(temp);
rlm@1 1120 }
rlm@1 1121
rlm@1 1122 __forceinline int NotEmpty()
rlm@1 1123 {
rlm@1 1124 return broad.islands.size();
rlm@1 1125 }
rlm@1 1126
rlm@1 1127 // note: it is illegal to call this if NotEmpty() returns 0
rlm@1 1128 __forceinline bool Contains(unsigned int address, int size)
rlm@1 1129 {
rlm@1 1130 return broad.islands[0].Contains(address, size) &&
rlm@1 1131 mid.Contains(address, size) &&
rlm@1 1132 narrow.Contains(address, size);
rlm@1 1133 }
rlm@1 1134 };
rlm@1 1135 TieredRegion hookedRegions [LUAMEMHOOK_COUNT];
rlm@1 1136
rlm@1 1137 static void CalculateMemHookRegions(LuaMemHookType hookType)
rlm@1 1138 {
rlm@1 1139 std::vector<unsigned int> hookedBytes;
rlm@1 1140 // std::map<int, LuaContextInfo*>::iterator iter = luaContextInfo.begin();
rlm@1 1141 // std::map<int, LuaContextInfo*>::iterator end = luaContextInfo.end();
rlm@1 1142 // while(iter != end)
rlm@1 1143 // {
rlm@1 1144 // LuaContextInfo& info = *iter->second;
rlm@1 1145 if (/*info.*/ numMemHooks)
rlm@1 1146 {
rlm@1 1147 lua_State *L = LUA /*info.L*/;
rlm@1 1148 if (L)
rlm@1 1149 {
rlm@1 1150 lua_settop(L, 0);
rlm@1 1151 lua_getfield(L, LUA_REGISTRYINDEX, luaMemHookTypeStrings[hookType]);
rlm@1 1152 lua_pushnil(L);
rlm@1 1153 while (lua_next(L, -2))
rlm@1 1154 {
rlm@1 1155 if (lua_isfunction(L, -1))
rlm@1 1156 {
rlm@1 1157 unsigned int addr = lua_tointeger(L, -2);
rlm@1 1158 hookedBytes.push_back(addr);
rlm@1 1159 }
rlm@1 1160 lua_pop(L, 1);
rlm@1 1161 }
rlm@1 1162 lua_settop(L, 0);
rlm@1 1163 }
rlm@1 1164 }
rlm@1 1165 // ++iter;
rlm@1 1166 // }
rlm@1 1167 hookedRegions[hookType].Calculate(hookedBytes);
rlm@1 1168 }
rlm@1 1169
rlm@1 1170 static void CallRegisteredLuaMemHook_LuaMatch(unsigned int address, int size, unsigned int value, LuaMemHookType hookType)
rlm@1 1171 {
rlm@1 1172 // std::map<int, LuaContextInfo*>::iterator iter = luaContextInfo.begin();
rlm@1 1173 // std::map<int, LuaContextInfo*>::iterator end = luaContextInfo.end();
rlm@1 1174 // while(iter != end)
rlm@1 1175 // {
rlm@1 1176 // LuaContextInfo& info = *iter->second;
rlm@1 1177 if (/*info.*/ numMemHooks)
rlm@1 1178 {
rlm@1 1179 lua_State *L = LUA /*info.L*/;
rlm@1 1180 if (L /* && !info.panic*/)
rlm@1 1181 {
rlm@1 1182 #ifdef USE_INFO_STACK
rlm@1 1183 infoStack.insert(infoStack.begin(), &info);
rlm@1 1184 struct Scope { ~Scope(){ infoStack. erase(infoStack.begin()); } } scope;
rlm@1 1185 #endif
rlm@1 1186 lua_settop(L, 0);
rlm@1 1187 lua_getfield(L, LUA_REGISTRYINDEX, luaMemHookTypeStrings[hookType]);
rlm@1 1188 for (int i = address; i != address + size; i++)
rlm@1 1189 {
rlm@1 1190 lua_rawgeti(L, -1, i);
rlm@1 1191 if (lua_isfunction(L, -1))
rlm@1 1192 {
rlm@1 1193 bool wasRunning = (luaRunning != 0) /*info.running*/;
rlm@1 1194 luaRunning /*info.running*/ = true;
rlm@1 1195 //RefreshScriptSpeedStatus();
rlm@1 1196 lua_pushinteger(L, address);
rlm@1 1197 lua_pushinteger(L, size);
rlm@1 1198 int errorcode = lua_pcall(L, 2, 0, 0);
rlm@1 1199 luaRunning /*info.running*/ = wasRunning;
rlm@1 1200 //RefreshScriptSpeedStatus();
rlm@1 1201 if (errorcode)
rlm@1 1202 {
rlm@1 1203 HandleCallbackError(L);
rlm@1 1204 //int uid = iter->first;
rlm@1 1205 //HandleCallbackError(L,info,uid,true);
rlm@1 1206 }
rlm@1 1207 break;
rlm@1 1208 }
rlm@1 1209 else
rlm@1 1210 {
rlm@1 1211 lua_pop(L, 1);
rlm@1 1212 }
rlm@1 1213 }
rlm@1 1214 lua_settop(L, 0);
rlm@1 1215 }
rlm@1 1216 }
rlm@1 1217 // ++iter;
rlm@1 1218 // }
rlm@1 1219 }
rlm@1 1220
rlm@1 1221 void CallRegisteredLuaMemHook(unsigned int address, int size, unsigned int value, LuaMemHookType hookType)
rlm@1 1222 {
rlm@1 1223 // performance critical! (called VERY frequently)
rlm@1 1224 // I suggest timing a large number of calls to this function in Release if you change anything in here,
rlm@1 1225 // before and after, because even the most innocent change can make it become 30% to 400% slower.
rlm@1 1226 // a good amount to test is: 100000000 calls with no hook set, and another 100000000 with a hook set.
rlm@1 1227 // (on my system that consistently took 200 ms total in the former case and 350 ms total in the latter
rlm@1 1228 // case)
rlm@1 1229 if (hookedRegions[hookType].NotEmpty())
rlm@1 1230 {
rlm@1 1231 //if((hookType <= LUAMEMHOOK_EXEC) && (address >= 0xE00000))
rlm@1 1232 // address |= 0xFF0000; // account for mirroring of RAM
rlm@1 1233 if (hookedRegions[hookType].Contains(address, size))
rlm@1 1234 CallRegisteredLuaMemHook_LuaMatch(address, size, value, hookType); // something has hooked this
rlm@1 1235 // specific address
rlm@1 1236 }
rlm@1 1237 }
rlm@1 1238
rlm@1 1239 static int memory_registerHook(lua_State *L, LuaMemHookType hookType, int defaultSize)
rlm@1 1240 {
rlm@1 1241 // get first argument: address
rlm@1 1242 unsigned int addr = luaL_checkinteger(L, 1);
rlm@1 1243 //if((addr & ~0xFFFFFF) == ~0xFFFFFF)
rlm@1 1244 // addr &= 0xFFFFFF;
rlm@1 1245
rlm@1 1246 // get optional second argument: size
rlm@1 1247 int size = defaultSize;
rlm@1 1248 int funcIdx = 2;
rlm@1 1249 if (lua_isnumber(L, 2))
rlm@1 1250 {
rlm@1 1251 size = luaL_checkinteger(L, 2);
rlm@1 1252 if (size < 0)
rlm@1 1253 {
rlm@1 1254 size = -size;
rlm@1 1255 addr -= size;
rlm@1 1256 }
rlm@1 1257 funcIdx++;
rlm@1 1258 }
rlm@1 1259
rlm@1 1260 // check last argument: callback function
rlm@1 1261 bool clearing = lua_isnil(L, funcIdx);
rlm@1 1262 if (!clearing)
rlm@1 1263 luaL_checktype(L, funcIdx, LUA_TFUNCTION);
rlm@1 1264 lua_settop(L, funcIdx);
rlm@1 1265
rlm@1 1266 // get the address-to-callback table for this hook type of the current script
rlm@1 1267 lua_getfield(L, LUA_REGISTRYINDEX, luaMemHookTypeStrings[hookType]);
rlm@1 1268
rlm@1 1269 // count how many callback functions we'll be displacing
rlm@1 1270 int numFuncsAfter = clearing ? 0 : size;
rlm@1 1271 int numFuncsBefore = 0;
rlm@1 1272 for (unsigned int i = addr; i != addr + size; i++)
rlm@1 1273 {
rlm@1 1274 lua_rawgeti(L, -1, i);
rlm@1 1275 if (lua_isfunction(L, -1))
rlm@1 1276 numFuncsBefore++;
rlm@1 1277 lua_pop(L, 1);
rlm@1 1278 }
rlm@1 1279
rlm@1 1280 // put the callback function in the address slots
rlm@1 1281 for (unsigned int i = addr; i != addr + size; i++)
rlm@1 1282 {
rlm@1 1283 lua_pushvalue(L, -2);
rlm@1 1284 lua_rawseti(L, -2, i);
rlm@1 1285 }
rlm@1 1286
rlm@1 1287 // adjust the count of active hooks
rlm@1 1288 //LuaContextInfo& info = GetCurrentInfo();
rlm@1 1289 /*info.*/ numMemHooks += numFuncsAfter - numFuncsBefore;
rlm@1 1290
rlm@1 1291 // re-cache regions of hooked memory across all scripts
rlm@1 1292 CalculateMemHookRegions(hookType);
rlm@1 1293
rlm@1 1294 //StopScriptIfFinished(luaStateToUIDMap[L]);
rlm@1 1295 return 0;
rlm@1 1296 }
rlm@1 1297
rlm@1 1298 LuaMemHookType MatchHookTypeToCPU(lua_State *L, LuaMemHookType hookType)
rlm@1 1299 {
rlm@1 1300 int cpuID = 0;
rlm@1 1301
rlm@1 1302 int cpunameIndex = 0;
rlm@1 1303 if (lua_type(L, 2) == LUA_TSTRING)
rlm@1 1304 cpunameIndex = 2;
rlm@1 1305 else if (lua_type(L, 3) == LUA_TSTRING)
rlm@1 1306 cpunameIndex = 3;
rlm@1 1307
rlm@1 1308 if (cpunameIndex)
rlm@1 1309 {
rlm@1 1310 const char *cpuName = lua_tostring(L, cpunameIndex);
rlm@1 1311 if (!stricmp(cpuName, "sub"))
rlm@1 1312 cpuID = 1;
rlm@1 1313 lua_remove(L, cpunameIndex);
rlm@1 1314 }
rlm@1 1315
rlm@1 1316 switch (cpuID)
rlm@1 1317 {
rlm@1 1318 case 0:
rlm@1 1319 return hookType;
rlm@1 1320
rlm@1 1321 case 1:
rlm@1 1322 switch (hookType)
rlm@1 1323 {
rlm@1 1324 case LUAMEMHOOK_WRITE:
rlm@1 1325 return LUAMEMHOOK_WRITE_SUB;
rlm@1 1326 case LUAMEMHOOK_READ:
rlm@1 1327 return LUAMEMHOOK_READ_SUB;
rlm@1 1328 case LUAMEMHOOK_EXEC:
rlm@1 1329 return LUAMEMHOOK_EXEC_SUB;
rlm@1 1330 }
rlm@1 1331 }
rlm@1 1332 return hookType;
rlm@1 1333 }
rlm@1 1334
rlm@1 1335 static int memory_registerwrite(lua_State *L)
rlm@1 1336 {
rlm@1 1337 return memory_registerHook(L, MatchHookTypeToCPU(L, LUAMEMHOOK_WRITE), 1);
rlm@1 1338 }
rlm@1 1339
rlm@1 1340 static int memory_registerread(lua_State *L)
rlm@1 1341 {
rlm@1 1342 return memory_registerHook(L, MatchHookTypeToCPU(L, LUAMEMHOOK_READ), 1);
rlm@1 1343 }
rlm@1 1344
rlm@1 1345 static int memory_registerexec(lua_State *L)
rlm@1 1346 {
rlm@1 1347 return memory_registerHook(L, MatchHookTypeToCPU(L, LUAMEMHOOK_EXEC), 1);
rlm@1 1348 }
rlm@1 1349
rlm@1 1350 //int vba.lagcount
rlm@1 1351 //
rlm@1 1352
rlm@1 1353 //Returns the lagcounter variable
rlm@1 1354 static int vba_getlagcount(lua_State *L)
rlm@1 1355 {
rlm@1 1356 lua_pushinteger(L, systemCounters.lagCount);
rlm@1 1357 return 1;
rlm@1 1358 }
rlm@1 1359
rlm@1 1360 //int vba.lagged
rlm@1 1361 //
rlm@1 1362 //Returns true if the current frame is a lag frame
rlm@1 1363 static int vba_lagged(lua_State *L)
rlm@1 1364 {
rlm@1 1365 lua_pushboolean(L, systemCounters.laggedLast);
rlm@1 1366 return 1;
rlm@1 1367 }
rlm@1 1368
rlm@1 1369 // boolean vba.emulating()
rlm@1 1370 int vba_emulating(lua_State *L)
rlm@1 1371 {
rlm@1 1372 lua_pushboolean(L, systemIsEmulating());
rlm@1 1373 return 1;
rlm@1 1374 }
rlm@1 1375
rlm@1 1376 int movie_isactive(lua_State *L)
rlm@1 1377 {
rlm@1 1378 lua_pushboolean(L, VBAMovieActive());
rlm@1 1379 return 1;
rlm@1 1380 }
rlm@1 1381
rlm@1 1382 int movie_isrecording(lua_State *L)
rlm@1 1383 {
rlm@1 1384 lua_pushboolean(L, VBAMovieRecording());
rlm@1 1385 return 1;
rlm@1 1386 }
rlm@1 1387
rlm@1 1388 int movie_isplaying(lua_State *L)
rlm@1 1389 {
rlm@1 1390 lua_pushboolean(L, VBAMoviePlaying());
rlm@1 1391 return 1;
rlm@1 1392 }
rlm@1 1393
rlm@1 1394 int movie_getlength(lua_State *L)
rlm@1 1395 {
rlm@1 1396 if (VBAMovieActive())
rlm@1 1397 lua_pushinteger(L, VBAMovieGetLength());
rlm@1 1398 else
rlm@1 1399 lua_pushinteger(L, 0);
rlm@1 1400 return 1;
rlm@1 1401 }
rlm@1 1402
rlm@1 1403 static int memory_readbyte(lua_State *L)
rlm@1 1404 {
rlm@1 1405 u32 addr;
rlm@1 1406 u8 val;
rlm@1 1407
rlm@1 1408 addr = luaL_checkinteger(L, 1);
rlm@1 1409 if (systemIsRunningGBA())
rlm@1 1410 {
rlm@1 1411 val = CPUReadByteQuick(addr);
rlm@1 1412 }
rlm@1 1413 else
rlm@1 1414 {
rlm@1 1415 val = gbReadMemoryQuick8(addr);
rlm@1 1416 }
rlm@1 1417
rlm@1 1418 lua_pushinteger(L, val);
rlm@1 1419 return 1;
rlm@1 1420 }
rlm@1 1421
rlm@1 1422 static int memory_readbytesigned(lua_State *L)
rlm@1 1423 {
rlm@1 1424 u32 addr;
rlm@1 1425 s8 val;
rlm@1 1426
rlm@1 1427 addr = luaL_checkinteger(L, 1);
rlm@1 1428 if (systemIsRunningGBA())
rlm@1 1429 {
rlm@1 1430 val = (s8) CPUReadByteQuick(addr);
rlm@1 1431 }
rlm@1 1432 else
rlm@1 1433 {
rlm@1 1434 val = (s8) gbReadMemoryQuick8(addr);
rlm@1 1435 }
rlm@1 1436
rlm@1 1437 lua_pushinteger(L, val);
rlm@1 1438 return 1;
rlm@1 1439 }
rlm@1 1440
rlm@1 1441 static int memory_readword(lua_State *L)
rlm@1 1442 {
rlm@1 1443 u32 addr;
rlm@1 1444 u16 val;
rlm@1 1445
rlm@1 1446 addr = luaL_checkinteger(L, 1);
rlm@1 1447 if (systemIsRunningGBA())
rlm@1 1448 {
rlm@1 1449 val = CPUReadHalfWordQuick(addr);
rlm@1 1450 }
rlm@1 1451 else
rlm@1 1452 {
rlm@1 1453 val = gbReadMemoryQuick16(addr & 0x0000FFFF);
rlm@1 1454 }
rlm@1 1455
rlm@1 1456 lua_pushinteger(L, val);
rlm@1 1457 return 1;
rlm@1 1458 }
rlm@1 1459
rlm@1 1460 static int memory_readwordsigned(lua_State *L)
rlm@1 1461 {
rlm@1 1462 u32 addr;
rlm@1 1463 s16 val;
rlm@1 1464
rlm@1 1465 addr = luaL_checkinteger(L, 1);
rlm@1 1466 if (systemIsRunningGBA())
rlm@1 1467 {
rlm@1 1468 val = (s16) CPUReadHalfWordQuick(addr);
rlm@1 1469 }
rlm@1 1470 else
rlm@1 1471 {
rlm@1 1472 val = (s16) gbReadMemoryQuick16(addr);
rlm@1 1473 }
rlm@1 1474
rlm@1 1475 lua_pushinteger(L, val);
rlm@1 1476 return 1;
rlm@1 1477 }
rlm@1 1478
rlm@1 1479 static int memory_readdword(lua_State *L)
rlm@1 1480 {
rlm@1 1481 u32 addr;
rlm@1 1482 u32 val;
rlm@1 1483
rlm@1 1484 addr = luaL_checkinteger(L, 1);
rlm@1 1485 if (systemIsRunningGBA())
rlm@1 1486 {
rlm@1 1487 val = CPUReadMemoryQuick(addr);
rlm@1 1488 }
rlm@1 1489 else
rlm@1 1490 {
rlm@1 1491 val = gbReadMemoryQuick32(addr & 0x0000FFFF);
rlm@1 1492 }
rlm@1 1493
rlm@1 1494 // lua_pushinteger doesn't work properly for 32bit system, does it?
rlm@1 1495 if (val >= 0x80000000 && sizeof(int) <= 4)
rlm@1 1496 lua_pushnumber(L, val);
rlm@1 1497 else
rlm@1 1498 lua_pushinteger(L, val);
rlm@1 1499 return 1;
rlm@1 1500 }
rlm@1 1501
rlm@1 1502 static int memory_readdwordsigned(lua_State *L)
rlm@1 1503 {
rlm@1 1504 u32 addr;
rlm@1 1505 s32 val;
rlm@1 1506
rlm@1 1507 addr = luaL_checkinteger(L, 1);
rlm@1 1508 if (systemIsRunningGBA())
rlm@1 1509 {
rlm@1 1510 val = (s32) CPUReadMemoryQuick(addr);
rlm@1 1511 }
rlm@1 1512 else
rlm@1 1513 {
rlm@1 1514 val = (s32) gbReadMemoryQuick32(addr);
rlm@1 1515 }
rlm@1 1516
rlm@1 1517 lua_pushinteger(L, val);
rlm@1 1518 return 1;
rlm@1 1519 }
rlm@1 1520
rlm@1 1521 static int memory_readbyterange(lua_State *L)
rlm@1 1522 {
rlm@1 1523 uint32 address = luaL_checkinteger(L, 1);
rlm@1 1524 int length = luaL_checkinteger(L, 2);
rlm@1 1525
rlm@1 1526 if (length < 0)
rlm@1 1527 {
rlm@1 1528 address += length;
rlm@1 1529 length = -length;
rlm@1 1530 }
rlm@1 1531
rlm@1 1532 // push the array
rlm@1 1533 lua_createtable(L, abs(length), 0);
rlm@1 1534
rlm@1 1535 // put all the values into the (1-based) array
rlm@1 1536 for (int a = address, n = 1; n <= length; a++, n++)
rlm@1 1537 {
rlm@1 1538 unsigned char value;
rlm@1 1539
rlm@1 1540 if (systemIsRunningGBA())
rlm@1 1541 {
rlm@1 1542 value = CPUReadByteQuick(a);
rlm@1 1543 }
rlm@1 1544 else
rlm@1 1545 {
rlm@1 1546 value = gbReadMemoryQuick8(a);
rlm@1 1547 }
rlm@1 1548
rlm@1 1549 lua_pushinteger(L, value);
rlm@1 1550 lua_rawseti(L, -2, n);
rlm@1 1551 }
rlm@1 1552
rlm@1 1553 return 1;
rlm@1 1554 }
rlm@1 1555
rlm@1 1556 static int memory_writebyte(lua_State *L)
rlm@1 1557 {
rlm@1 1558 u32 addr;
rlm@1 1559 int val;
rlm@1 1560
rlm@1 1561 addr = luaL_checkinteger(L, 1);
rlm@1 1562 val = luaL_checkinteger(L, 2);
rlm@1 1563 if (systemIsRunningGBA())
rlm@1 1564 {
rlm@1 1565 CPUWriteByteQuick(addr, val);
rlm@1 1566 }
rlm@1 1567 else
rlm@1 1568 {
rlm@1 1569 gbWriteMemoryQuick8(addr, val);
rlm@1 1570 }
rlm@1 1571
rlm@1 1572 CallRegisteredLuaMemHook(addr, 1, val, LUAMEMHOOK_WRITE);
rlm@1 1573 return 0;
rlm@1 1574 }
rlm@1 1575
rlm@1 1576 static int memory_writeword(lua_State *L)
rlm@1 1577 {
rlm@1 1578 u32 addr;
rlm@1 1579 int val;
rlm@1 1580
rlm@1 1581 addr = luaL_checkinteger(L, 1);
rlm@1 1582 val = luaL_checkinteger(L, 2);
rlm@1 1583 if (systemIsRunningGBA())
rlm@1 1584 {
rlm@1 1585 CPUWriteHalfWordQuick(addr, val);
rlm@1 1586 }
rlm@1 1587 else
rlm@1 1588 {
rlm@1 1589 gbWriteMemoryQuick16(addr, val);
rlm@1 1590 }
rlm@1 1591
rlm@1 1592 CallRegisteredLuaMemHook(addr, 2, val, LUAMEMHOOK_WRITE);
rlm@1 1593 return 0;
rlm@1 1594 }
rlm@1 1595
rlm@1 1596 static int memory_writedword(lua_State *L)
rlm@1 1597 {
rlm@1 1598 u32 addr;
rlm@1 1599 int val;
rlm@1 1600
rlm@1 1601 addr = luaL_checkinteger(L, 1);
rlm@1 1602 val = luaL_checkinteger(L, 2);
rlm@1 1603 if (systemIsRunningGBA())
rlm@1 1604 {
rlm@1 1605 CPUWriteMemoryQuick(addr, val);
rlm@1 1606 }
rlm@1 1607 else
rlm@1 1608 {
rlm@1 1609 gbWriteMemoryQuick32(addr, val);
rlm@1 1610 }
rlm@1 1611
rlm@1 1612 CallRegisteredLuaMemHook(addr, 4, val, LUAMEMHOOK_WRITE);
rlm@1 1613 return 0;
rlm@1 1614 }
rlm@1 1615
rlm@1 1616 static int memory_gbromreadbyte(lua_State *L)
rlm@1 1617 {
rlm@1 1618 u32 addr;
rlm@1 1619 u8 val;
rlm@1 1620
rlm@1 1621 addr = luaL_checkinteger(L, 1);
rlm@1 1622 if (systemIsRunningGBA())
rlm@1 1623 {
rlm@1 1624 lua_pushnil(L);
rlm@1 1625 return 1;
rlm@1 1626 }
rlm@1 1627 else
rlm@1 1628 {
rlm@1 1629 val = gbReadROMQuick8(addr);
rlm@1 1630 }
rlm@1 1631
rlm@1 1632 lua_pushinteger(L, val);
rlm@1 1633 return 1;
rlm@1 1634 }
rlm@1 1635
rlm@1 1636 static int memory_gbromreadbytesigned(lua_State *L)
rlm@1 1637 {
rlm@1 1638 u32 addr;
rlm@1 1639 s8 val;
rlm@1 1640
rlm@1 1641 addr = luaL_checkinteger(L, 1);
rlm@1 1642 if (systemIsRunningGBA())
rlm@1 1643 {
rlm@1 1644 lua_pushnil(L);
rlm@1 1645 return 1;
rlm@1 1646 }
rlm@1 1647 else
rlm@1 1648 {
rlm@1 1649 val = (s8) gbReadROMQuick8(addr);
rlm@1 1650 }
rlm@1 1651
rlm@1 1652 lua_pushinteger(L, val);
rlm@1 1653 return 1;
rlm@1 1654 }
rlm@1 1655
rlm@1 1656 static int memory_gbromreadword(lua_State *L)
rlm@1 1657 {
rlm@1 1658 u32 addr;
rlm@1 1659 u16 val;
rlm@1 1660
rlm@1 1661 addr = luaL_checkinteger(L, 1);
rlm@1 1662 if (systemIsRunningGBA())
rlm@1 1663 {
rlm@1 1664 lua_pushnil(L);
rlm@1 1665 return 1;
rlm@1 1666 }
rlm@1 1667 else
rlm@1 1668 {
rlm@1 1669 val = gbReadROMQuick16(addr);
rlm@1 1670 }
rlm@1 1671
rlm@1 1672 lua_pushinteger(L, val);
rlm@1 1673 return 1;
rlm@1 1674 }
rlm@1 1675
rlm@1 1676 static int memory_gbromreadwordsigned(lua_State *L)
rlm@1 1677 {
rlm@1 1678 u32 addr;
rlm@1 1679 s16 val;
rlm@1 1680
rlm@1 1681 addr = luaL_checkinteger(L, 1);
rlm@1 1682 if (systemIsRunningGBA())
rlm@1 1683 {
rlm@1 1684 lua_pushnil(L);
rlm@1 1685 return 1;
rlm@1 1686 }
rlm@1 1687 else
rlm@1 1688 {
rlm@1 1689 val = (s16) gbReadROMQuick16(addr);
rlm@1 1690 }
rlm@1 1691
rlm@1 1692 lua_pushinteger(L, val);
rlm@1 1693 return 1;
rlm@1 1694 }
rlm@1 1695
rlm@1 1696 static int memory_gbromreaddword(lua_State *L)
rlm@1 1697 {
rlm@1 1698 u32 addr;
rlm@1 1699 u32 val;
rlm@1 1700
rlm@1 1701 addr = luaL_checkinteger(L, 1);
rlm@1 1702 if (systemIsRunningGBA())
rlm@1 1703 {
rlm@1 1704 lua_pushnil(L);
rlm@1 1705 return 1;
rlm@1 1706 }
rlm@1 1707 else
rlm@1 1708 {
rlm@1 1709 val = gbReadROMQuick32(addr);
rlm@1 1710 }
rlm@1 1711
rlm@1 1712 // lua_pushinteger doesn't work properly for 32bit system, does it?
rlm@1 1713 if (val >= 0x80000000 && sizeof(int) <= 4)
rlm@1 1714 lua_pushnumber(L, val);
rlm@1 1715 else
rlm@1 1716 lua_pushinteger(L, val);
rlm@1 1717 return 1;
rlm@1 1718 }
rlm@1 1719
rlm@1 1720 static int memory_gbromreaddwordsigned(lua_State *L)
rlm@1 1721 {
rlm@1 1722 u32 addr;
rlm@1 1723 s32 val;
rlm@1 1724
rlm@1 1725 addr = luaL_checkinteger(L, 1);
rlm@1 1726 if (systemIsRunningGBA())
rlm@1 1727 {
rlm@1 1728 lua_pushnil(L);
rlm@1 1729 return 1;
rlm@1 1730 }
rlm@1 1731 else
rlm@1 1732 {
rlm@1 1733 val = (s32) gbReadROMQuick32(addr);
rlm@1 1734 }
rlm@1 1735
rlm@1 1736 lua_pushinteger(L, val);
rlm@1 1737 return 1;
rlm@1 1738 }
rlm@1 1739
rlm@1 1740 static int memory_gbromreadbyterange(lua_State *L)
rlm@1 1741 {
rlm@1 1742 uint32 address = luaL_checkinteger(L, 1);
rlm@1 1743 int length = luaL_checkinteger(L, 2);
rlm@1 1744
rlm@1 1745 if (length < 0)
rlm@1 1746 {
rlm@1 1747 address += length;
rlm@1 1748 length = -length;
rlm@1 1749 }
rlm@1 1750
rlm@1 1751 // push the array
rlm@1 1752 lua_createtable(L, abs(length), 0);
rlm@1 1753
rlm@1 1754 // put all the values into the (1-based) array
rlm@1 1755 for (int a = address, n = 1; n <= length; a++, n++)
rlm@1 1756 {
rlm@1 1757 unsigned char value;
rlm@1 1758
rlm@1 1759 if (systemIsRunningGBA())
rlm@1 1760 {
rlm@1 1761 lua_pushnil(L);
rlm@1 1762 return 1;
rlm@1 1763 }
rlm@1 1764 else
rlm@1 1765 {
rlm@1 1766 value = gbReadROMQuick8(a);
rlm@1 1767 }
rlm@1 1768
rlm@1 1769 lua_pushinteger(L, value);
rlm@1 1770 lua_rawseti(L, -2, n);
rlm@1 1771 }
rlm@1 1772
rlm@1 1773 return 1;
rlm@1 1774 }
rlm@1 1775
rlm@1 1776 // table joypad.get(int which = 1)
rlm@1 1777 //
rlm@1 1778 // Reads the joypads as inputted by the user.
rlm@1 1779 static int joy_get_internal(lua_State *L, bool reportUp, bool reportDown)
rlm@1 1780 {
rlm@1 1781 // Reads the joypads as inputted by the user
rlm@1 1782 int which = luaL_checkinteger(L, 1);
rlm@1 1783
rlm@1 1784 if (which < 0 || which > 4)
rlm@1 1785 {
rlm@1 1786 luaL_error(L, "Invalid input port (valid range 0-4, specified %d)", which);
rlm@1 1787 }
rlm@1 1788
rlm@1 1789 uint32 buttons = systemGetOriginalJoypad(which - 1, false);
rlm@1 1790
rlm@1 1791 lua_newtable(L);
rlm@1 1792
rlm@1 1793 int i;
rlm@1 1794 for (i = 0; i < 10; i++)
rlm@1 1795 {
rlm@1 1796 bool pressed = (buttons & (1 << i)) != 0;
rlm@1 1797 if ((pressed && reportDown) || (!pressed && reportUp))
rlm@1 1798 {
rlm@1 1799 lua_pushboolean(L, pressed);
rlm@1 1800 lua_setfield(L, -2, button_mappings[i]);
rlm@1 1801 }
rlm@1 1802 }
rlm@1 1803
rlm@1 1804 return 1;
rlm@1 1805 }
rlm@1 1806
rlm@1 1807 // joypad.get(which)
rlm@1 1808 // returns a table of every game button,
rlm@1 1809 // true meaning currently-held and false meaning not-currently-held
rlm@1 1810 // (as of last frame boundary)
rlm@1 1811 // this WILL read input from a currently-playing movie
rlm@1 1812 static int joypad_get(lua_State *L)
rlm@1 1813 {
rlm@1 1814 return joy_get_internal(L, true, true);
rlm@1 1815 }
rlm@1 1816
rlm@1 1817 // joypad.getdown(which)
rlm@1 1818 // returns a table of every game button that is currently held
rlm@1 1819 static int joypad_getdown(lua_State *L)
rlm@1 1820 {
rlm@1 1821 return joy_get_internal(L, false, true);
rlm@1 1822 }
rlm@1 1823
rlm@1 1824 // joypad.getup(which)
rlm@1 1825 // returns a table of every game button that is not currently held
rlm@1 1826 static int joypad_getup(lua_State *L)
rlm@1 1827 {
rlm@1 1828 return joy_get_internal(L, true, false);
rlm@1 1829 }
rlm@1 1830
rlm@1 1831 // joypad.set(int which, table buttons)
rlm@1 1832 //
rlm@1 1833 // Sets the given buttons to be pressed during the next
rlm@1 1834 // frame advance. The table should have the right
rlm@1 1835
rlm@1 1836 // keys (no pun intended) set.
rlm@1 1837 static int joypad_set(lua_State *L)
rlm@1 1838 {
rlm@1 1839 // Which joypad we're tampering with
rlm@1 1840 int which = luaL_checkinteger(L, 1);
rlm@1 1841 if (which < 0 || which > 4)
rlm@1 1842 {
rlm@1 1843 luaL_error(L, "Invalid output port (valid range 0-4, specified %d)", which);
rlm@1 1844 }
rlm@1 1845
rlm@1 1846 if (which == 0)
rlm@1 1847 which = systemGetDefaultJoypad();
rlm@1 1848
rlm@1 1849 // And the table of buttons.
rlm@1 1850 luaL_checktype(L, 2, LUA_TTABLE);
rlm@1 1851
rlm@1 1852 // Set up for taking control of the indicated controller
rlm@1 1853 lua_joypads_used |= 1 << (which - 1);
rlm@1 1854 lua_joypads[which - 1] = 0;
rlm@1 1855
rlm@1 1856 for (int i = 0; i < 10; i++)
rlm@1 1857 {
rlm@1 1858 const char *name = button_mappings[i];
rlm@1 1859 lua_getfield(L, 2, name);
rlm@1 1860 if (!lua_isnil(L, -1))
rlm@1 1861 {
rlm@1 1862 bool pressed = lua_toboolean(L, -1) != 0;
rlm@1 1863 if (pressed)
rlm@1 1864 lua_joypads[which - 1] |= 1 << i;
rlm@1 1865 else
rlm@1 1866 lua_joypads[which - 1] &= ~(1 << i);
rlm@1 1867 }
rlm@1 1868 lua_pop(L, 1);
rlm@1 1869 }
rlm@1 1870
rlm@1 1871 return 0;
rlm@1 1872 }
rlm@1 1873
rlm@1 1874 // Helper function to convert a savestate object to the filename it represents.
rlm@1 1875 static const char *savestateobj2filename(lua_State *L, int offset)
rlm@1 1876 {
rlm@1 1877 // First we get the metatable of the indicated object
rlm@1 1878 int result = lua_getmetatable(L, offset);
rlm@1 1879
rlm@1 1880 if (!result)
rlm@1 1881 luaL_error(L, "object not a savestate object");
rlm@1 1882
rlm@1 1883 // Also check that the type entry is set
rlm@1 1884 lua_getfield(L, -1, "__metatable");
rlm@1 1885 if (strcmp(lua_tostring(L, -1), "vba Savestate") != 0)
rlm@1 1886 luaL_error(L, "object not a savestate object");
rlm@1 1887 lua_pop(L, 1);
rlm@1 1888
rlm@1 1889 // Now, get the field we want
rlm@1 1890 lua_getfield(L, -1, "filename");
rlm@1 1891
rlm@1 1892 // Return it
rlm@1 1893 return lua_tostring(L, -1);
rlm@1 1894 }
rlm@1 1895
rlm@1 1896 // Helper function for garbage collection.
rlm@1 1897 static int savestate_gc(lua_State *L)
rlm@1 1898 {
rlm@1 1899 // The object we're collecting is on top of the stack
rlm@1 1900 lua_getmetatable(L, 1);
rlm@1 1901
rlm@1 1902 // Get the filename
rlm@1 1903 const char *filename;
rlm@1 1904 lua_getfield(L, -1, "filename");
rlm@1 1905 filename = lua_tostring(L, -1);
rlm@1 1906
rlm@1 1907 // Delete the file
rlm@1 1908 remove(filename);
rlm@1 1909
rlm@1 1910 // We exit, and the garbage collector takes care of the rest.
rlm@1 1911 // Edit: Visual Studio needs a return value anyway, so returns 0.
rlm@1 1912 return 0;
rlm@1 1913 }
rlm@1 1914
rlm@1 1915 // object savestate.create(int which = nil)
rlm@1 1916 //
rlm@1 1917 // Creates an object used for savestates.
rlm@1 1918 // The object can be associated with a player-accessible savestate
rlm@1 1919
rlm@1 1920 // ("which" between 1 and 12) or not (which == nil).
rlm@1 1921 static int savestate_create(lua_State *L)
rlm@1 1922 {
rlm@1 1923 int which = -1;
rlm@1 1924 if (lua_gettop(L) >= 1)
rlm@1 1925 {
rlm@1 1926 which = luaL_checkinteger(L, 1);
rlm@1 1927 if (which < 1 || which > 12)
rlm@1 1928 {
rlm@1 1929 luaL_error(L, "invalid player's savestate %d", which);
rlm@1 1930 }
rlm@1 1931 }
rlm@1 1932
rlm@1 1933 char stateName[2048];
rlm@1 1934
rlm@1 1935 if (which > 0)
rlm@1 1936 {
rlm@1 1937 // Find an appropriate filename. This is OS specific, unfortunately.
rlm@1 1938 #if (defined(WIN32) && !defined(SDL))
rlm@1 1939 CString stateName = winGetSavestateFilename(theApp.gameFilename, which);
rlm@1 1940 #else
rlm@1 1941 extern char saveDir[2048];
rlm@1 1942 extern char filename[2048];
rlm@1 1943 extern char *sdlGetFilename(char *name);
rlm@1 1944
rlm@1 1945 if (saveDir[0])
rlm@1 1946 sprintf(stateName, "%s/%s%d.sgm", saveDir, sdlGetFilename(filename), which);
rlm@1 1947 else
rlm@1 1948 sprintf(stateName, "%s%d.sgm", filename, which);
rlm@1 1949 #endif
rlm@1 1950 }
rlm@1 1951 else
rlm@1 1952 {
rlm@1 1953 char *stateNameTemp = tempnam(NULL, "snlua");
rlm@1 1954 strcpy(stateName, stateNameTemp);
rlm@1 1955 if (stateNameTemp)
rlm@1 1956 free(stateNameTemp);
rlm@1 1957 }
rlm@1 1958
rlm@1 1959 // Our "object". We don't care about the type, we just need the memory and GC services.
rlm@1 1960 lua_newuserdata(L, 1);
rlm@1 1961
rlm@1 1962 // The metatable we use, protected from Lua and contains garbage collection info and stuff.
rlm@1 1963 lua_newtable(L);
rlm@1 1964
rlm@1 1965 // First, we must protect it
rlm@1 1966 lua_pushstring(L, "vba Savestate");
rlm@1 1967 lua_setfield(L, -2, "__metatable");
rlm@1 1968
rlm@1 1969 // Now we need to save the file itself.
rlm@1 1970 lua_pushstring(L, stateName);
rlm@1 1971 lua_setfield(L, -2, "filename");
rlm@1 1972
rlm@1 1973 // If it's an anonymous savestate, we must delete the file from disk should it be gargage collected
rlm@1 1974 if (which < 0)
rlm@1 1975 {
rlm@1 1976 lua_pushcfunction(L, savestate_gc);
rlm@1 1977 lua_setfield(L, -2, "__gc");
rlm@1 1978 }
rlm@1 1979
rlm@1 1980 // Set the metatable
rlm@1 1981 lua_setmetatable(L, -2);
rlm@1 1982
rlm@1 1983 // Awesome. Return the object
rlm@1 1984 return 1;
rlm@1 1985 }
rlm@1 1986
rlm@1 1987 // savestate.save(object state)
rlm@1 1988 //
rlm@1 1989
rlm@1 1990 // Saves a state to the given object.
rlm@1 1991 static int savestate_save(lua_State *L)
rlm@1 1992 {
rlm@1 1993 const char *filename = savestateobj2filename(L, 1);
rlm@1 1994
rlm@1 1995 // printf("saving %s\n", filename);
rlm@1 1996 // Save states are very expensive. They take time.
rlm@1 1997 numTries--;
rlm@1 1998
rlm@1 1999 bool8 retvalue = theEmulator.emuWriteState ? theEmulator.emuWriteState(filename) : false;
rlm@1 2000 if (!retvalue)
rlm@1 2001 {
rlm@1 2002 // Uh oh
rlm@1 2003 luaL_error(L, "savestate failed");
rlm@1 2004 }
rlm@1 2005
rlm@1 2006 return 0;
rlm@1 2007 }
rlm@1 2008
rlm@1 2009 // savestate.load(object state)
rlm@1 2010 //
rlm@1 2011
rlm@1 2012 // Loads the given state
rlm@1 2013 static int savestate_load(lua_State *L)
rlm@1 2014 {
rlm@1 2015 const char *filename = savestateobj2filename(L, 1);
rlm@1 2016
rlm@1 2017 numTries--;
rlm@1 2018
rlm@1 2019 // printf("loading %s\n", filename);
rlm@1 2020 bool8 retvalue = theEmulator.emuReadState ? theEmulator.emuReadState(filename) : false;
rlm@1 2021 if (!retvalue)
rlm@1 2022 {
rlm@1 2023 // Uh oh
rlm@1 2024 luaL_error(L, "loadstate failed");
rlm@1 2025 }
rlm@1 2026
rlm@1 2027 return 0;
rlm@1 2028 }
rlm@1 2029
rlm@1 2030 // int vba.framecount()
rlm@1 2031 //
rlm@1 2032
rlm@1 2033 // Gets the frame counter for the movie, or the number of frames since last reset.
rlm@1 2034 int vba_framecount(lua_State *L)
rlm@1 2035 {
rlm@1 2036 if (!VBAMovieActive())
rlm@1 2037 {
rlm@1 2038 lua_pushinteger(L, systemCounters.frameCount);
rlm@1 2039 }
rlm@1 2040 else
rlm@1 2041 {
rlm@1 2042 lua_pushinteger(L, VBAMovieGetFrameCounter());
rlm@1 2043 }
rlm@1 2044
rlm@1 2045 return 1;
rlm@1 2046 }
rlm@1 2047
rlm@1 2048 //string movie.getauthor
rlm@1 2049 //
rlm@1 2050
rlm@1 2051 // returns author info field of .vbm file
rlm@1 2052 int movie_getauthor(lua_State *L)
rlm@1 2053 {
rlm@1 2054 if (!VBAMovieActive())
rlm@1 2055 {
rlm@1 2056 //lua_pushnil(L);
rlm@1 2057 lua_pushstring(L, "");
rlm@1 2058 return 1;
rlm@1 2059 }
rlm@1 2060
rlm@1 2061 lua_pushstring(L, VBAMovieGetAuthorInfo().c_str());
rlm@1 2062 return 1;
rlm@1 2063 }
rlm@1 2064
rlm@1 2065 //string movie.filename
rlm@1 2066 int movie_getfilename(lua_State *L)
rlm@1 2067 {
rlm@1 2068 if (!VBAMovieActive())
rlm@1 2069 {
rlm@1 2070 //lua_pushnil(L);
rlm@1 2071 lua_pushstring(L, "");
rlm@1 2072 return 1;
rlm@1 2073 }
rlm@1 2074
rlm@1 2075 lua_pushstring(L, VBAMovieGetFilename().c_str());
rlm@1 2076 return 1;
rlm@1 2077 }
rlm@1 2078
rlm@1 2079 // string movie.mode()
rlm@1 2080 //
rlm@1 2081
rlm@1 2082 // "record", "playback" or nil
rlm@1 2083 int movie_getmode(lua_State *L)
rlm@1 2084 {
rlm@1 2085 assert(!VBAMovieLoading());
rlm@1 2086 if (!VBAMovieActive())
rlm@1 2087 {
rlm@1 2088 lua_pushnil(L);
rlm@1 2089 return 1;
rlm@1 2090 }
rlm@1 2091
rlm@1 2092 if (VBAMovieRecording())
rlm@1 2093 lua_pushstring(L, "record");
rlm@1 2094 else
rlm@1 2095 lua_pushstring(L, "playback");
rlm@1 2096 return 1;
rlm@1 2097 }
rlm@1 2098
rlm@1 2099 static int movie_rerecordcount(lua_State *L)
rlm@1 2100 {
rlm@1 2101 if (VBAMovieActive())
rlm@1 2102 lua_pushinteger(L, VBAMovieGetRerecordCount());
rlm@1 2103 else
rlm@1 2104 lua_pushinteger(L, 0);
rlm@1 2105 return 1;
rlm@1 2106 }
rlm@1 2107
rlm@1 2108 static int movie_setrerecordcount(lua_State *L)
rlm@1 2109 {
rlm@1 2110 if (VBAMovieActive())
rlm@1 2111 VBAMovieSetRerecordCount(luaL_checkinteger(L, 1));
rlm@1 2112 return 0;
rlm@1 2113 }
rlm@1 2114
rlm@1 2115 static int movie_rerecordcounting(lua_State *L)
rlm@1 2116 {
rlm@1 2117 if (lua_gettop(L) == 0)
rlm@1 2118 luaL_error(L, "no parameters specified");
rlm@1 2119
rlm@1 2120 skipRerecords = lua_toboolean(L, 1);
rlm@1 2121 return 0;
rlm@1 2122 }
rlm@1 2123
rlm@1 2124 // movie.stop()
rlm@1 2125 //
rlm@1 2126
rlm@1 2127 // Stops movie playback/recording. Bombs out if movie is not running.
rlm@1 2128 static int movie_stop(lua_State *L)
rlm@1 2129 {
rlm@1 2130 if (!VBAMovieActive())
rlm@1 2131 luaL_error(L, "no movie");
rlm@1 2132
rlm@1 2133 VBAMovieStop(false);
rlm@1 2134 return 0;
rlm@1 2135 }
rlm@1 2136
rlm@1 2137 #define LUA_SCREEN_WIDTH 256
rlm@1 2138 #define LUA_SCREEN_HEIGHT 239
rlm@1 2139
rlm@1 2140 // Common code by the gui library: make sure the screen array is ready
rlm@1 2141 static void gui_prepare(void)
rlm@1 2142 {
rlm@1 2143 if (!gui_data)
rlm@1 2144 gui_data = (uint8 *)malloc(LUA_SCREEN_WIDTH * LUA_SCREEN_HEIGHT * 4);
rlm@1 2145 if (!gui_used)
rlm@1 2146 memset(gui_data, 0, LUA_SCREEN_WIDTH * LUA_SCREEN_HEIGHT * 4);
rlm@1 2147 gui_used = true;
rlm@1 2148 }
rlm@1 2149
rlm@1 2150 // pixform for lua graphics
rlm@1 2151 #define BUILD_PIXEL_ARGB8888(A, R, G, B) (((int)(A) << 24) | ((int)(R) << 16) | ((int)(G) << 8) | (int)(B))
rlm@1 2152 #define DECOMPOSE_PIXEL_ARGB8888(PIX, A, R, G, B) \
rlm@1 2153 { \
rlm@1 2154 (A) = ((PIX) >> 24) & 0xff; \
rlm@1 2155 (R) = ((PIX) >> 16) & 0xff; \
rlm@1 2156 (G) = ((PIX) >> 8) & 0xff; \
rlm@1 2157 (B) = (PIX) & 0xff; \
rlm@1 2158 }
rlm@1 2159 #define LUA_BUILD_PIXEL BUILD_PIXEL_ARGB8888
rlm@1 2160 #define LUA_DECOMPOSE_PIXEL DECOMPOSE_PIXEL_ARGB8888
rlm@1 2161 #define LUA_PIXEL_A(PIX) (((PIX) >> 24) & 0xff)
rlm@1 2162 #define LUA_PIXEL_R(PIX) (((PIX) >> 16) & 0xff)
rlm@1 2163 #define LUA_PIXEL_G(PIX) (((PIX) >> 8) & 0xff)
rlm@1 2164 #define LUA_PIXEL_B(PIX) ((PIX) & 0xff)
rlm@1 2165
rlm@1 2166 template<class T>
rlm@1 2167 static void swap(T &one, T &two)
rlm@1 2168 {
rlm@1 2169 T temp = one;
rlm@1 2170 one = two;
rlm@1 2171 two = temp;
rlm@1 2172 }
rlm@1 2173
rlm@1 2174 // write a pixel to buffer
rlm@1 2175 static inline void blend32(uint32 *dstPixel, uint32 colour)
rlm@1 2176 {
rlm@1 2177 uint8 *dst = (uint8 *)dstPixel;
rlm@1 2178 int a, r, g, b;
rlm@1 2179 LUA_DECOMPOSE_PIXEL(colour, a, r, g, b);
rlm@1 2180
rlm@1 2181 if (a == 255 || dst[3] == 0)
rlm@1 2182 {
rlm@1 2183 // direct copy
rlm@1 2184 *(uint32 *) (dst) = colour;
rlm@1 2185 }
rlm@1 2186 else if (a == 0)
rlm@1 2187 {
rlm@1 2188 // do not copy
rlm@1 2189 }
rlm@1 2190 else
rlm@1 2191 {
rlm@1 2192 // alpha-blending
rlm@1 2193 int a_dst = ((255 - a) * dst[3] + 128) / 255;
rlm@1 2194 int a_new = a + a_dst;
rlm@1 2195
rlm@1 2196 dst[0] = (uint8) (((dst[0] * a_dst + b * a) + (a_new / 2)) / a_new);
rlm@1 2197 dst[1] = (uint8) (((dst[1] * a_dst + g * a) + (a_new / 2)) / a_new);
rlm@1 2198 dst[2] = (uint8) (((dst[2] * a_dst + r * a) + (a_new / 2)) / a_new);
rlm@1 2199 dst[3] = (uint8) a_new;
rlm@1 2200 }
rlm@1 2201 }
rlm@1 2202
rlm@1 2203 // check if a pixel is in the lua canvas
rlm@1 2204 static inline bool gui_check_boundary(int x, int y)
rlm@1 2205 {
rlm@1 2206 return !(x < 0 || x >= LUA_SCREEN_WIDTH || y < 0 || y >= LUA_SCREEN_HEIGHT);
rlm@1 2207 }
rlm@1 2208
rlm@1 2209 // check if any part of a box is in the lua canvas
rlm@1 2210 static inline bool gui_checkbox(int x1, int y1, int x2, int y2)
rlm@1 2211 {
rlm@1 2212 if ((x1 < 0 && x2 < 0)
rlm@1 2213 || (x1 >= LUA_SCREEN_WIDTH && x2 >= LUA_SCREEN_WIDTH)
rlm@1 2214 || (y1 < 0 && y2 < 0)
rlm@1 2215 || (y1 >= LUA_SCREEN_HEIGHT && y2 >= LUA_SCREEN_HEIGHT))
rlm@1 2216 return false;
rlm@1 2217 return true;
rlm@1 2218 }
rlm@1 2219
rlm@1 2220 // write a pixel to gui_data (do not check boundaries for speedup)
rlm@1 2221 static inline void gui_drawpixel_fast(int x, int y, uint32 colour)
rlm@1 2222 {
rlm@1 2223 //gui_prepare();
rlm@1 2224 blend32((uint32 *) &gui_data[(y * LUA_SCREEN_WIDTH + x) * 4], colour);
rlm@1 2225 }
rlm@1 2226
rlm@1 2227 // write a pixel to gui_data (check boundaries)
rlm@1 2228 static inline void gui_drawpixel_internal(int x, int y, uint32 colour)
rlm@1 2229 {
rlm@1 2230 //gui_prepare();
rlm@1 2231 if (gui_check_boundary(x, y))
rlm@1 2232 gui_drawpixel_fast(x, y, colour);
rlm@1 2233 }
rlm@1 2234
rlm@1 2235 // draw a line on gui_data (checks boundaries)
rlm@1 2236 static void gui_drawline_internal(int x1, int y1, int x2, int y2, bool lastPixel, uint32 colour)
rlm@1 2237 {
rlm@1 2238 //gui_prepare();
rlm@1 2239 // Note: New version of Bresenham's Line Algorithm
rlm@1 2240 //
rlm@1 2241 //
rlm@1 2242 // http://groups.google.co.jp/group/rec.games.roguelike.development/browse_thread/thread/345f4c42c3b25858/29e07a3af3a450e6?show_docid=29e07a3af3a450e6
rlm@1 2243 int swappedx = 0;
rlm@1 2244 int swappedy = 0;
rlm@1 2245
rlm@1 2246 int xtemp = x1 - x2;
rlm@1 2247 int ytemp = y1 - y2;
rlm@1 2248 if (xtemp == 0 && ytemp == 0)
rlm@1 2249 {
rlm@1 2250 gui_drawpixel_internal(x1, y1, colour);
rlm@1 2251 return;
rlm@1 2252 }
rlm@1 2253
rlm@1 2254 if (xtemp < 0)
rlm@1 2255 {
rlm@1 2256 xtemp = -xtemp;
rlm@1 2257 swappedx = 1;
rlm@1 2258 }
rlm@1 2259
rlm@1 2260 if (ytemp < 0)
rlm@1 2261 {
rlm@1 2262 ytemp = -ytemp;
rlm@1 2263 swappedy = 1;
rlm@1 2264 }
rlm@1 2265
rlm@1 2266 int delta_x = xtemp << 1;
rlm@1 2267 int delta_y = ytemp << 1;
rlm@1 2268
rlm@1 2269 signed char ix = x1 > x2 ? 1 : -1;
rlm@1 2270 signed char iy = y1 > y2 ? 1 : -1;
rlm@1 2271
rlm@1 2272 if (lastPixel)
rlm@1 2273 gui_drawpixel_internal(x2, y2, colour);
rlm@1 2274
rlm@1 2275 if (delta_x >= delta_y)
rlm@1 2276 {
rlm@1 2277 int error = delta_y - (delta_x >> 1);
rlm@1 2278
rlm@1 2279 while (x2 != x1)
rlm@1 2280 {
rlm@1 2281 if (error == 0 && !swappedx)
rlm@1 2282 gui_drawpixel_internal(x2 + ix, y2, colour);
rlm@1 2283 if (error >= 0)
rlm@1 2284 {
rlm@1 2285 if (error || (ix > 0))
rlm@1 2286 {
rlm@1 2287 y2 += iy;
rlm@1 2288 error -= delta_x;
rlm@1 2289 }
rlm@1 2290 }
rlm@1 2291
rlm@1 2292 x2 += ix;
rlm@1 2293 gui_drawpixel_internal(x2, y2, colour);
rlm@1 2294 if (error == 0 && swappedx)
rlm@1 2295 gui_drawpixel_internal(x2, y2 + iy, colour);
rlm@1 2296 error += delta_y;
rlm@1 2297 }
rlm@1 2298 }
rlm@1 2299 else
rlm@1 2300 {
rlm@1 2301 int error = delta_x - (delta_y >> 1);
rlm@1 2302
rlm@1 2303 while (y2 != y1)
rlm@1 2304 {
rlm@1 2305 if (error == 0 && !swappedy)
rlm@1 2306 gui_drawpixel_internal(x2, y2 + iy, colour);
rlm@1 2307 if (error >= 0)
rlm@1 2308 {
rlm@1 2309 if (error || (iy > 0))
rlm@1 2310 {
rlm@1 2311 x2 += ix;
rlm@1 2312 error -= delta_y;
rlm@1 2313 }
rlm@1 2314 }
rlm@1 2315
rlm@1 2316 y2 += iy;
rlm@1 2317 gui_drawpixel_internal(x2, y2, colour);
rlm@1 2318 if (error == 0 && swappedy)
rlm@1 2319 gui_drawpixel_internal(x2 + ix, y2, colour);
rlm@1 2320 error += delta_x;
rlm@1 2321 }
rlm@1 2322 }
rlm@1 2323 }
rlm@1 2324
rlm@1 2325 // draw a rect on gui_data
rlm@1 2326 static void gui_drawbox_internal(int x1, int y1, int x2, int y2, uint32 colour)
rlm@1 2327 {
rlm@1 2328 if (x1 > x2)
rlm@1 2329 std::swap(x1, x2);
rlm@1 2330 if (y1 > y2)
rlm@1 2331 std::swap(y1, y2);
rlm@1 2332 if (x1 < 0)
rlm@1 2333 x1 = -1;
rlm@1 2334 if (y1 < 0)
rlm@1 2335 y1 = -1;
rlm@1 2336 if (x2 >= LUA_SCREEN_WIDTH)
rlm@1 2337 x2 = LUA_SCREEN_WIDTH;
rlm@1 2338 if (y2 >= LUA_SCREEN_HEIGHT)
rlm@1 2339 y2 = LUA_SCREEN_HEIGHT;
rlm@1 2340
rlm@1 2341 if (!gui_checkbox(x1, y1, x2, y2))
rlm@1 2342 return;
rlm@1 2343
rlm@1 2344 //gui_prepare();
rlm@1 2345 gui_drawline_internal(x1, y1, x2, y1, true, colour);
rlm@1 2346 gui_drawline_internal(x1, y2, x2, y2, true, colour);
rlm@1 2347 gui_drawline_internal(x1, y1, x1, y2, true, colour);
rlm@1 2348 gui_drawline_internal(x2, y1, x2, y2, true, colour);
rlm@1 2349 }
rlm@1 2350
rlm@1 2351 // draw a circle on gui_data
rlm@1 2352 static void gui_drawcircle_internal(int x0, int y0, int radius, uint32 colour)
rlm@1 2353 {
rlm@1 2354 //gui_prepare();
rlm@1 2355 if (radius < 0)
rlm@1 2356 radius = -radius;
rlm@1 2357 if (radius == 0)
rlm@1 2358 return;
rlm@1 2359 if (radius == 1)
rlm@1 2360 {
rlm@1 2361 gui_drawpixel_internal(x0, y0, colour);
rlm@1 2362 return;
rlm@1 2363 }
rlm@1 2364
rlm@1 2365 // http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
rlm@1 2366 int f = 1 - radius;
rlm@1 2367 int ddF_x = 1;
rlm@1 2368 int ddF_y = -2 * radius;
rlm@1 2369 int x = 0;
rlm@1 2370 int y = radius;
rlm@1 2371
rlm@1 2372 if (!gui_checkbox(x0 - radius, y0 - radius, x0 + radius, y0 + radius))
rlm@1 2373 return;
rlm@1 2374
rlm@1 2375 gui_drawpixel_internal(x0, y0 + radius, colour);
rlm@1 2376 gui_drawpixel_internal(x0, y0 - radius, colour);
rlm@1 2377 gui_drawpixel_internal(x0 + radius, y0, colour);
rlm@1 2378 gui_drawpixel_internal(x0 - radius, y0, colour);
rlm@1 2379
rlm@1 2380 // same pixel shouldn't be drawed twice,
rlm@1 2381 // because each pixel has opacity.
rlm@1 2382 // so now the routine gets ugly.
rlm@1 2383 while (true)
rlm@1 2384 {
rlm@1 2385 assert(ddF_x == 2 * x + 1);
rlm@1 2386 assert(ddF_y == -2 * y);
rlm@1 2387 assert(f == x * x + y * y - radius * radius + 2 * x - y + 1);
rlm@1 2388 if (f >= 0)
rlm@1 2389 {
rlm@1 2390 y--;
rlm@1 2391 ddF_y += 2;
rlm@1 2392 f += ddF_y;
rlm@1 2393 }
rlm@1 2394
rlm@1 2395 x++;
rlm@1 2396 ddF_x += 2;
rlm@1 2397 f += ddF_x;
rlm@1 2398 if (x < y)
rlm@1 2399 {
rlm@1 2400 gui_drawpixel_internal(x0 + x, y0 + y, colour);
rlm@1 2401 gui_drawpixel_internal(x0 - x, y0 + y, colour);
rlm@1 2402 gui_drawpixel_internal(x0 + x, y0 - y, colour);
rlm@1 2403 gui_drawpixel_internal(x0 - x, y0 - y, colour);
rlm@1 2404 gui_drawpixel_internal(x0 + y, y0 + x, colour);
rlm@1 2405 gui_drawpixel_internal(x0 - y, y0 + x, colour);
rlm@1 2406 gui_drawpixel_internal(x0 + y, y0 - x, colour);
rlm@1 2407 gui_drawpixel_internal(x0 - y, y0 - x, colour);
rlm@1 2408 }
rlm@1 2409 else if (x == y)
rlm@1 2410 {
rlm@1 2411 gui_drawpixel_internal(x0 + x, y0 + y, colour);
rlm@1 2412 gui_drawpixel_internal(x0 - x, y0 + y, colour);
rlm@1 2413 gui_drawpixel_internal(x0 + x, y0 - y, colour);
rlm@1 2414 gui_drawpixel_internal(x0 - x, y0 - y, colour);
rlm@1 2415 break;
rlm@1 2416 }
rlm@1 2417 else
rlm@1 2418 break;
rlm@1 2419 }
rlm@1 2420 }
rlm@1 2421
rlm@1 2422 // draw fill rect on gui_data
rlm@1 2423 static void gui_fillbox_internal(int x1, int y1, int x2, int y2, uint32 colour)
rlm@1 2424 {
rlm@1 2425 if (x1 > x2)
rlm@1 2426 std::swap(x1, x2);
rlm@1 2427 if (y1 > y2)
rlm@1 2428 std::swap(y1, y2);
rlm@1 2429 if (x1 < 0)
rlm@1 2430 x1 = 0;
rlm@1 2431 if (y1 < 0)
rlm@1 2432 y1 = 0;
rlm@1 2433 if (x2 >= LUA_SCREEN_WIDTH)
rlm@1 2434 x2 = LUA_SCREEN_WIDTH - 1;
rlm@1 2435 if (y2 >= LUA_SCREEN_HEIGHT)
rlm@1 2436 y2 = LUA_SCREEN_HEIGHT - 1;
rlm@1 2437
rlm@1 2438 //gui_prepare();
rlm@1 2439 int ix, iy;
rlm@1 2440 for (iy = y1; iy <= y2; iy++)
rlm@1 2441 {
rlm@1 2442 for (ix = x1; ix <= x2; ix++)
rlm@1 2443 {
rlm@1 2444 gui_drawpixel_fast(ix, iy, colour);
rlm@1 2445 }
rlm@1 2446 }
rlm@1 2447 }
rlm@1 2448
rlm@1 2449 // fill a circle on gui_data
rlm@1 2450 static void gui_fillcircle_internal(int x0, int y0, int radius, uint32 colour)
rlm@1 2451 {
rlm@1 2452 //gui_prepare();
rlm@1 2453 if (radius < 0)
rlm@1 2454 radius = -radius;
rlm@1 2455 if (radius == 0)
rlm@1 2456 return;
rlm@1 2457 if (radius == 1)
rlm@1 2458 {
rlm@1 2459 gui_drawpixel_internal(x0, y0, colour);
rlm@1 2460 return;
rlm@1 2461 }
rlm@1 2462
rlm@1 2463 // http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
rlm@1 2464 int f = 1 - radius;
rlm@1 2465 int ddF_x = 1;
rlm@1 2466 int ddF_y = -2 * radius;
rlm@1 2467 int x = 0;
rlm@1 2468 int y = radius;
rlm@1 2469
rlm@1 2470 if (!gui_checkbox(x0 - radius, y0 - radius, x0 + radius, y0 + radius))
rlm@1 2471 return;
rlm@1 2472
rlm@1 2473 gui_drawline_internal(x0, y0 - radius, x0, y0 + radius, true, colour);
rlm@1 2474
rlm@1 2475 while (true)
rlm@1 2476 {
rlm@1 2477 assert(ddF_x == 2 * x + 1);
rlm@1 2478 assert(ddF_y == -2 * y);
rlm@1 2479 assert(f == x * x + y * y - radius * radius + 2 * x - y + 1);
rlm@1 2480 if (f >= 0)
rlm@1 2481 {
rlm@1 2482 y--;
rlm@1 2483 ddF_y += 2;
rlm@1 2484 f += ddF_y;
rlm@1 2485 }
rlm@1 2486
rlm@1 2487 x++;
rlm@1 2488 ddF_x += 2;
rlm@1 2489 f += ddF_x;
rlm@1 2490
rlm@1 2491 if (x < y)
rlm@1 2492 {
rlm@1 2493 gui_drawline_internal(x0 + x, y0 - y, x0 + x, y0 + y, true, colour);
rlm@1 2494 gui_drawline_internal(x0 - x, y0 - y, x0 - x, y0 + y, true, colour);
rlm@1 2495 if (f >= 0)
rlm@1 2496 {
rlm@1 2497 gui_drawline_internal(x0 + y, y0 - x, x0 + y, y0 + x, true, colour);
rlm@1 2498 gui_drawline_internal(x0 - y, y0 - x, x0 - y, y0 + x, true, colour);
rlm@1 2499 }
rlm@1 2500 }
rlm@1 2501 else if (x == y)
rlm@1 2502 {
rlm@1 2503 gui_drawline_internal(x0 + x, y0 - y, x0 + x, y0 + y, true, colour);
rlm@1 2504 gui_drawline_internal(x0 - x, y0 - y, x0 - x, y0 + y, true, colour);
rlm@1 2505 break;
rlm@1 2506 }
rlm@1 2507 else
rlm@1 2508 break;
rlm@1 2509 }
rlm@1 2510 }
rlm@1 2511
rlm@1 2512 // Helper for a simple hex parser
rlm@1 2513 static int hex2int(lua_State *L, char c)
rlm@1 2514 {
rlm@1 2515 if (c >= '0' && c <= '9')
rlm@1 2516 return c - '0';
rlm@1 2517 if (c >= 'a' && c <= 'f')
rlm@1 2518 return c - 'a' + 10;
rlm@1 2519 if (c >= 'A' && c <= 'F')
rlm@1 2520 return c - 'A' + 10;
rlm@1 2521 return luaL_error(L, "invalid hex in colour");
rlm@1 2522 }
rlm@1 2523
rlm@1 2524 static const struct ColorMapping
rlm@1 2525 {
rlm@1 2526 const char *name;
rlm@1 2527 int value;
rlm@1 2528 }
rlm@1 2529 s_colorMapping[] =
rlm@1 2530 {
rlm@1 2531 { "white", 0xFFFFFFFF },
rlm@1 2532 { "black", 0x000000FF },
rlm@1 2533 { "clear", 0x00000000 },
rlm@1 2534 { "gray", 0x7F7F7FFF },
rlm@1 2535 { "grey", 0x7F7F7FFF },
rlm@1 2536 { "red", 0xFF0000FF },
rlm@1 2537 { "orange", 0xFF7F00FF },
rlm@1 2538 { "yellow", 0xFFFF00FF },
rlm@1 2539 { "chartreuse", 0x7FFF00FF },
rlm@1 2540 { "green", 0x00FF00FF },
rlm@1 2541 { "teal", 0x00FF7FFF },
rlm@1 2542 { "cyan", 0x00FFFFFF },
rlm@1 2543 { "blue", 0x0000FFFF },
rlm@1 2544 { "purple", 0x7F00FFFF },
rlm@1 2545 { "magenta", 0xFF00FFFF },
rlm@1 2546 };
rlm@1 2547
rlm@1 2548 /**
rlm@1 2549 * Converts an integer or a string on the stack at the given
rlm@1 2550 * offset to a RGB32 colour. Several encodings are supported.
rlm@1 2551 * The user may construct their own RGB value, given a simple colour name,
rlm@1 2552 * or an HTML-style "#09abcd" colour. 16 bit reduction doesn't occur at this time.
rlm@1 2553 */
rlm@1 2554 static inline bool str2colour(uint32 *colour, lua_State *L, const char *str)
rlm@1 2555 {
rlm@1 2556 if (str[0] == '#')
rlm@1 2557 {
rlm@1 2558 int color;
rlm@1 2559 sscanf(str + 1, "%X", &color);
rlm@1 2560
rlm@1 2561 int len = strlen(str + 1);
rlm@1 2562 int missing = max(0, 8 - len);
rlm@1 2563 color <<= missing << 2;
rlm@1 2564 if (missing >= 2)
rlm@1 2565 color |= 0xFF;
rlm@1 2566 *colour = color;
rlm@1 2567 return true;
rlm@1 2568 }
rlm@1 2569 else
rlm@1 2570 {
rlm@1 2571 if (!strnicmp(str, "rand", 4))
rlm@1 2572 {
rlm@1 2573 *colour = gen_rand32() | 0xFF; //((rand()*255/RAND_MAX) << 8) | ((rand()*255/RAND_MAX) << 16) |
rlm@1 2574 // ((rand()*255/RAND_MAX) << 24) | 0xFF;
rlm@1 2575 return true;
rlm@1 2576 }
rlm@1 2577
rlm@1 2578 for (int i = 0; i < sizeof(s_colorMapping) / sizeof(*s_colorMapping); i++)
rlm@1 2579 {
rlm@1 2580 if (!stricmp(str, s_colorMapping[i].name))
rlm@1 2581 {
rlm@1 2582 *colour = s_colorMapping[i].value;
rlm@1 2583 return true;
rlm@1 2584 }
rlm@1 2585 }
rlm@1 2586 }
rlm@1 2587
rlm@1 2588 return false;
rlm@1 2589 }
rlm@1 2590
rlm@1 2591 static inline uint32 gui_getcolour_wrapped(lua_State *L, int offset, bool hasDefaultValue, uint32 defaultColour)
rlm@1 2592 {
rlm@1 2593 switch (lua_type(L, offset))
rlm@1 2594 {
rlm@1 2595 case LUA_TSTRING:
rlm@1 2596 {
rlm@1 2597 const char *str = lua_tostring(L, offset);
rlm@1 2598 uint32 colour;
rlm@1 2599
rlm@1 2600 if (str2colour(&colour, L, str))
rlm@1 2601 return colour;
rlm@1 2602 else
rlm@1 2603 {
rlm@1 2604 if (hasDefaultValue)
rlm@1 2605 return defaultColour;
rlm@1 2606 else
rlm@1 2607 return luaL_error(L, "unknown colour %s", str);
rlm@1 2608 }
rlm@1 2609 }
rlm@1 2610
rlm@1 2611 case LUA_TNUMBER:
rlm@1 2612 {
rlm@1 2613 uint32 colour = (uint32) lua_tointeger(L, offset);
rlm@1 2614 return colour;
rlm@1 2615 }
rlm@1 2616
rlm@1 2617 case LUA_TTABLE:
rlm@1 2618 {
rlm@1 2619 int color = 0xFF;
rlm@1 2620 lua_pushnil(L); // first key
rlm@1 2621 int keyIndex = lua_gettop(L);
rlm@1 2622 int valueIndex = keyIndex + 1;
rlm@1 2623 bool first = true;
rlm@1 2624 while (lua_next(L, offset))
rlm@1 2625 {
rlm@1 2626 bool keyIsString = (lua_type(L, keyIndex) == LUA_TSTRING);
rlm@1 2627 bool keyIsNumber = (lua_type(L, keyIndex) == LUA_TNUMBER);
rlm@1 2628 int key = keyIsString ? tolower(*lua_tostring(L, keyIndex)) : (keyIsNumber ? lua_tointeger(L, keyIndex) : 0);
rlm@1 2629 int value = lua_tointeger(L, valueIndex);
rlm@1 2630 if (value < 0) value = 0;
rlm@1 2631 if (value > 255) value = 255;
rlm@1 2632 switch (key)
rlm@1 2633 {
rlm@1 2634 case 1:
rlm@1 2635 case 'r':
rlm@1 2636 color |= value << 24; break;
rlm@1 2637 case 2:
rlm@1 2638 case 'g':
rlm@1 2639 color |= value << 16; break;
rlm@1 2640 case 3:
rlm@1 2641 case 'b':
rlm@1 2642 color |= value << 8; break;
rlm@1 2643 case 4:
rlm@1 2644 case 'a':
rlm@1 2645 color = (color & ~0xFF) | value; break;
rlm@1 2646 }
rlm@1 2647 lua_pop(L, 1);
rlm@1 2648 }
rlm@1 2649 return color;
rlm@1 2650 } break;
rlm@1 2651
rlm@1 2652 case LUA_TFUNCTION:
rlm@1 2653 luaL_error(L, "invalid colour"); // NYI
rlm@1 2654 return 0;
rlm@1 2655
rlm@1 2656 default:
rlm@1 2657 if (hasDefaultValue)
rlm@1 2658 return defaultColour;
rlm@1 2659 else
rlm@1 2660 return luaL_error(L, "invalid colour");
rlm@1 2661 }
rlm@1 2662 }
rlm@1 2663
rlm@1 2664 static uint32 gui_getcolour(lua_State *L, int offset)
rlm@1 2665 {
rlm@1 2666 uint32 colour;
rlm@1 2667 int a, r, g, b;
rlm@1 2668
rlm@1 2669 colour = gui_getcolour_wrapped(L, offset, false, 0);
rlm@1 2670 a = ((colour & 0xff) * transparencyModifier) / 255;
rlm@1 2671 if (a > 255)
rlm@1 2672 a = 255;
rlm@1 2673 b = (colour >> 8) & 0xff;
rlm@1 2674 g = (colour >> 16) & 0xff;
rlm@1 2675 r = (colour >> 24) & 0xff;
rlm@1 2676 return LUA_BUILD_PIXEL(a, r, g, b);
rlm@1 2677 }
rlm@1 2678
rlm@1 2679 static uint32 gui_optcolour(lua_State *L, int offset, uint32 defaultColour)
rlm@1 2680 {
rlm@1 2681 uint32 colour;
rlm@1 2682 int a, r, g, b;
rlm@1 2683 uint8 defA, defB, defG, defR;
rlm@1 2684
rlm@1 2685 LUA_DECOMPOSE_PIXEL(defaultColour, defA, defR, defG, defB);
rlm@1 2686 defaultColour = (defR << 24) | (defG << 16) | (defB << 8) | defA;
rlm@1 2687
rlm@1 2688 colour = gui_getcolour_wrapped(L, offset, true, defaultColour);
rlm@1 2689 a = ((colour & 0xff) * transparencyModifier) / 255;
rlm@1 2690 if (a > 255)
rlm@1 2691 a = 255;
rlm@1 2692 b = (colour >> 8) & 0xff;
rlm@1 2693 g = (colour >> 16) & 0xff;
rlm@1 2694 r = (colour >> 24) & 0xff;
rlm@1 2695 return LUA_BUILD_PIXEL(a, r, g, b);
rlm@1 2696 }
rlm@1 2697
rlm@1 2698 // gui.drawpixel(x,y,colour)
rlm@1 2699 static int gui_drawpixel(lua_State *L)
rlm@1 2700 {
rlm@1 2701 int x = luaL_checkinteger(L, 1);
rlm@1 2702 int y = luaL_checkinteger(L, 2);
rlm@1 2703
rlm@1 2704 uint32 colour = gui_getcolour(L, 3);
rlm@1 2705
rlm@1 2706 // if (!gui_check_boundary(x, y))
rlm@1 2707 // luaL_error(L,"bad coordinates");
rlm@1 2708 gui_prepare();
rlm@1 2709
rlm@1 2710 gui_drawpixel_internal(x, y, colour);
rlm@1 2711
rlm@1 2712 return 0;
rlm@1 2713 }
rlm@1 2714
rlm@1 2715 // gui.drawline(x1,y1,x2,y2,color,skipFirst)
rlm@1 2716 static int gui_drawline(lua_State *L)
rlm@1 2717 {
rlm@1 2718 int x1, y1, x2, y2;
rlm@1 2719 uint32 color;
rlm@1 2720 x1 = luaL_checkinteger(L, 1);
rlm@1 2721 y1 = luaL_checkinteger(L, 2);
rlm@1 2722 x2 = luaL_checkinteger(L, 3);
rlm@1 2723 y2 = luaL_checkinteger(L, 4);
rlm@1 2724 color = gui_optcolour(L, 5, LUA_BUILD_PIXEL(255, 255, 255, 255));
rlm@1 2725 int skipFirst = lua_toboolean(L, 6);
rlm@1 2726
rlm@1 2727 gui_prepare();
rlm@1 2728
rlm@1 2729 gui_drawline_internal(x2, y2, x1, y1, !skipFirst, color);
rlm@1 2730
rlm@1 2731 return 0;
rlm@1 2732 }
rlm@1 2733
rlm@1 2734 // gui.drawbox(x1, y1, x2, y2, fillcolor, outlinecolor)
rlm@1 2735 static int gui_drawbox(lua_State *L)
rlm@1 2736 {
rlm@1 2737 int x1, y1, x2, y2;
rlm@1 2738 uint32 fillcolor;
rlm@1 2739 uint32 outlinecolor;
rlm@1 2740
rlm@1 2741 x1 = luaL_checkinteger(L, 1);
rlm@1 2742 y1 = luaL_checkinteger(L, 2);
rlm@1 2743 x2 = luaL_checkinteger(L, 3);
rlm@1 2744 y2 = luaL_checkinteger(L, 4);
rlm@1 2745 fillcolor = gui_optcolour(L, 5, LUA_BUILD_PIXEL(63, 255, 255, 255));
rlm@1 2746 outlinecolor = gui_optcolour(L, 6, LUA_BUILD_PIXEL(255, LUA_PIXEL_R(fillcolor), LUA_PIXEL_G(fillcolor), LUA_PIXEL_B(fillcolor)));
rlm@1 2747
rlm@1 2748 if (x1 > x2)
rlm@1 2749 std::swap(x1, x2);
rlm@1 2750 if (y1 > y2)
rlm@1 2751 std::swap(y1, y2);
rlm@1 2752
rlm@1 2753 gui_prepare();
rlm@1 2754
rlm@1 2755 gui_drawbox_internal(x1, y1, x2, y2, outlinecolor);
rlm@1 2756 if ((x2 - x1) >= 2 && (y2 - y1) >= 2)
rlm@1 2757 gui_fillbox_internal(x1 + 1, y1 + 1, x2 - 1, y2 - 1, fillcolor);
rlm@1 2758
rlm@1 2759 return 0;
rlm@1 2760 }
rlm@1 2761
rlm@1 2762 // gui.drawcircle(x0, y0, radius, colour)
rlm@1 2763 static int gui_drawcircle(lua_State *L)
rlm@1 2764 {
rlm@1 2765 int x, y, r;
rlm@1 2766 uint32 colour;
rlm@1 2767
rlm@1 2768 x = luaL_checkinteger(L, 1);
rlm@1 2769 y = luaL_checkinteger(L, 2);
rlm@1 2770 r = luaL_checkinteger(L, 3);
rlm@1 2771 colour = gui_getcolour(L, 4);
rlm@1 2772
rlm@1 2773 gui_prepare();
rlm@1 2774
rlm@1 2775 gui_drawcircle_internal(x, y, r, colour);
rlm@1 2776
rlm@1 2777 return 0;
rlm@1 2778 }
rlm@1 2779
rlm@1 2780 // gui.fillbox(x1, y1, x2, y2, colour)
rlm@1 2781 static int gui_fillbox(lua_State *L)
rlm@1 2782 {
rlm@1 2783 int x1, y1, x2, y2;
rlm@1 2784 uint32 colour;
rlm@1 2785
rlm@1 2786 x1 = luaL_checkinteger(L, 1);
rlm@1 2787 y1 = luaL_checkinteger(L, 2);
rlm@1 2788 x2 = luaL_checkinteger(L, 3);
rlm@1 2789 y2 = luaL_checkinteger(L, 4);
rlm@1 2790 colour = gui_getcolour(L, 5);
rlm@1 2791
rlm@1 2792 // if (!gui_check_boundary(x1, y1))
rlm@1 2793 // luaL_error(L,"bad coordinates");
rlm@1 2794 //
rlm@1 2795 // if (!gui_check_boundary(x2, y2))
rlm@1 2796 // luaL_error(L,"bad coordinates");
rlm@1 2797 gui_prepare();
rlm@1 2798
rlm@1 2799 if (!gui_checkbox(x1, y1, x2, y2))
rlm@1 2800 return 0;
rlm@1 2801
rlm@1 2802 gui_fillbox_internal(x1, y1, x2, y2, colour);
rlm@1 2803
rlm@1 2804 return 0;
rlm@1 2805 }
rlm@1 2806
rlm@1 2807 // gui.fillcircle(x0, y0, radius, colour)
rlm@1 2808 static int gui_fillcircle(lua_State *L)
rlm@1 2809 {
rlm@1 2810 int x, y, r;
rlm@1 2811 uint32 colour;
rlm@1 2812
rlm@1 2813 x = luaL_checkinteger(L, 1);
rlm@1 2814 y = luaL_checkinteger(L, 2);
rlm@1 2815 r = luaL_checkinteger(L, 3);
rlm@1 2816 colour = gui_getcolour(L, 4);
rlm@1 2817
rlm@1 2818 gui_prepare();
rlm@1 2819
rlm@1 2820 gui_fillcircle_internal(x, y, r, colour);
rlm@1 2821
rlm@1 2822 return 0;
rlm@1 2823 }
rlm@1 2824
rlm@1 2825 static int gui_getpixel(lua_State *L)
rlm@1 2826 {
rlm@1 2827 int x = luaL_checkinteger(L, 1);
rlm@1 2828 int y = luaL_checkinteger(L, 2);
rlm@1 2829
rlm@1 2830 int pixWidth = 240, pixHeight = 160;
rlm@1 2831 int scrWidth = 240, scrHeight = 160;
rlm@1 2832 int scrOffsetX = 0, scrOffsetY = 0;
rlm@1 2833 int pitch;
rlm@1 2834 if (!systemIsRunningGBA())
rlm@1 2835 {
rlm@1 2836 if (gbBorderOn)
rlm@1 2837 {
rlm@1 2838 pixWidth = 256, pixHeight = 224;
rlm@1 2839 scrOffsetX = 48, scrOffsetY = 40;
rlm@1 2840 }
rlm@1 2841 else
rlm@1 2842 {
rlm@1 2843 pixWidth = 160, pixHeight = 144;
rlm@1 2844 }
rlm@1 2845 scrWidth = 160, scrHeight = 144;
rlm@1 2846 }
rlm@1 2847 pitch = pixWidth * (systemColorDepth / 8) + (systemColorDepth == 24 ? 0 : 4);
rlm@1 2848 scrOffsetY++; // don't know why it's needed
rlm@1 2849
rlm@1 2850 if (!(x >= 0 && y >= 0 && x < scrWidth && y < scrHeight) /*!gui_check_boundary(x,y)*/)
rlm@1 2851 {
rlm@1 2852 lua_pushinteger(L, 0);
rlm@1 2853 lua_pushinteger(L, 0);
rlm@1 2854 lua_pushinteger(L, 0);
rlm@1 2855 }
rlm@1 2856 else
rlm@1 2857 {
rlm@1 2858 switch (systemColorDepth)
rlm@1 2859 {
rlm@1 2860 case 16:
rlm@1 2861 {
rlm@1 2862 uint16 *screen = (uint16 *) (&pix[scrOffsetY * pitch + scrOffsetX * 2]);
rlm@1 2863 uint16 pixColor = screen[y * pitch / 2 + x];
rlm@1 2864 lua_pushinteger(L, (pixColor >> 8) & 0xF8); // red
rlm@1 2865 lua_pushinteger(L, (pixColor >> 3) & 0xFC); // green
rlm@1 2866 lua_pushinteger(L, (pixColor << 3) & 0xF8); // blue
rlm@1 2867 }
rlm@1 2868 break;
rlm@1 2869 case 24:
rlm@1 2870 {
rlm@1 2871 uint8 *screen = &pix[scrOffsetY * pitch + scrOffsetX * 3];
rlm@1 2872 lua_pushinteger(L, screen[y * pitch + x * 3 + 2]); // red
rlm@1 2873 lua_pushinteger(L, screen[y * pitch + x * 3 + 1]); // green
rlm@1 2874 lua_pushinteger(L, screen[y * pitch + x * 3 + 0]); // blue
rlm@1 2875 }
rlm@1 2876 break;
rlm@1 2877 case 32:
rlm@1 2878 {
rlm@1 2879 uint8 *screen = &pix[scrOffsetY * pitch + scrOffsetX * 4];
rlm@1 2880 lua_pushinteger(L, screen[y * pitch + x * 4 + 2]); // red
rlm@1 2881 lua_pushinteger(L, screen[y * pitch + x * 4 + 1]); // green
rlm@1 2882 lua_pushinteger(L, screen[y * pitch + x * 4 + 0]); // blue
rlm@1 2883 }
rlm@1 2884 break;
rlm@1 2885 default:
rlm@1 2886 lua_pushinteger(L, 0);
rlm@1 2887 lua_pushinteger(L, 0);
rlm@1 2888 lua_pushinteger(L, 0);
rlm@1 2889 break;
rlm@1 2890 }
rlm@1 2891 }
rlm@1 2892 return 3;
rlm@1 2893 }
rlm@1 2894
rlm@1 2895 static int gui_parsecolor(lua_State *L)
rlm@1 2896 {
rlm@1 2897 int r, g, b, a;
rlm@1 2898 uint32 color = gui_getcolour(L, 1);
rlm@1 2899 LUA_DECOMPOSE_PIXEL(color, a, r, g, b);
rlm@1 2900 lua_pushinteger(L, r);
rlm@1 2901 lua_pushinteger(L, g);
rlm@1 2902 lua_pushinteger(L, b);
rlm@1 2903 lua_pushinteger(L, a);
rlm@1 2904 return 4;
rlm@1 2905 }
rlm@1 2906
rlm@1 2907 // gui.gdscreenshot()
rlm@1 2908 //
rlm@1 2909 // Returns a screen shot as a string in gd's v1 file format.
rlm@1 2910 // This allows us to make screen shots available without gd installed locally.
rlm@1 2911 // Users can also just grab pixels via substring selection.
rlm@1 2912 //
rlm@1 2913 // I think... Does lua support grabbing byte values from a string? // yes, string.byte(str,offset)
rlm@1 2914 // Well, either way, just install gd and do what you like with it.
rlm@1 2915 // It really is easier that way.
rlm@1 2916
rlm@1 2917 // example: gd.createFromGdStr(gui.gdscreenshot()):png("outputimage.png")
rlm@1 2918 static int gui_gdscreenshot(lua_State *L)
rlm@1 2919 {
rlm@1 2920 int xofs = 0, yofs = 0, ppl = 240, width = 240, height = 160;
rlm@1 2921 if (!systemIsRunningGBA())
rlm@1 2922 {
rlm@1 2923 if (gbBorderOn)
rlm@1 2924 xofs = 48, yofs = 40, ppl = 256;
rlm@1 2925 else
rlm@1 2926 ppl = 160;
rlm@1 2927 width = 160, height = 144;
rlm@1 2928 }
rlm@1 2929
rlm@1 2930 yofs++;
rlm@1 2931
rlm@1 2932 //int pitch = (((ppl * systemColorDepth + 7)>>3)+3)&~3;
rlm@1 2933 int pitch = ppl * (systemColorDepth / 8) + (systemColorDepth == 24 ? 0 : 4);
rlm@1 2934 uint8 *screen = &pix[yofs * pitch + xofs * (systemColorDepth / 8)];
rlm@1 2935
rlm@1 2936 int size = 11 + width * height * 4;
rlm@1 2937 char *str = new char[size + 1];
rlm@1 2938 str[size] = 0;
rlm@1 2939
rlm@1 2940 unsigned char *ptr = (unsigned char *)str;
rlm@1 2941
rlm@1 2942 // GD format header for truecolor image (11 bytes)
rlm@1 2943 *ptr++ = (65534 >> 8) & 0xFF;
rlm@1 2944 *ptr++ = (65534) & 0xFF;
rlm@1 2945 *ptr++ = (width >> 8) & 0xFF;
rlm@1 2946 *ptr++ = (width) & 0xFF;
rlm@1 2947 *ptr++ = (height >> 8) & 0xFF;
rlm@1 2948 *ptr++ = (height) & 0xFF;
rlm@1 2949 *ptr++ = 1;
rlm@1 2950 *ptr++ = 255;
rlm@1 2951 *ptr++ = 255;
rlm@1 2952 *ptr++ = 255;
rlm@1 2953 *ptr++ = 255;
rlm@1 2954
rlm@1 2955 GetColorFunc getColor;
rlm@1 2956 getColorIOFunc(systemColorDepth, &getColor, NULL);
rlm@1 2957
rlm@1 2958 int x, y;
rlm@1 2959 for (y = 0; y < height; y++)
rlm@1 2960 {
rlm@1 2961 uint8 *s = &screen[y * pitch];
rlm@1 2962 for (x = 0; x < width; x++, s += systemColorDepth / 8)
rlm@1 2963 {
rlm@1 2964 uint8 r, g, b;
rlm@1 2965 getColor(s, &r, &g, &b);
rlm@1 2966
rlm@1 2967 *ptr++ = 0;
rlm@1 2968 *ptr++ = r;
rlm@1 2969 *ptr++ = g;
rlm@1 2970 *ptr++ = b;
rlm@1 2971 }
rlm@1 2972 }
rlm@1 2973
rlm@1 2974 lua_pushlstring(L, str, size);
rlm@1 2975 delete[] str;
rlm@1 2976 return 1;
rlm@1 2977 }
rlm@1 2978
rlm@1 2979 // gui.opacity(number alphaValue)
rlm@1 2980 // sets the transparency of subsequent draw calls
rlm@1 2981 // 0.0 is completely transparent, 1.0 is completely opaque
rlm@1 2982 // non-integer values are supported and meaningful, as are values greater than 1.0
rlm@1 2983 // it is not necessary to use this function to get transparency (or the less-recommended gui.transparency() either),
rlm@1 2984 // because you can provide an alpha value in the color argument of each draw call.
rlm@1 2985
rlm@1 2986 // however, it can be convenient to be able to globally modify the drawing transparency
rlm@1 2987 static int gui_setopacity(lua_State *L)
rlm@1 2988 {
rlm@1 2989 double opacF = luaL_checknumber(L, 1);
rlm@1 2990 transparencyModifier = (int)(opacF * 255);
rlm@1 2991 if (transparencyModifier < 0)
rlm@1 2992 transparencyModifier = 0;
rlm@1 2993 return 0;
rlm@1 2994 }
rlm@1 2995
rlm@1 2996 // gui.transparency(int strength)
rlm@1 2997 //
rlm@1 2998
rlm@1 2999 // 0 = solid,
rlm@1 3000 static int gui_transparency(lua_State *L)
rlm@1 3001 {
rlm@1 3002 double trans = luaL_checknumber(L, 1);
rlm@1 3003 transparencyModifier = (int)((4.0 - trans) / 4.0 * 255);
rlm@1 3004 if (transparencyModifier < 0)
rlm@1 3005 transparencyModifier = 0;
rlm@1 3006 return 0;
rlm@1 3007 }
rlm@1 3008
rlm@1 3009 static const uint32 Small_Font_Data[] =
rlm@1 3010 {
rlm@1 3011 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 32
rlm@1 3012 0x00000000, 0x00000300, 0x00000400, 0x00000500, 0x00000000, 0x00000700, 0x00000000, // 33 !
rlm@1 3013 0x00000000, 0x00040002, 0x00050003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 34 "
rlm@1 3014 0x00000000, 0x00040002, 0x00050403, 0x00060004, 0x00070605, 0x00080006, 0x00000000, // 35 #
rlm@1 3015 0x00000000, 0x00040300, 0x00000403, 0x00000500, 0x00070600, 0x00000706, 0x00000000, // 36 $
rlm@1 3016 0x00000000, 0x00000002, 0x00050000, 0x00000500, 0x00000005, 0x00080000, 0x00000000, // 37 %
rlm@1 3017 0x00000000, 0x00000300, 0x00050003, 0x00000500, 0x00070005, 0x00080700, 0x00000000, // 38 &
rlm@1 3018 0x00000000, 0x00000300, 0x00000400, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 39 '
rlm@1 3019 0x00000000, 0x00000300, 0x00000003, 0x00000004, 0x00000005, 0x00000700, 0x00000000, // 40 (
rlm@1 3020 0x00000000, 0x00000300, 0x00050000, 0x00060000, 0x00070000, 0x00000700, 0x00000000, // 41 )
rlm@1 3021 0x00000000, 0x00000000, 0x00000400, 0x00060504, 0x00000600, 0x00080006, 0x00000000, // 42 *
rlm@1 3022 0x00000000, 0x00000000, 0x00000400, 0x00060504, 0x00000600, 0x00000000, 0x00000000, // 43 +
rlm@1 3023 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000600, 0x00000700, 0x00000007, // 44 ,
rlm@1 3024 0x00000000, 0x00000000, 0x00000000, 0x00060504, 0x00000000, 0x00000000, 0x00000000, // 45 -
rlm@1 3025 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000700, 0x00000000, // 46 .
rlm@1 3026 0x00030000, 0x00040000, 0x00000400, 0x00000500, 0x00000005, 0x00000006, 0x00000000, // 47 /
rlm@1 3027 0x00000000, 0x00000300, 0x00050003, 0x00060004, 0x00070005, 0x00000700, 0x00000000, // 48 0
rlm@1 3028 0x00000000, 0x00000300, 0x00000403, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 49 1
rlm@1 3029 0x00000000, 0x00000302, 0x00050000, 0x00000500, 0x00000005, 0x00080706, 0x00000000, // 50 2
rlm@1 3030 0x00000000, 0x00000302, 0x00050000, 0x00000504, 0x00070000, 0x00000706, 0x00000000, // 51 3
rlm@1 3031 0x00000000, 0x00000300, 0x00000003, 0x00060004, 0x00070605, 0x00080000, 0x00000000, // 52 4
rlm@1 3032 0x00000000, 0x00040302, 0x00000003, 0x00000504, 0x00070000, 0x00000706, 0x00000000, // 53 5
rlm@1 3033 0x00000000, 0x00000300, 0x00000003, 0x00000504, 0x00070005, 0x00000700, 0x00000000, // 54 6
rlm@1 3034 0x00000000, 0x00040302, 0x00050000, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 55 7
rlm@1 3035 0x00000000, 0x00000300, 0x00050003, 0x00000500, 0x00070005, 0x00000700, 0x00000000, // 56 8
rlm@1 3036 0x00000000, 0x00000300, 0x00050003, 0x00060500, 0x00070000, 0x00000700, 0x00000000, // 57 9
rlm@1 3037 0x00000000, 0x00000000, 0x00000400, 0x00000000, 0x00000000, 0x00000700, 0x00000000, // 58 :
rlm@1 3038 0x00000000, 0x00000000, 0x00000000, 0x00000500, 0x00000000, 0x00000700, 0x00000007, // 59 ;
rlm@1 3039 0x00000000, 0x00040000, 0x00000400, 0x00000004, 0x00000600, 0x00080000, 0x00000000, // 60 <
rlm@1 3040 0x00000000, 0x00000000, 0x00050403, 0x00000000, 0x00070605, 0x00000000, 0x00000000, // 61 =
rlm@1 3041 0x00000000, 0x00000002, 0x00000400, 0x00060000, 0x00000600, 0x00000006, 0x00000000, // 62 >
rlm@1 3042 0x00000000, 0x00000302, 0x00050000, 0x00000500, 0x00000000, 0x00000700, 0x00000000, // 63 ?
rlm@1 3043 0x00000000, 0x00000300, 0x00050400, 0x00060004, 0x00070600, 0x00000000, 0x00000000, // 64 @
rlm@1 3044 0x00000000, 0x00000300, 0x00050003, 0x00060504, 0x00070005, 0x00080006, 0x00000000, // 65 A
rlm@1 3045 0x00000000, 0x00000302, 0x00050003, 0x00000504, 0x00070005, 0x00000706, 0x00000000, // 66 B
rlm@1 3046 0x00000000, 0x00040300, 0x00000003, 0x00000004, 0x00000005, 0x00080700, 0x00000000, // 67 C
rlm@1 3047 0x00000000, 0x00000302, 0x00050003, 0x00060004, 0x00070005, 0x00000706, 0x00000000, // 68 D
rlm@1 3048 0x00000000, 0x00040302, 0x00000003, 0x00000504, 0x00000005, 0x00080706, 0x00000000, // 69 E
rlm@1 3049 0x00000000, 0x00040302, 0x00000003, 0x00000504, 0x00000005, 0x00000006, 0x00000000, // 70 F
rlm@1 3050 0x00000000, 0x00040300, 0x00000003, 0x00060004, 0x00070005, 0x00080700, 0x00000000, // 71 G
rlm@1 3051 0x00000000, 0x00040002, 0x00050003, 0x00060504, 0x00070005, 0x00080006, 0x00000000, // 72 H
rlm@1 3052 0x00000000, 0x00000300, 0x00000400, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 73 I
rlm@1 3053 0x00000000, 0x00040000, 0x00050000, 0x00060000, 0x00070005, 0x00000700, 0x00000000, // 74 J
rlm@1 3054 0x00000000, 0x00040002, 0x00050003, 0x00000504, 0x00070005, 0x00080006, 0x00000000, // 75 K
rlm@1 3055 0x00000000, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00080706, 0x00000000, // 76 l
rlm@1 3056 0x00000000, 0x00040002, 0x00050403, 0x00060004, 0x00070005, 0x00080006, 0x00000000, // 77 M
rlm@1 3057 0x00000000, 0x00000302, 0x00050003, 0x00060004, 0x00070005, 0x00080006, 0x00000000, // 78 N
rlm@1 3058 0x00000000, 0x00040302, 0x00050003, 0x00060004, 0x00070005, 0x00080706, 0x00000000, // 79 O
rlm@1 3059 0x00000000, 0x00000302, 0x00050003, 0x00000504, 0x00000005, 0x00000006, 0x00000000, // 80 P
rlm@1 3060 0x00000000, 0x00040302, 0x00050003, 0x00060004, 0x00070005, 0x00080706, 0x00090000, // 81 Q
rlm@1 3061 0x00000000, 0x00000302, 0x00050003, 0x00000504, 0x00070005, 0x00080006, 0x00000000, // 82 R
rlm@1 3062 0x00000000, 0x00040300, 0x00000003, 0x00000500, 0x00070000, 0x00000706, 0x00000000, // 83 S
rlm@1 3063 0x00000000, 0x00040302, 0x00000400, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 84 T
rlm@1 3064 0x00000000, 0x00040002, 0x00050003, 0x00060004, 0x00070005, 0x00080706, 0x00000000, // 85 U
rlm@1 3065 0x00000000, 0x00040002, 0x00050003, 0x00060004, 0x00000600, 0x00000700, 0x00000000, // 86 V
rlm@1 3066 0x00000000, 0x00040002, 0x00050003, 0x00060004, 0x00070605, 0x00080006, 0x00000000, // 87 W
rlm@1 3067 0x00000000, 0x00040002, 0x00050003, 0x00000500, 0x00070005, 0x00080006, 0x00000000, // 88 X
rlm@1 3068 0x00000000, 0x00040002, 0x00050003, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 89 Y
rlm@1 3069 0x00000000, 0x00040302, 0x00050000, 0x00000500, 0x00000005, 0x00080706, 0x00000000, // 90 Z
rlm@1 3070 0x00000000, 0x00040300, 0x00000400, 0x00000500, 0x00000600, 0x00080700, 0x00000000, // 91 [
rlm@1 3071 0x00000000, 0x00000002, 0x00000400, 0x00000500, 0x00070000, 0x00080000, 0x00000000, // 92 '\'
rlm@1 3072 0x00000000, 0x00000302, 0x00000400, 0x00000500, 0x00000600, 0x00000706, 0x00000000, // 93 ]
rlm@1 3073 0x00000000, 0x00000300, 0x00050003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 94 ^
rlm@1 3074 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00080706, 0x00000000, // 95 _
rlm@1 3075 0x00000000, 0x00000002, 0x00000400, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 96 `
rlm@1 3076 0x00000000, 0x00000000, 0x00050400, 0x00060004, 0x00070005, 0x00080700, 0x00000000, // 97 a
rlm@1 3077 0x00000000, 0x00000002, 0x00000003, 0x00000504, 0x00070005, 0x00000706, 0x00000000, // 98 b
rlm@1 3078 0x00000000, 0x00000000, 0x00050400, 0x00000004, 0x00000005, 0x00080700, 0x00000000, // 99 c
rlm@1 3079 0x00000000, 0x00040000, 0x00050000, 0x00060500, 0x00070005, 0x00080700, 0x00000000, // 100 d
rlm@1 3080 0x00000000, 0x00000000, 0x00050400, 0x00060504, 0x00000005, 0x00080700, 0x00000000, // 101 e
rlm@1 3081 0x00000000, 0x00040300, 0x00000003, 0x00000504, 0x00000005, 0x00000006, 0x00000000, // 102 f
rlm@1 3082 0x00000000, 0x00000000, 0x00050400, 0x00060004, 0x00070600, 0x00080000, 0x00000807, // 103 g
rlm@1 3083 0x00000000, 0x00000002, 0x00000003, 0x00000504, 0x00070005, 0x00080006, 0x00000000, // 104 h
rlm@1 3084 0x00000000, 0x00000300, 0x00000000, 0x00000500, 0x00000600, 0x00000700, 0x00000000, // 105 i
rlm@1 3085 0x00000000, 0x00000300, 0x00000000, 0x00000500, 0x00000600, 0x00000700, 0x00000007, // 106 j
rlm@1 3086 0x00000000, 0x00000002, 0x00000003, 0x00060004, 0x00000605, 0x00080006, 0x00000000, // 107 k
rlm@1 3087 0x00000000, 0x00000300, 0x00000400, 0x00000500, 0x00000600, 0x00080000, 0x00000000, // 108 l
rlm@1 3088 0x00000000, 0x00000000, 0x00050003, 0x00060504, 0x00070005, 0x00080006, 0x00000000, // 109 m
rlm@1 3089 0x00000000, 0x00000000, 0x00000403, 0x00060004, 0x00070005, 0x00080006, 0x00000000, // 110 n
rlm@1 3090 0x00000000, 0x00000000, 0x00000400, 0x00060004, 0x00070005, 0x00000700, 0x00000000, // 111 o
rlm@1 3091 0x00000000, 0x00000000, 0x00000400, 0x00060004, 0x00000605, 0x00000006, 0x00000007, // 112 p
rlm@1 3092 0x00000000, 0x00000000, 0x00000400, 0x00060004, 0x00070600, 0x00080000, 0x00090000, // 113 q
rlm@1 3093 0x00000000, 0x00000000, 0x00050003, 0x00000504, 0x00000005, 0x00000006, 0x00000000, // 114 r
rlm@1 3094 0x00000000, 0x00000000, 0x00050400, 0x00000004, 0x00070600, 0x00000706, 0x00000000, // 115 s
rlm@1 3095 0x00000000, 0x00000300, 0x00050403, 0x00000500, 0x00000600, 0x00080000, 0x00000000, // 116 t
rlm@1 3096 0x00000000, 0x00000000, 0x00050003, 0x00060004, 0x00070005, 0x00080700, 0x00000000, // 117 u
rlm@1 3097 0x00000000, 0x00000000, 0x00050003, 0x00060004, 0x00070005, 0x00000700, 0x00000000, // 118 v
rlm@1 3098 0x00000000, 0x00000000, 0x00050003, 0x00060004, 0x00070605, 0x00080006, 0x00000000, // 119 w
rlm@1 3099 0x00000000, 0x00000000, 0x00050003, 0x00000500, 0x00070005, 0x00080006, 0x00000000, // 120 x
rlm@1 3100 0x00000000, 0x00000000, 0x00050003, 0x00060004, 0x00000600, 0x00000700, 0x00000007, // 121 y
rlm@1 3101 0x00000000, 0x00000000, 0x00050403, 0x00000500, 0x00000005, 0x00080706, 0x00000000, // 122 z
rlm@1 3102 0x00000000, 0x00040300, 0x00000400, 0x00000504, 0x00000600, 0x00080700, 0x00000000, // 123 {
rlm@1 3103 0x00000000, 0x00000300, 0x00000400, 0x00000000, 0x00000600, 0x00000700, 0x00000000, // 124 |
rlm@1 3104 0x00000000, 0x00000302, 0x00000400, 0x00060500, 0x00000600, 0x00000706, 0x00000000, // 125 }
rlm@1 3105 0x00000000, 0x00000302, 0x00050000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // 126 ~
rlm@1 3106 0x00000000, 0x00000000, 0x00000400, 0x00060004, 0x00070605, 0x00000000, 0x00000000, // 127 
rlm@1 3107 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
rlm@1 3108 };
rlm@1 3109
rlm@1 3110 static void PutTextInternal(const char *str, int len, short x, short y, int color, int backcolor)
rlm@1 3111 {
rlm@1 3112 int Opac = (color >> 24) & 0xFF;
rlm@1 3113 int backOpac = (backcolor >> 24) & 0xFF;
rlm@1 3114 int origX = x;
rlm@1 3115
rlm@1 3116 if (!Opac && !backOpac)
rlm@1 3117 return;
rlm@1 3118
rlm@1 3119 while (*str && len && y < LUA_SCREEN_HEIGHT)
rlm@1 3120 {
rlm@1 3121 int c = *str++;
rlm@1 3122 while (x > LUA_SCREEN_WIDTH && c != '\n')
rlm@1 3123 {
rlm@1 3124 c = *str;
rlm@1 3125 if (c == '\0')
rlm@1 3126 break;
rlm@1 3127 str++;
rlm@1 3128 }
rlm@1 3129
rlm@1 3130 if (c == '\n')
rlm@1 3131 {
rlm@1 3132 x = origX;
rlm@1 3133 y += 8;
rlm@1 3134 continue;
rlm@1 3135 }
rlm@1 3136 else if (c == '\t') // just in case
rlm@1 3137 {
rlm@1 3138 const int tabSpace = 8;
rlm@1 3139 x += (tabSpace - (((x - origX) / 4) % tabSpace)) * 4;
rlm@1 3140 continue;
rlm@1 3141 }
rlm@1 3142
rlm@1 3143 if ((unsigned int)(c - 32) >= 96)
rlm@1 3144 continue;
rlm@1 3145
rlm@1 3146 const unsigned char *Cur_Glyph = (const unsigned char *) &Small_Font_Data + (c - 32) * 7 * 4;
rlm@1 3147
rlm@1 3148 for (int y2 = 0; y2 < 8; y2++)
rlm@1 3149 {
rlm@1 3150 unsigned int glyphLine = *((unsigned int *)Cur_Glyph + y2);
rlm@1 3151 for (int x2 = -1; x2 < 4; x2++)
rlm@1 3152 {
rlm@1 3153 int shift = x2 << 3;
rlm@1 3154 int mask = 0xFF << shift;
rlm@1 3155 int intensity = (glyphLine & mask) >> shift;
rlm@1 3156
rlm@1 3157 if (intensity && x2 >= 0 && y2 < 7)
rlm@1 3158 {
rlm@1 3159 //int xdraw = max(0,min(LUA_SCREEN_WIDTH - 1,x+x2));
rlm@1 3160 //int ydraw = max(0,min(LUA_SCREEN_HEIGHT - 1,y+y2));
rlm@1 3161 //gui_drawpixel_fast(xdraw, ydraw, color);
rlm@1 3162 gui_drawpixel_internal(x + x2, y + y2, color);
rlm@1 3163 }
rlm@1 3164 else if (backOpac)
rlm@1 3165 {
rlm@1 3166 for (int y3 = max(0, y2 - 1); y3 <= min(6, y2 + 1); y3++)
rlm@1 3167 {
rlm@1 3168 unsigned int glyphLine = *((unsigned int *)Cur_Glyph + y3);
rlm@1 3169 for (int x3 = max(0, x2 - 1); x3 <= min(3, x2 + 1); x3++)
rlm@1 3170 {
rlm@1 3171 int shift = x3 << 3;
rlm@1 3172 int mask = 0xFF << shift;
rlm@1 3173 intensity |= (glyphLine & mask) >> shift;
rlm@1 3174 if (intensity)
rlm@1 3175 goto draw_outline; // speedup?
rlm@1 3176 }
rlm@1 3177 }
rlm@1 3178
rlm@1 3179 draw_outline:
rlm@1 3180 if (intensity)
rlm@1 3181 {
rlm@1 3182 //int xdraw = max(0,min(LUA_SCREEN_WIDTH - 1,x+x2));
rlm@1 3183 //int ydraw = max(0,min(LUA_SCREEN_HEIGHT - 1,y+y2));
rlm@1 3184 //gui_drawpixel_fast(xdraw, ydraw, backcolor);
rlm@1 3185 gui_drawpixel_internal(x + x2, y + y2, backcolor);
rlm@1 3186 }
rlm@1 3187 }
rlm@1 3188 }
rlm@1 3189 }
rlm@1 3190
rlm@1 3191 x += 4;
rlm@1 3192 len--;
rlm@1 3193 }
rlm@1 3194 }
rlm@1 3195
rlm@1 3196 static int strlinelen(const char *string)
rlm@1 3197 {
rlm@1 3198 const char *s = string;
rlm@1 3199 while (*s && *s != '\n')
rlm@1 3200 s++;
rlm@1 3201 if (*s)
rlm@1 3202 s++;
rlm@1 3203 return s - string;
rlm@1 3204 }
rlm@1 3205
rlm@1 3206 static void LuaDisplayString(const char *string, int y, int x, uint32 color, uint32 outlineColor)
rlm@1 3207 {
rlm@1 3208 if (!string)
rlm@1 3209 return;
rlm@1 3210
rlm@1 3211 gui_prepare();
rlm@1 3212
rlm@1 3213 PutTextInternal(string, strlen(string), x, y, color, outlineColor);
rlm@1 3214
rlm@1 3215 /*
rlm@1 3216 const char* ptr = string;
rlm@1 3217 while(*ptr && y < LUA_SCREEN_HEIGHT)
rlm@1 3218 {
rlm@1 3219 int len = strlinelen(ptr);
rlm@1 3220 int skip = 0;
rlm@1 3221 if(len < 1) len = 1;
rlm@1 3222
rlm@1 3223 // break up the line if it's too long to display otherwise
rlm@1 3224 if(len > 63)
rlm@1 3225 {
rlm@1 3226 len = 63;
rlm@1 3227 const char* ptr2 = ptr + len-1;
rlm@1 3228 for(int j = len-1; j; j--, ptr2--)
rlm@1 3229 {
rlm@1 3230 if(*ptr2 == ' ' || *ptr2 == '\t')
rlm@1 3231 {
rlm@1 3232 len = j;
rlm@1 3233 skip = 1;
rlm@1 3234 break;
rlm@1 3235 }
rlm@1 3236 }
rlm@1 3237 }
rlm@1 3238
rlm@1 3239 int xl = 0;
rlm@1 3240 int yl = 0;
rlm@1 3241 int xh = (LUA_SCREEN_WIDTH - 1 - 1) - 4*len;
rlm@1 3242 int yh = LUA_SCREEN_HEIGHT - 1;
rlm@1 3243 int x2 = min(max(x,xl),xh);
rlm@1 3244 int y2 = min(max(y,yl),yh);
rlm@1 3245
rlm@1 3246 PutTextInternal(ptr,len,x2,y2,color,outlineColor);
rlm@1 3247
rlm@1 3248 ptr += len + skip;
rlm@1 3249 y += 8;
rlm@1 3250 }
rlm@1 3251 */
rlm@1 3252 }
rlm@1 3253
rlm@1 3254 // gui.text(int x, int y, string msg)
rlm@1 3255 //
rlm@1 3256 // Displays the given text on the screen, using the same font and techniques as the
rlm@1 3257
rlm@1 3258 // main HUD.
rlm@1 3259 static int gui_text(lua_State *L)
rlm@1 3260 {
rlm@1 3261 //extern int font_height;
rlm@1 3262 const char *msg;
rlm@1 3263 int x, y;
rlm@1 3264 uint32 colour, borderColour;
rlm@1 3265
rlm@1 3266 x = luaL_checkinteger(L, 1);
rlm@1 3267 y = luaL_checkinteger(L, 2);
rlm@1 3268 //msg = luaL_checkstring(L, 3);
rlm@1 3269 msg = toCString(L, 3);
rlm@1 3270
rlm@1 3271 // if (x < 0 || x >= LUA_SCREEN_WIDTH || y < 0 || y >= (LUA_SCREEN_HEIGHT - font_height))
rlm@1 3272 // luaL_error(L,"bad coordinates");
rlm@1 3273 colour = gui_optcolour(L, 4, LUA_BUILD_PIXEL(255, 255, 255, 255));
rlm@1 3274 borderColour = gui_optcolour(L, 5, LUA_BUILD_PIXEL(255, 0, 0, 0));
rlm@1 3275
rlm@1 3276 gui_prepare();
rlm@1 3277
rlm@1 3278 LuaDisplayString(msg, y, x, colour, borderColour);
rlm@1 3279
rlm@1 3280 return 0;
rlm@1 3281 }
rlm@1 3282
rlm@1 3283 // gui.gdoverlay([int dx=0, int dy=0,] string str [, sx=0, sy=0, sw, sh] [, float alphamul=1.0])
rlm@1 3284 //
rlm@1 3285 // Overlays the given image on the screen.
rlm@1 3286
rlm@1 3287 // example: gui.gdoverlay(gd.createFromPng("myimage.png"):gdStr())
rlm@1 3288 static int gui_gdoverlay(lua_State *L)
rlm@1 3289 {
rlm@1 3290 int argCount = lua_gettop(L);
rlm@1 3291
rlm@1 3292 int xStartDst = 0;
rlm@1 3293 int yStartDst = 0;
rlm@1 3294 int xStartSrc = 0;
rlm@1 3295 int yStartSrc = 0;
rlm@1 3296
rlm@1 3297 int index = 1;
rlm@1 3298 if (lua_type(L, index) == LUA_TNUMBER)
rlm@1 3299 {
rlm@1 3300 xStartDst = lua_tointeger(L, index++);
rlm@1 3301 if (lua_type(L, index) == LUA_TNUMBER)
rlm@1 3302 yStartDst = lua_tointeger(L, index++);
rlm@1 3303 }
rlm@1 3304
rlm@1 3305 luaL_checktype(L, index, LUA_TSTRING);
rlm@1 3306
rlm@1 3307 const unsigned char *ptr = (const unsigned char *)lua_tostring(L, index++);
rlm@1 3308
rlm@1 3309 if (ptr[0] != 255 || (ptr[1] != 254 && ptr[1] != 255))
rlm@1 3310 luaL_error(L, "bad image data");
rlm@1 3311
rlm@1 3312 bool trueColor = (ptr[1] == 254);
rlm@1 3313 ptr += 2;
rlm@1 3314
rlm@1 3315 int imgwidth = *ptr++ << 8;
rlm@1 3316 imgwidth |= *ptr++;
rlm@1 3317
rlm@1 3318 int width = imgwidth;
rlm@1 3319 int imgheight = *ptr++ << 8;
rlm@1 3320 imgheight |= *ptr++;
rlm@1 3321
rlm@1 3322 int height = imgheight;
rlm@1 3323 if ((!trueColor && *ptr) || (trueColor && !*ptr))
rlm@1 3324 luaL_error(L, "bad image data");
rlm@1 3325 ptr++;
rlm@1 3326
rlm@1 3327 int pitch = imgwidth * (trueColor ? 4 : 1);
rlm@1 3328
rlm@1 3329 if ((argCount - index + 1) >= 4)
rlm@1 3330 {
rlm@1 3331 xStartSrc = luaL_checkinteger(L, index++);
rlm@1 3332 yStartSrc = luaL_checkinteger(L, index++);
rlm@1 3333 width = luaL_checkinteger(L, index++);
rlm@1 3334 height = luaL_checkinteger(L, index++);
rlm@1 3335 }
rlm@1 3336
rlm@1 3337 int alphaMul = transparencyModifier;
rlm@1 3338 if (lua_isnumber(L, index))
rlm@1 3339 alphaMul = (int)(alphaMul * lua_tonumber(L, index++));
rlm@1 3340 if (alphaMul <= 0)
rlm@1 3341 return 0;
rlm@1 3342
rlm@1 3343 // since there aren't that many possible opacity levels,
rlm@1 3344 // do the opacity modification calculations beforehand instead of per pixel
rlm@1 3345 int opacMap[256];
rlm@1 3346 for (int i = 0; i < 128; i++)
rlm@1 3347 {
rlm@1 3348 int opac = 255 - ((i << 1) | (i & 1)); // gdAlphaMax = 127, not 255
rlm@1 3349 opac = (opac * alphaMul) / 255;
rlm@1 3350 if (opac < 0)
rlm@1 3351 opac = 0;
rlm@1 3352 if (opac > 255)
rlm@1 3353 opac = 255;
rlm@1 3354 opacMap[i] = opac;
rlm@1 3355 }
rlm@1 3356
rlm@1 3357 for (int i = 128; i < 256; i++)
rlm@1 3358 opacMap[i] = 0; // what should we do for them, actually?
rlm@1 3359 int colorsTotal = 0;
rlm@1 3360 if (!trueColor)
rlm@1 3361 {
rlm@1 3362 colorsTotal = *ptr++ << 8;
rlm@1 3363 colorsTotal |= *ptr++;
rlm@1 3364 }
rlm@1 3365
rlm@1 3366 int transparent = *ptr++ << 24;
rlm@1 3367 transparent |= *ptr++ << 16;
rlm@1 3368 transparent |= *ptr++ << 8;
rlm@1 3369 transparent |= *ptr++;
rlm@1 3370 struct
rlm@1 3371 {
rlm@1 3372 uint8 r, g, b, a;
rlm@1 3373 } pal[256];
rlm@1 3374 if (!trueColor)
rlm@1 3375 for (int i = 0; i < 256; i++)
rlm@1 3376 {
rlm@1 3377 pal[i].r = *ptr++;
rlm@1 3378 pal[i].g = *ptr++;
rlm@1 3379 pal[i].b = *ptr++;
rlm@1 3380 pal[i].a = opacMap[*ptr++];
rlm@1 3381 }
rlm@1 3382
rlm@1 3383 // some of clippings
rlm@1 3384 if (xStartSrc < 0)
rlm@1 3385 {
rlm@1 3386 width += xStartSrc;
rlm@1 3387 xStartDst -= xStartSrc;
rlm@1 3388 xStartSrc = 0;
rlm@1 3389 }
rlm@1 3390
rlm@1 3391 if (yStartSrc < 0)
rlm@1 3392 {
rlm@1 3393 height += yStartSrc;
rlm@1 3394 yStartDst -= yStartSrc;
rlm@1 3395 yStartSrc = 0;
rlm@1 3396 }
rlm@1 3397
rlm@1 3398 if (xStartSrc + width >= imgwidth)
rlm@1 3399 width = imgwidth - xStartSrc;
rlm@1 3400 if (yStartSrc + height >= imgheight)
rlm@1 3401 height = imgheight - yStartSrc;
rlm@1 3402 if (xStartDst < 0)
rlm@1 3403 {
rlm@1 3404 width += xStartDst;
rlm@1 3405 if (width <= 0)
rlm@1 3406 return 0;
rlm@1 3407 xStartSrc = -xStartDst;
rlm@1 3408 xStartDst = 0;
rlm@1 3409 }
rlm@1 3410
rlm@1 3411 if (yStartDst < 0)
rlm@1 3412 {
rlm@1 3413 height += yStartDst;
rlm@1 3414 if (height <= 0)
rlm@1 3415 return 0;
rlm@1 3416 yStartSrc = -yStartDst;
rlm@1 3417 yStartDst = 0;
rlm@1 3418 }
rlm@1 3419
rlm@1 3420 if (xStartDst + width >= LUA_SCREEN_WIDTH)
rlm@1 3421 width = LUA_SCREEN_WIDTH - xStartDst;
rlm@1 3422 if (yStartDst + height >= LUA_SCREEN_HEIGHT)
rlm@1 3423 height = LUA_SCREEN_HEIGHT - yStartDst;
rlm@1 3424 if (width <= 0 || height <= 0)
rlm@1 3425 return 0; // out of screen or invalid size
rlm@1 3426 gui_prepare();
rlm@1 3427
rlm@1 3428 const uint8 *pix = (const uint8 *)(&ptr[yStartSrc * pitch + (xStartSrc * (trueColor ? 4 : 1))]);
rlm@1 3429 int bytesToNextLine = pitch - (width * (trueColor ? 4 : 1));
rlm@1 3430 if (trueColor)
rlm@1 3431 {
rlm@1 3432 for (int y = yStartDst; y < height + yStartDst && y < LUA_SCREEN_HEIGHT; y++, pix += bytesToNextLine)
rlm@1 3433 {
rlm@1 3434 for (int x = xStartDst; x < width + xStartDst && x < LUA_SCREEN_WIDTH; x++, pix += 4)
rlm@1 3435 {
rlm@1 3436 gui_drawpixel_fast(x, y, LUA_BUILD_PIXEL(opacMap[pix[0]], pix[1], pix[2], pix[3]));
rlm@1 3437 }
rlm@1 3438 }
rlm@1 3439 }
rlm@1 3440 else
rlm@1 3441 {
rlm@1 3442 for (int y = yStartDst; y < height + yStartDst && y < LUA_SCREEN_HEIGHT; y++, pix += bytesToNextLine)
rlm@1 3443 {
rlm@1 3444 for (int x = xStartDst; x < width + xStartDst && x < LUA_SCREEN_WIDTH; x++, pix++)
rlm@1 3445 {
rlm@1 3446 gui_drawpixel_fast(x, y, LUA_BUILD_PIXEL(pal[*pix].a, pal[*pix].r, pal[*pix].g, pal[*pix].b));
rlm@1 3447 }
rlm@1 3448 }
rlm@1 3449 }
rlm@1 3450
rlm@1 3451 return 0;
rlm@1 3452 }
rlm@1 3453
rlm@1 3454 // function gui.register(function f)
rlm@1 3455 //
rlm@1 3456 // This function will be called just before a graphical update.
rlm@1 3457 // More complicated, but doesn't suffer any frame delays.
rlm@1 3458 // Nil will be accepted in place of a function to erase
rlm@1 3459 // a previously registered function, and the previous function
rlm@1 3460
rlm@1 3461 // (if any) is returned, or nil if none.
rlm@1 3462 static int gui_register(lua_State *L)
rlm@1 3463 {
rlm@1 3464 // We'll do this straight up.
rlm@1 3465 // First set up the stack.
rlm@1 3466 lua_settop(L, 1);
rlm@1 3467
rlm@1 3468 // Verify the validity of the entry
rlm@1 3469 if (!lua_isnil(L, 1))
rlm@1 3470 luaL_checktype(L, 1, LUA_TFUNCTION);
rlm@1 3471
rlm@1 3472 // Get the old value
rlm@1 3473 lua_getfield(L, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 3474
rlm@1 3475 // Save the new value
rlm@1 3476 lua_pushvalue(L, 1);
rlm@1 3477 lua_setfield(L, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 3478
rlm@1 3479 // The old value is on top of the stack. Return it.
rlm@1 3480 return 1;
rlm@1 3481 }
rlm@1 3482
rlm@1 3483 // string gui.popup(string message, [string type = "ok"])
rlm@1 3484 //
rlm@1 3485
rlm@1 3486 // Popup dialog!
rlm@1 3487 int gui_popup(lua_State *L)
rlm@1 3488 {
rlm@1 3489 const char *message = luaL_checkstring(L, 1);
rlm@1 3490 const char *type = luaL_optstring(L, 2, "ok");
rlm@1 3491
rlm@1 3492 #if (defined(WIN32) && !defined(SDL))
rlm@1 3493 int t;
rlm@1 3494 if (strcmp(type, "ok") == 0)
rlm@1 3495 t = MB_OK;
rlm@1 3496 else if (strcmp(type, "yesno") == 0)
rlm@1 3497 t = MB_YESNO;
rlm@1 3498 else if (strcmp(type, "yesnocancel") == 0)
rlm@1 3499 t = MB_YESNOCANCEL;
rlm@1 3500 else
rlm@1 3501 return luaL_error(L, "invalid popup type \"%s\"", type);
rlm@1 3502
rlm@1 3503 theApp.winCheckFullscreen();
rlm@1 3504 systemSoundClearBuffer();
rlm@1 3505 int result = AfxGetApp()->m_pMainWnd->MessageBox(message, "Lua Script Pop-up", t);
rlm@1 3506
rlm@1 3507 lua_settop(L, 1);
rlm@1 3508
rlm@1 3509 if (t != MB_OK)
rlm@1 3510 {
rlm@1 3511 if (result == IDYES)
rlm@1 3512 lua_pushstring(L, "yes");
rlm@1 3513 else if (result == IDNO)
rlm@1 3514 lua_pushstring(L, "no");
rlm@1 3515 else if (result == IDCANCEL)
rlm@1 3516 lua_pushstring(L, "cancel");
rlm@1 3517 else
rlm@1 3518 luaL_error(L, "win32 unrecognized return value %d", result);
rlm@1 3519 return 1;
rlm@1 3520 }
rlm@1 3521
rlm@1 3522 // else, we don't care.
rlm@1 3523 return 0;
rlm@1 3524 #else
rlm@1 3525 char *t;
rlm@1 3526 #ifdef __linux
rlm@1 3527 // The Linux backend has a "FromPause" variable.
rlm@1 3528 // If set to 1, assume some known external event has screwed with the flow of time.
rlm@1 3529 // Since this pauses the emulator waiting for a response, we set it to 1.
rlm@1 3530 // FIXME: Well, actually it doesn't
rlm@1 3531 // extern int FromPause;
rlm@1 3532 // FromPause = 1;
rlm@1 3533
rlm@1 3534 int pid; // appease compiler
rlm@1 3535
rlm@1 3536 // Before doing any work, verify the correctness of the parameters.
rlm@1 3537 if (strcmp(type, "ok") == 0)
rlm@1 3538 t = "OK:100";
rlm@1 3539 else if (strcmp(type, "yesno") == 0)
rlm@1 3540 t = "Yes:100,No:101";
rlm@1 3541 else if (strcmp(type, "yesnocancel") == 0)
rlm@1 3542 t = "Yes:100,No:101,Cancel:102";
rlm@1 3543 else
rlm@1 3544 return luaL_error(L, "invalid popup type \"%s\"", type);
rlm@1 3545
rlm@1 3546 // Can we find a copy of xmessage? Search the path.
rlm@1 3547 char *path = strdup(getenv("PATH"));
rlm@1 3548
rlm@1 3549 char *current = path;
rlm@1 3550
rlm@1 3551 char *colon;
rlm@1 3552
rlm@1 3553 int found = 0;
rlm@1 3554
rlm@1 3555 while (current)
rlm@1 3556 {
rlm@1 3557 colon = strchr(current, ':');
rlm@1 3558
rlm@1 3559 // Clip off the colon.
rlm@1 3560 *colon++ = 0;
rlm@1 3561
rlm@1 3562 int len = strlen(current);
rlm@1 3563 char *filename = (char *)malloc(len + 12); // always give excess
rlm@1 3564 snprintf(filename, len + 12, "%s/xmessage", current);
rlm@1 3565
rlm@1 3566 if (access(filename, X_OK) == 0)
rlm@1 3567 {
rlm@1 3568 free(filename);
rlm@1 3569 found = 1;
rlm@1 3570 break;
rlm@1 3571 }
rlm@1 3572
rlm@1 3573 // Failed, move on.
rlm@1 3574 current = colon;
rlm@1 3575 free(filename);
rlm@1 3576 }
rlm@1 3577
rlm@1 3578 free(path);
rlm@1 3579
rlm@1 3580 // We've found it?
rlm@1 3581 if (!found)
rlm@1 3582 goto use_console;
rlm@1 3583
rlm@1 3584 pid = fork();
rlm@1 3585 if (pid == 0)
rlm@1 3586 { // I'm the virgin sacrifice
rlm@1 3587 // I'm gonna be dead in a matter of microseconds anyways, so wasted memory doesn't matter to me.
rlm@1 3588 // Go ahead and abuse strdup.
rlm@1 3589 char *parameters[] = { "xmessage", "-buttons", t, strdup(message), NULL };
rlm@1 3590
rlm@1 3591 execvp("xmessage", parameters);
rlm@1 3592
rlm@1 3593 // Aw shitty
rlm@1 3594 perror("exec xmessage");
rlm@1 3595 exit(1);
rlm@1 3596 }
rlm@1 3597 else if (pid < 0) // something went wrong!!! Oh hell... use the console
rlm@1 3598 goto use_console;
rlm@1 3599 else
rlm@1 3600 {
rlm@1 3601 // We're the parent. Watch for the child.
rlm@1 3602 int r;
rlm@1 3603 int res = waitpid(pid, &r, 0);
rlm@1 3604 if (res < 0) // wtf?
rlm@1 3605 goto use_console;
rlm@1 3606
rlm@1 3607 // The return value gets copmlicated...
rlm@1 3608 if (!WIFEXITED(r))
rlm@1 3609 {
rlm@1 3610 luaL_error(L, "don't screw with my xmessage process!");
rlm@1 3611 }
rlm@1 3612
rlm@1 3613 r = WEXITSTATUS(r);
rlm@1 3614
rlm@1 3615 // We assume it's worked.
rlm@1 3616 if (r == 0)
rlm@1 3617 {
rlm@1 3618 return 0; // no parameters for an OK
rlm@1 3619 }
rlm@1 3620
rlm@1 3621 if (r == 100)
rlm@1 3622 {
rlm@1 3623 lua_pushstring(L, "yes");
rlm@1 3624 return 1;
rlm@1 3625 }
rlm@1 3626
rlm@1 3627 if (r == 101)
rlm@1 3628 {
rlm@1 3629 lua_pushstring(L, "no");
rlm@1 3630 return 1;
rlm@1 3631 }
rlm@1 3632
rlm@1 3633 if (r == 102)
rlm@1 3634 {
rlm@1 3635 lua_pushstring(L, "cancel");
rlm@1 3636 return 1;
rlm@1 3637 }
rlm@1 3638
rlm@1 3639 // Wtf?
rlm@1 3640 return luaL_error(L, "popup failed due to unknown results involving xmessage (%d)", r);
rlm@1 3641 }
rlm@1 3642
rlm@1 3643 use_console:
rlm@1 3644 #endif
rlm@1 3645
rlm@1 3646 // All else has failed
rlm@1 3647 if (strcmp(type, "ok") == 0)
rlm@1 3648 t = "";
rlm@1 3649 else if (strcmp(type, "yesno") == 0)
rlm@1 3650 t = "yn";
rlm@1 3651 else if (strcmp(type, "yesnocancel") == 0)
rlm@1 3652 t = "ync";
rlm@1 3653 else
rlm@1 3654 return luaL_error(L, "invalid popup type \"%s\"", type);
rlm@1 3655
rlm@1 3656 fprintf(stderr, "Lua Message: %s\n", message);
rlm@1 3657
rlm@1 3658 while (true)
rlm@1 3659 {
rlm@1 3660 char buffer[64];
rlm@1 3661
rlm@1 3662 // We don't want parameters
rlm@1 3663 if (!t[0])
rlm@1 3664 {
rlm@1 3665 fprintf(stderr, "[Press Enter]");
rlm@1 3666 fgets(buffer, sizeof(buffer), stdin);
rlm@1 3667
rlm@1 3668 // We're done
rlm@1 3669 return 0;
rlm@1 3670 }
rlm@1 3671
rlm@1 3672 fprintf(stderr, "(%s): ", t);
rlm@1 3673 fgets(buffer, sizeof(buffer), stdin);
rlm@1 3674
rlm@1 3675 // Check if the option is in the list
rlm@1 3676 if (strchr(t, tolower(buffer[0])))
rlm@1 3677 {
rlm@1 3678 switch (tolower(buffer[0]))
rlm@1 3679 {
rlm@1 3680 case 'y':
rlm@1 3681 lua_pushstring(L, "yes");
rlm@1 3682 return 1;
rlm@1 3683 case 'n':
rlm@1 3684 lua_pushstring(L, "no");
rlm@1 3685 return 1;
rlm@1 3686 case 'c':
rlm@1 3687 lua_pushstring(L, "cancel");
rlm@1 3688 return 1;
rlm@1 3689 default:
rlm@1 3690 luaL_error(L, "internal logic error in console based prompts for gui.popup");
rlm@1 3691 }
rlm@1 3692 }
rlm@1 3693
rlm@1 3694 // We fell through, so we assume the user answered wrong and prompt again.
rlm@1 3695 }
rlm@1 3696
rlm@1 3697 // Nothing here, since the only way out is in the loop.
rlm@1 3698 #endif
rlm@1 3699 }
rlm@1 3700
rlm@1 3701 #if (defined(WIN32) && !defined(SDL))
rlm@1 3702 const char *s_keyToName[256] =
rlm@1 3703 {
rlm@1 3704 NULL,
rlm@1 3705 "leftclick",
rlm@1 3706 "rightclick",
rlm@1 3707 NULL,
rlm@1 3708 "middleclick",
rlm@1 3709 NULL,
rlm@1 3710 NULL,
rlm@1 3711 NULL,
rlm@1 3712 "backspace",
rlm@1 3713 "tab",
rlm@1 3714 NULL,
rlm@1 3715 NULL,
rlm@1 3716 NULL,
rlm@1 3717 "enter",
rlm@1 3718 NULL,
rlm@1 3719 NULL,
rlm@1 3720 "shift", // 0x10
rlm@1 3721 "control",
rlm@1 3722 "alt",
rlm@1 3723 "pause",
rlm@1 3724 "capslock",
rlm@1 3725 NULL,
rlm@1 3726 NULL,
rlm@1 3727 NULL,
rlm@1 3728 NULL,
rlm@1 3729 NULL,
rlm@1 3730 NULL,
rlm@1 3731 "escape",
rlm@1 3732 NULL,
rlm@1 3733 NULL,
rlm@1 3734 NULL,
rlm@1 3735 NULL,
rlm@1 3736 "space", // 0x20
rlm@1 3737 "pageup",
rlm@1 3738 "pagedown",
rlm@1 3739 "end",
rlm@1 3740 "home",
rlm@1 3741 "left",
rlm@1 3742 "up",
rlm@1 3743 "right",
rlm@1 3744 "down",
rlm@1 3745 NULL,
rlm@1 3746 NULL,
rlm@1 3747 NULL,
rlm@1 3748 NULL,
rlm@1 3749 "insert",
rlm@1 3750 "delete",
rlm@1 3751 NULL,
rlm@1 3752 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
rlm@1 3753 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3754 "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
rlm@1 3755 "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
rlm@1 3756 "U", "V", "W", "X", "Y", "Z",
rlm@1 3757 NULL,
rlm@1 3758 NULL,
rlm@1 3759 NULL,
rlm@1 3760 NULL,
rlm@1 3761 NULL,
rlm@1 3762 "numpad0", "numpad1", "numpad2", "numpad3", "numpad4", "numpad5", "numpad6", "numpad7", "numpad8", "numpad9",
rlm@1 3763 "numpad*", "numpad+",
rlm@1 3764 NULL,
rlm@1 3765 "numpad-", "numpad.", "numpad/",
rlm@1 3766 "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11",
rlm@1 3767 "F12",
rlm@1 3768 "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21", "F22", "F23",
rlm@1 3769 "F24",
rlm@1 3770 NULL,
rlm@1 3771 NULL,
rlm@1 3772 NULL,
rlm@1 3773 NULL,
rlm@1 3774 NULL,
rlm@1 3775 NULL,
rlm@1 3776 NULL,
rlm@1 3777 NULL,
rlm@1 3778 "numlock",
rlm@1 3779 "scrolllock",
rlm@1 3780 NULL, // 0x92
rlm@1 3781 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3782 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3783 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3784 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3785 NULL, // 0xB9
rlm@1 3786 "semicolon",
rlm@1 3787 "plus",
rlm@1 3788 "comma",
rlm@1 3789 "minus",
rlm@1 3790 "period",
rlm@1 3791 "slash",
rlm@1 3792 "tilde",
rlm@1 3793 NULL, // 0xC1
rlm@1 3794 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3795 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3796 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
rlm@1 3797 NULL, // 0xDA
rlm@1 3798 "leftbracket",
rlm@1 3799 "backslash",
rlm@1 3800 "rightbracket",
rlm@1 3801 "quote",
rlm@1 3802 };
rlm@1 3803 #endif
rlm@1 3804
rlm@1 3805 // input.get()
rlm@1 3806 // takes no input, returns a lua table of entries representing the current input state,
rlm@1 3807 // independent of the joypad buttons the emulated game thinks are pressed
rlm@1 3808 // for example:
rlm@1 3809 // if the user is holding the W key and the left mouse button
rlm@1 3810 // and has the mouse at the bottom-right corner of the game screen,
rlm@1 3811
rlm@1 3812 // then this would return {W=true, leftclick=true, xmouse=255, ymouse=223}
rlm@1 3813 static int input_getcurrentinputstatus(lua_State *L)
rlm@1 3814 {
rlm@1 3815 lua_newtable(L);
rlm@1 3816
rlm@1 3817 #if (defined(WIN32) && !defined(SDL))
rlm@1 3818 // keyboard and mouse button status
rlm@1 3819 {
rlm@1 3820 unsigned char keys[256];
rlm@1 3821 if (true /*!GUI.BackgroundInput*/) // TODO: background input
rlm@1 3822 {
rlm@1 3823 if (GetKeyboardState(keys))
rlm@1 3824 {
rlm@1 3825 for (int i = 1; i < 255; i++)
rlm@1 3826 {
rlm@1 3827 int mask = (i == VK_CAPITAL || i == VK_NUMLOCK || i == VK_SCROLL) ? 0x01 : 0x80;
rlm@1 3828 if (keys[i] & mask)
rlm@1 3829 {
rlm@1 3830 const char *name = s_keyToName[i];
rlm@1 3831 if (name)
rlm@1 3832 {
rlm@1 3833 lua_pushboolean(L, true);
rlm@1 3834 lua_setfield(L, -2, name);
rlm@1 3835 }
rlm@1 3836 }
rlm@1 3837 }
rlm@1 3838 }
rlm@1 3839 }
rlm@1 3840 else // use a slightly different method that will detect background input:
rlm@1 3841 {
rlm@1 3842 for (int i = 1; i < 255; i++)
rlm@1 3843 {
rlm@1 3844 const char *name = s_keyToName[i];
rlm@1 3845 if (name)
rlm@1 3846 {
rlm@1 3847 int active;
rlm@1 3848 if (i == VK_CAPITAL || i == VK_NUMLOCK || i == VK_SCROLL)
rlm@1 3849 active = GetKeyState(i) & 0x01;
rlm@1 3850 else
rlm@1 3851 active = GetAsyncKeyState(i) & 0x8000;
rlm@1 3852 if (active)
rlm@1 3853 {
rlm@1 3854 lua_pushboolean(L, true);
rlm@1 3855 lua_setfield(L, -2, name);
rlm@1 3856 }
rlm@1 3857 }
rlm@1 3858 }
rlm@1 3859 }
rlm@1 3860 }
rlm@1 3861
rlm@1 3862 // mouse position in game screen pixel coordinates
rlm@1 3863 {
rlm@1 3864 POINT mouse;
rlm@1 3865
rlm@1 3866 int xofs = 0, yofs = 0, width = 240, height = 160;
rlm@1 3867 if (!systemIsRunningGBA())
rlm@1 3868 {
rlm@1 3869 if (gbBorderOn)
rlm@1 3870 width = 256, height = 224, xofs = 48, yofs = 40;
rlm@1 3871 else
rlm@1 3872 width = 160, height = 144;
rlm@1 3873 }
rlm@1 3874
rlm@1 3875 GetCursorPos(&mouse);
rlm@1 3876 AfxGetApp()->m_pMainWnd->ScreenToClient(&mouse);
rlm@1 3877
rlm@1 3878 // game screen is always fully stretched to window size,
rlm@1 3879 // with no aspect rate correction, or something like that.
rlm@1 3880 RECT clientRect;
rlm@1 3881 AfxGetApp()->m_pMainWnd->GetClientRect(&clientRect);
rlm@1 3882
rlm@1 3883 int wndWidth = clientRect.right - clientRect.left;
rlm@1 3884 int wndHeight = clientRect.bottom - clientRect.top;
rlm@1 3885 mouse.x = (LONG) (mouse.x * ((float)width / wndWidth)) - xofs;
rlm@1 3886 mouse.y = (LONG) (mouse.y * ((float)height / wndHeight)) - yofs;
rlm@1 3887
rlm@1 3888 lua_pushinteger(L, mouse.x);
rlm@1 3889 lua_setfield(L, -2, "xmouse");
rlm@1 3890 lua_pushinteger(L, mouse.y);
rlm@1 3891 lua_setfield(L, -2, "ymouse");
rlm@1 3892 }
rlm@1 3893
rlm@1 3894 #else
rlm@1 3895 // NYI (well, return an empty table)
rlm@1 3896 #endif
rlm@1 3897 return 1;
rlm@1 3898 }
rlm@1 3899
rlm@1 3900 static int avi_framecount(lua_State *L)
rlm@1 3901 {
rlm@1 3902 #ifdef WIN32
rlm@1 3903 if (theApp.aviRecorder != NULL)
rlm@1 3904 {
rlm@1 3905 lua_pushinteger(L, theApp.aviRecorder->videoFrames());
rlm@1 3906 }
rlm@1 3907 else
rlm@1 3908 #endif
rlm@1 3909 {
rlm@1 3910 lua_pushinteger(L, 0);
rlm@1 3911 }
rlm@1 3912 return 1;
rlm@1 3913 }
rlm@1 3914
rlm@1 3915 static int avi_pause(lua_State *L)
rlm@1 3916 {
rlm@1 3917 #ifdef WIN32
rlm@1 3918 if (theApp.aviRecorder != NULL)
rlm@1 3919 theApp.aviRecorder->Pause(true);
rlm@1 3920 #endif
rlm@1 3921 return 1;
rlm@1 3922 }
rlm@1 3923
rlm@1 3924 static int avi_resume(lua_State *L)
rlm@1 3925 {
rlm@1 3926 #ifdef WIN32
rlm@1 3927 if (theApp.aviRecorder != NULL)
rlm@1 3928 theApp.aviRecorder->Pause(false);
rlm@1 3929 #endif
rlm@1 3930 return 1;
rlm@1 3931 }
rlm@1 3932
rlm@1 3933 static int sound_get(lua_State *L)
rlm@1 3934 {
rlm@1 3935 extern int32 soundLevel1;
rlm@1 3936 extern int32 soundLevel2;
rlm@1 3937 extern int32 soundBalance;
rlm@1 3938 extern int32 soundMasterOn;
rlm@1 3939 extern int32 soundVIN;
rlm@1 3940 extern int32 sound1On;
rlm@1 3941 extern int32 sound1EnvelopeVolume;
rlm@1 3942 extern int32 sound2On;
rlm@1 3943 extern int32 sound2EnvelopeVolume;
rlm@1 3944 extern int32 sound3On;
rlm@1 3945 extern int32 sound3OutputLevel;
rlm@1 3946 extern int32 sound3Bank;
rlm@1 3947 extern int32 sound3DataSize;
rlm@1 3948 extern int32 sound3ForcedOutput;
rlm@1 3949 extern int32 sound4On;
rlm@1 3950 extern int32 sound4EnvelopeVolume;
rlm@1 3951 extern u8 sound3WaveRam[0x20];
rlm@1 3952
rlm@1 3953 int freqReg;
rlm@1 3954 double freq;
rlm@1 3955 double leftvolscale;
rlm@1 3956 double rightvolscale;
rlm@1 3957 double panpot;
rlm@1 3958 bool gba = systemIsRunningGBA();
rlm@1 3959 u8* gbMem = gba ? ioMem : gbMemory;
rlm@1 3960 const int rNR10 = gba ? 0x60 : 0xff10;
rlm@1 3961 const int rNR11 = gba ? 0x62 : 0xff11;
rlm@1 3962 const int rNR12 = gba ? 0x63 : 0xff12;
rlm@1 3963 const int rNR13 = gba ? 0x64 : 0xff13;
rlm@1 3964 const int rNR14 = gba ? 0x65 : 0xff14;
rlm@1 3965 const int rNR21 = gba ? 0x68 : 0xff16;
rlm@1 3966 const int rNR22 = gba ? 0x69 : 0xff17;
rlm@1 3967 const int rNR23 = gba ? 0x6c : 0xff18;
rlm@1 3968 const int rNR24 = gba ? 0x6d : 0xff19;
rlm@1 3969 const int rNR30 = gba ? 0x70 : 0xff1a;
rlm@1 3970 const int rNR31 = gba ? 0x72 : 0xff1b;
rlm@1 3971 const int rNR32 = gba ? 0x73 : 0xff1c;
rlm@1 3972 const int rNR33 = gba ? 0x74 : 0xff1d;
rlm@1 3973 const int rNR34 = gba ? 0x75 : 0xff1e;
rlm@1 3974 const int rNR41 = gba ? 0x78 : 0xff20;
rlm@1 3975 const int rNR42 = gba ? 0x79 : 0xff21;
rlm@1 3976 const int rNR43 = gba ? 0x7c : 0xff22;
rlm@1 3977 const int rNR44 = gba ? 0x7d : 0xff23;
rlm@1 3978 const int rNR50 = gba ? 0x80 : 0xff24;
rlm@1 3979 const int rNR51 = gba ? 0x81 : 0xff25;
rlm@1 3980 const int rNR52 = gba ? 0x84 : 0xff26;
rlm@1 3981 const int rWAVE_RAM = gba ? 0x90 : 0xff30;
rlm@1 3982
rlm@1 3983 const int32 _soundVIN = 0x88; // gba ? 0x88 : soundVIN;
rlm@1 3984 const bool soundVINLeft = ((_soundVIN & 0x80) != 0);
rlm@1 3985 const bool soundVINRight = ((_soundVIN & 0x08) != 0);
rlm@1 3986
rlm@1 3987 lua_newtable(L);
rlm@1 3988
rlm@1 3989 // square1
rlm@1 3990 lua_newtable(L);
rlm@1 3991 if(sound1On == 0 || soundMasterOn == 0)
rlm@1 3992 {
rlm@1 3993 lua_pushnumber(L, 0.0);
rlm@1 3994 panpot = 0.5;
rlm@1 3995 }
rlm@1 3996 else
rlm@1 3997 {
rlm@1 3998 double envVolume = sound1EnvelopeVolume / 15.0;
rlm@1 3999 if (soundVINLeft && (soundBalance & 0x10) != 0)
rlm@1 4000 leftvolscale = ((soundLevel2 / 7.0) * envVolume);
rlm@1 4001 else
rlm@1 4002 leftvolscale = 0.0;
rlm@1 4003 if (soundVINRight && (soundBalance & 0x01) != 0)
rlm@1 4004 rightvolscale = ((soundLevel1 / 7.0) * envVolume);
rlm@1 4005 else
rlm@1 4006 rightvolscale = 0.0;
rlm@1 4007 if ((leftvolscale + rightvolscale) != 0)
rlm@1 4008 panpot = rightvolscale / (leftvolscale + rightvolscale);
rlm@1 4009 else
rlm@1 4010 panpot = 0.5;
rlm@1 4011 lua_pushnumber(L, (leftvolscale + rightvolscale) / 2.0);
rlm@1 4012 }
rlm@1 4013 lua_setfield(L, -2, "volume");
rlm@1 4014 lua_pushnumber(L, panpot);
rlm@1 4015 lua_setfield(L, -2, "panpot");
rlm@1 4016 freqReg = (((int)(gbMem[rNR14] & 7) << 8) | gbMem[rNR13]);
rlm@1 4017 freq = 131072.0 / (2048 - freqReg);
rlm@1 4018 lua_pushnumber(L, freq);
rlm@1 4019 lua_setfield(L, -2, "frequency");
rlm@1 4020 lua_pushnumber(L, (log(freq / 440.0) * 12 / log(2.0)) + 69);
rlm@1 4021 lua_setfield(L, -2, "midikey");
rlm@1 4022 lua_pushinteger(L, (gbMem[rNR11] & 0xC0) >> 6);
rlm@1 4023 lua_setfield(L, -2, "duty");
rlm@1 4024 lua_newtable(L);
rlm@1 4025 lua_pushinteger(L, freqReg);
rlm@1 4026 lua_setfield(L, -2, "frequency");
rlm@1 4027 lua_setfield(L, -2, "regs");
rlm@1 4028 lua_setfield(L, -2, "square1");
rlm@1 4029 // square2
rlm@1 4030 lua_newtable(L);
rlm@1 4031 if(sound2On == 0 || soundMasterOn == 0)
rlm@1 4032 {
rlm@1 4033 lua_pushnumber(L, 0.0);
rlm@1 4034 panpot = 0.5;
rlm@1 4035 }
rlm@1 4036 else
rlm@1 4037 {
rlm@1 4038 double envVolume = sound2EnvelopeVolume / 15.0;
rlm@1 4039 if (soundVINLeft && (soundBalance & 0x20) != 0)
rlm@1 4040 leftvolscale = ((soundLevel2 / 7.0) * envVolume);
rlm@1 4041 else
rlm@1 4042 leftvolscale = 0.0;
rlm@1 4043 if (soundVINRight && (soundBalance & 0x02) != 0)
rlm@1 4044 rightvolscale = ((soundLevel1 / 7.0) * envVolume);
rlm@1 4045 else
rlm@1 4046 rightvolscale = 0.0;
rlm@1 4047 if ((leftvolscale + rightvolscale) != 0)
rlm@1 4048 panpot = rightvolscale / (leftvolscale + rightvolscale);
rlm@1 4049 else
rlm@1 4050 panpot = 0.5;
rlm@1 4051 lua_pushnumber(L, (leftvolscale + rightvolscale) / 2.0);
rlm@1 4052 }
rlm@1 4053 lua_setfield(L, -2, "volume");
rlm@1 4054 lua_pushnumber(L, panpot);
rlm@1 4055 lua_setfield(L, -2, "panpot");
rlm@1 4056 freqReg = (((int)(gbMem[rNR24] & 7) << 8) | gbMem[rNR23]);
rlm@1 4057 freq = 131072.0 / (2048 - freqReg);
rlm@1 4058 lua_pushnumber(L, freq);
rlm@1 4059 lua_setfield(L, -2, "frequency");
rlm@1 4060 lua_pushnumber(L, (log(freq / 440.0) * 12 / log(2.0)) + 69);
rlm@1 4061 lua_setfield(L, -2, "midikey");
rlm@1 4062 lua_pushinteger(L, (gbMem[rNR21] & 0xC0) >> 6);
rlm@1 4063 lua_setfield(L, -2, "duty");
rlm@1 4064 lua_newtable(L);
rlm@1 4065 lua_pushinteger(L, freqReg);
rlm@1 4066 lua_setfield(L, -2, "frequency");
rlm@1 4067 lua_setfield(L, -2, "regs");
rlm@1 4068 lua_setfield(L, -2, "square2");
rlm@1 4069 // wavememory
rlm@1 4070 lua_newtable(L);
rlm@1 4071 if(sound3On == 0 || soundMasterOn == 0)
rlm@1 4072 {
rlm@1 4073 lua_pushnumber(L, 0.0);
rlm@1 4074 panpot = 0.5;
rlm@1 4075 }
rlm@1 4076 else
rlm@1 4077 {
rlm@1 4078 double envVolume;
rlm@1 4079 if (gba && sound3ForcedOutput != 0)
rlm@1 4080 envVolume = 0.75;
rlm@1 4081 else
rlm@1 4082 {
rlm@1 4083 double volTable[4] = { 0.0, 1.0, 0.5, 0.25 };
rlm@1 4084 envVolume = volTable[sound3OutputLevel & 3];
rlm@1 4085 }
rlm@1 4086
rlm@1 4087 if (soundVINLeft && (soundBalance & 0x40) != 0)
rlm@1 4088 leftvolscale = ((soundLevel2 / 7.0) * envVolume);
rlm@1 4089 else
rlm@1 4090 leftvolscale = 0.0;
rlm@1 4091 if (soundVINRight && (soundBalance & 0x04) != 0)
rlm@1 4092 rightvolscale = ((soundLevel1 / 7.0) * envVolume);
rlm@1 4093 else
rlm@1 4094 rightvolscale = 0.0;
rlm@1 4095 if ((leftvolscale + rightvolscale) != 0)
rlm@1 4096 panpot = rightvolscale / (leftvolscale + rightvolscale);
rlm@1 4097 else
rlm@1 4098 panpot = 0.5;
rlm@1 4099 lua_pushnumber(L, (leftvolscale + rightvolscale) / 2.0);
rlm@1 4100 }
rlm@1 4101 lua_setfield(L, -2, "volume");
rlm@1 4102 lua_pushnumber(L, panpot);
rlm@1 4103 lua_setfield(L, -2, "panpot");
rlm@1 4104 int waveMemSamples = 32;
rlm@1 4105 if (gba)
rlm@1 4106 {
rlm@1 4107 lua_pushlstring(L, (const char *) &sound3WaveRam[sound3Bank * 0x10], sound3DataSize ? 0x20 : 0x10);
rlm@1 4108 waveMemSamples = sound3DataSize ? 64 : 32;
rlm@1 4109 }
rlm@1 4110 else
rlm@1 4111 {
rlm@1 4112 lua_pushlstring(L, (const char *) &gbMem[rWAVE_RAM], 0x10);
rlm@1 4113 }
rlm@1 4114 lua_setfield(L, -2, "waveform");
rlm@1 4115 freqReg = (((int)(gbMem[rNR34] & 7) << 8) | gbMem[rNR33]);
rlm@1 4116 freq = 2097152.0 / (waveMemSamples * (2048 - freqReg));
rlm@1 4117 lua_pushnumber(L, freq);
rlm@1 4118 lua_setfield(L, -2, "frequency");
rlm@1 4119 lua_pushnumber(L, (log(freq / 440.0) * 12 / log(2.0)) + 69);
rlm@1 4120 lua_setfield(L, -2, "midikey");
rlm@1 4121 lua_newtable(L);
rlm@1 4122 lua_pushinteger(L, freqReg);
rlm@1 4123 lua_setfield(L, -2, "frequency");
rlm@1 4124 lua_setfield(L, -2, "regs");
rlm@1 4125 lua_setfield(L, -2, "wavememory");
rlm@1 4126 // noise
rlm@1 4127 lua_newtable(L);
rlm@1 4128 if(sound4On == 0 || soundMasterOn == 0)
rlm@1 4129 {
rlm@1 4130 lua_pushnumber(L, 0.0);
rlm@1 4131 panpot = 0.5;
rlm@1 4132 }
rlm@1 4133 else
rlm@1 4134 {
rlm@1 4135 double envVolume = sound4EnvelopeVolume / 15.0;
rlm@1 4136 if (soundVINLeft && (soundBalance & 0x80) != 0)
rlm@1 4137 leftvolscale = ((soundLevel2 / 7.0) * envVolume);
rlm@1 4138 else
rlm@1 4139 leftvolscale = 0.0;
rlm@1 4140 if (soundVINRight && (soundBalance & 0x08) != 0)
rlm@1 4141 rightvolscale = ((soundLevel1 / 7.0) * envVolume);
rlm@1 4142 else
rlm@1 4143 rightvolscale = 0.0;
rlm@1 4144 if ((leftvolscale + rightvolscale) != 0)
rlm@1 4145 panpot = rightvolscale / (leftvolscale + rightvolscale);
rlm@1 4146 else
rlm@1 4147 panpot = 0.5;
rlm@1 4148 lua_pushnumber(L, (leftvolscale + rightvolscale) / 2.0);
rlm@1 4149 }
rlm@1 4150 lua_setfield(L, -2, "volume");
rlm@1 4151 lua_pushnumber(L, panpot);
rlm@1 4152 lua_setfield(L, -2, "panpot");
rlm@1 4153 const int gbNoiseFreqTable[8] = { 1, 2, 4, 6, 8, 10, 12, 14 };
rlm@1 4154 freqReg = gbNoiseFreqTable[gbMem[rNR43] & 7] << (1 + (gbMem[rNR43] >> 4));
rlm@1 4155 lua_pushboolean(L, (gbMem[rNR43] & 8) != 0);
rlm@1 4156 lua_setfield(L, -2, "short");
rlm@1 4157 freq = 1048576.0 / freqReg;
rlm@1 4158 lua_pushnumber(L, freq);
rlm@1 4159 lua_setfield(L, -2, "frequency");
rlm@1 4160 lua_pushnumber(L, (log(freq / 440.0) * 12 / log(2.0)) + 69);
rlm@1 4161 lua_setfield(L, -2, "midikey");
rlm@1 4162 lua_newtable(L);
rlm@1 4163 lua_pushinteger(L, freqReg);
rlm@1 4164 lua_setfield(L, -2, "frequency");
rlm@1 4165 lua_setfield(L, -2, "regs");
rlm@1 4166 lua_setfield(L, -2, "noise");
rlm@1 4167
rlm@1 4168 return 1;
rlm@1 4169 }
rlm@1 4170
rlm@1 4171 // same as math.random, but uses SFMT instead of C rand()
rlm@1 4172 // FIXME: this function doesn't care multi-instance,
rlm@1 4173
rlm@1 4174 // original math.random either though (Lua 5.1)
rlm@1 4175 static int sfmt_random(lua_State *L)
rlm@1 4176 {
rlm@1 4177 lua_Number r = (lua_Number) genrand_real2();
rlm@1 4178 switch (lua_gettop(L))
rlm@1 4179 { // check number of arguments
rlm@1 4180 case 0:
rlm@1 4181 { // no arguments
rlm@1 4182 lua_pushnumber(L, r); // Number between 0 and 1
rlm@1 4183 break;
rlm@1 4184 }
rlm@1 4185
rlm@1 4186 case 1:
rlm@1 4187 { // only upper limit
rlm@1 4188 int u = luaL_checkint(L, 1);
rlm@1 4189 luaL_argcheck(L, 1 <= u, 1, "interval is empty");
rlm@1 4190 lua_pushnumber(L, floor(r * u) + 1); // int between 1 and `u'
rlm@1 4191 break;
rlm@1 4192 }
rlm@1 4193
rlm@1 4194 case 2:
rlm@1 4195 { // lower and upper limits
rlm@1 4196 int l = luaL_checkint(L, 1);
rlm@1 4197 int u = luaL_checkint(L, 2);
rlm@1 4198 luaL_argcheck(L, l <= u, 2, "interval is empty");
rlm@1 4199 lua_pushnumber(L, floor(r * (u - l + 1)) + l); // int between `l' and `u'
rlm@1 4200 break;
rlm@1 4201 }
rlm@1 4202
rlm@1 4203 default:
rlm@1 4204 return luaL_error(L, "wrong number of arguments");
rlm@1 4205 }
rlm@1 4206
rlm@1 4207 return 1;
rlm@1 4208 }
rlm@1 4209
rlm@1 4210 // same as math.randomseed, but uses SFMT instead of C srand()
rlm@1 4211 // FIXME: this function doesn't care multi-instance,
rlm@1 4212
rlm@1 4213 // original math.randomseed either though (Lua 5.1)
rlm@1 4214 static int sfmt_randomseed(lua_State *L)
rlm@1 4215 {
rlm@1 4216 init_gen_rand(luaL_checkint(L, 1));
rlm@1 4217 return 0;
rlm@1 4218 }
rlm@1 4219
rlm@1 4220 // the following bit operations are ported from LuaBitOp 1.0.1,
rlm@1 4221 // because it can handle the sign bit (bit 31) correctly.
rlm@1 4222
rlm@1 4223 /*
rlm@1 4224 ** Lua BitOp -- a bit operations library for Lua 5.1.
rlm@1 4225 ** http://bitop.luajit.org/
rlm@1 4226 **
rlm@1 4227 ** Copyright (C) 2008-2009 Mike Pall. All rights reserved.
rlm@1 4228 **
rlm@1 4229 ** Permission is hereby granted, free of charge, to any person obtaining
rlm@1 4230 ** a copy of this software and associated documentation files (the
rlm@1 4231 ** "Software"), to deal in the Software without restriction, including
rlm@1 4232 ** without limitation the rights to use, copy, modify, merge, publish,
rlm@1 4233 ** distribute, sublicense, and/or sell copies of the Software, and to
rlm@1 4234 ** permit persons to whom the Software is furnished to do so, subject to
rlm@1 4235 ** the following conditions:
rlm@1 4236 **
rlm@1 4237 ** The above copyright notice and this permission notice shall be
rlm@1 4238 ** included in all copies or substantial portions of the Software.
rlm@1 4239 **
rlm@1 4240 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
rlm@1 4241 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
rlm@1 4242 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
rlm@1 4243 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
rlm@1 4244 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
rlm@1 4245 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
rlm@1 4246 ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
rlm@1 4247 **
rlm@1 4248 ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
rlm@1 4249 */
rlm@1 4250
rlm@1 4251 #ifdef _MSC_VER
rlm@1 4252 /* MSVC is stuck in the last century and doesn't have C99's stdint.h. */
rlm@1 4253 typedef __int32 int32_t;
rlm@1 4254 typedef unsigned __int32 uint32_t;
rlm@1 4255 typedef unsigned __int64 uint64_t;
rlm@1 4256 #else
rlm@1 4257 #include <stdint.h>
rlm@1 4258 #endif
rlm@1 4259
rlm@1 4260 typedef int32_t SBits;
rlm@1 4261 typedef uint32_t UBits;
rlm@1 4262
rlm@1 4263 typedef union
rlm@1 4264 {
rlm@1 4265 lua_Number n;
rlm@1 4266 #ifdef LUA_NUMBER_DOUBLE
rlm@1 4267 uint64_t b;
rlm@1 4268 #else
rlm@1 4269 UBits b;
rlm@1 4270 #endif
rlm@1 4271 } BitNum;
rlm@1 4272
rlm@1 4273 /* Convert argument to bit type. */
rlm@1 4274 static UBits barg(lua_State *L, int idx)
rlm@1 4275 {
rlm@1 4276 BitNum bn;
rlm@1 4277 UBits b;
rlm@1 4278 bn.n = lua_tonumber(L, idx);
rlm@1 4279 #if defined(LUA_NUMBER_DOUBLE)
rlm@1 4280 bn.n += 6755399441055744.0; /* 2^52+2^51 */
rlm@1 4281 #ifdef SWAPPED_DOUBLE
rlm@1 4282 b = (UBits)(bn.b >> 32);
rlm@1 4283 #else
rlm@1 4284 b = (UBits)(bn.b & 0xffffffff);
rlm@1 4285 #endif
rlm@1 4286 #elif defined(LUA_NUMBER_INT) || defined(LUA_NUMBER_LONG) || \
rlm@1 4287 defined(LUA_NUMBER_LONGLONG) || defined(LUA_NUMBER_LONG_LONG) || \
rlm@1 4288 defined(LUA_NUMBER_LLONG)
rlm@1 4289 if (sizeof(UBits) == sizeof(lua_Number))
rlm@1 4290 b = bn.b;
rlm@1 4291 else
rlm@1 4292 b = (UBits)(SBits)bn.n;
rlm@1 4293 #elif defined(LUA_NUMBER_FLOAT)
rlm@1 4294 #error "A 'float' lua_Number type is incompatible with this library"
rlm@1 4295 #else
rlm@1 4296 #error "Unknown number type, check LUA_NUMBER_* in luaconf.h"
rlm@1 4297 #endif
rlm@1 4298 if (b == 0 && !lua_isnumber(L, idx))
rlm@1 4299 luaL_typerror(L, idx, "number");
rlm@1 4300 return b;
rlm@1 4301 }
rlm@1 4302
rlm@1 4303 /* Return bit type. */
rlm@1 4304 #define BRET(b) lua_pushnumber(L, (lua_Number)(SBits)(b)); return 1;
rlm@1 4305
rlm@1 4306 static int bit_tobit(lua_State *L) { BRET(barg(L, 1)) }
rlm@1 4307 static int bit_bnot(lua_State *L) { BRET(~barg(L, 1)) }
rlm@1 4308
rlm@1 4309 #define BIT_OP(func, opr) \
rlm@1 4310 static int func(lua_State * L) { int i; UBits b = barg(L, 1); \
rlm@1 4311 for (i = lua_gettop(L); i > 1; i--) \
rlm@1 4312 b opr barg(L, i); BRET(b) }
rlm@1 4313 BIT_OP(bit_band, &= )
rlm@1 4314 BIT_OP(bit_bor, |= )
rlm@1 4315 BIT_OP(bit_bxor, ^= )
rlm@1 4316
rlm@1 4317 #define bshl(b, n) (b << n)
rlm@1 4318 #define bshr(b, n) (b >> n)
rlm@1 4319 #define bsar(b, n) ((SBits)b >> n)
rlm@1 4320 #define brol(b, n) ((b << n) | (b >> (32 - n)))
rlm@1 4321 #define bror(b, n) ((b << (32 - n)) | (b >> n))
rlm@1 4322 #define BIT_SH(func, fn) \
rlm@1 4323 static int func(lua_State * L) { \
rlm@1 4324 UBits b = barg(L, 1); UBits n = barg(L, 2) & 31; BRET(fn(b, n)) }
rlm@1 4325 BIT_SH(bit_lshift, bshl)
rlm@1 4326 BIT_SH(bit_rshift, bshr)
rlm@1 4327 BIT_SH(bit_arshift, bsar)
rlm@1 4328 BIT_SH(bit_rol, brol)
rlm@1 4329 BIT_SH(bit_ror, bror)
rlm@1 4330
rlm@1 4331 static int bit_bswap(lua_State *L)
rlm@1 4332 {
rlm@1 4333 UBits b = barg(L, 1);
rlm@1 4334 b = (b >> 24) | ((b >> 8) & 0xff00) | ((b & 0xff00) << 8) | (b << 24);
rlm@1 4335 BRET(b)
rlm@1 4336 }
rlm@1 4337
rlm@1 4338 static int bit_tohex(lua_State *L)
rlm@1 4339 {
rlm@1 4340 UBits b = barg(L, 1);
rlm@1 4341 SBits n = lua_isnone(L, 2) ? 8 : (SBits)barg(L, 2);
rlm@1 4342 const char *hexdigits = "0123456789abcdef";
rlm@1 4343 char buf[8];
rlm@1 4344 int i;
rlm@1 4345 if (n < 0) { n = -n; hexdigits = "0123456789ABCDEF"; }
rlm@1 4346 if (n > 8) n = 8;
rlm@1 4347 for (i = (int)n; --i >= 0; )
rlm@1 4348 {
rlm@1 4349 buf[i] = hexdigits[b & 15]; b >>= 4;
rlm@1 4350 }
rlm@1 4351 lua_pushlstring(L, buf, (size_t)n);
rlm@1 4352 return 1;
rlm@1 4353 }
rlm@1 4354
rlm@1 4355 static const struct luaL_Reg bit_funcs[] = {
rlm@1 4356 { "tobit", bit_tobit },
rlm@1 4357 { "bnot", bit_bnot },
rlm@1 4358 { "band", bit_band },
rlm@1 4359 { "bor", bit_bor },
rlm@1 4360 { "bxor", bit_bxor },
rlm@1 4361 { "lshift", bit_lshift },
rlm@1 4362 { "rshift", bit_rshift },
rlm@1 4363 { "arshift", bit_arshift },
rlm@1 4364 { "rol", bit_rol },
rlm@1 4365 { "ror", bit_ror },
rlm@1 4366 { "bswap", bit_bswap },
rlm@1 4367 { "tohex", bit_tohex },
rlm@1 4368 { NULL, NULL }
rlm@1 4369 };
rlm@1 4370
rlm@1 4371 /* Signed right-shifts are implementation-defined per C89/C99.
rlm@1 4372 ** But the de facto standard are arithmetic right-shifts on two's
rlm@1 4373 ** complement CPUs. This behaviour is required here, so test for it.
rlm@1 4374 */
rlm@1 4375 #define BAD_SAR (bsar(-8, 2) != (SBits) - 2)
rlm@1 4376
rlm@1 4377 bool luabitop_validate(lua_State *L) // originally named as luaopen_bit
rlm@1 4378 {
rlm@1 4379 UBits b;
rlm@1 4380 lua_pushnumber(L, (lua_Number)1437217655L);
rlm@1 4381 b = barg(L, -1);
rlm@1 4382 if (b != (UBits)1437217655L || BAD_SAR) /* Perform a simple self-test. */
rlm@1 4383 {
rlm@1 4384 const char *msg = "compiled with incompatible luaconf.h";
rlm@1 4385 #ifdef LUA_NUMBER_DOUBLE
rlm@1 4386 #ifdef WIN32
rlm@1 4387 if (b == (UBits)1610612736L)
rlm@1 4388 msg = "use D3DCREATE_FPU_PRESERVE with DirectX";
rlm@1 4389 #endif
rlm@1 4390 if (b == (UBits)1127743488L)
rlm@1 4391 msg = "not compiled with SWAPPED_DOUBLE";
rlm@1 4392 #endif
rlm@1 4393 if (BAD_SAR)
rlm@1 4394 msg = "arithmetic right-shift broken";
rlm@1 4395 luaL_error(L, "bit library self-test failed (%s)", msg);
rlm@1 4396 return false;
rlm@1 4397 }
rlm@1 4398 return true;
rlm@1 4399 }
rlm@1 4400
rlm@1 4401 // LuaBitOp ends here
rlm@1 4402
rlm@1 4403 static int bit_bshift_emulua(lua_State *L)
rlm@1 4404 {
rlm@1 4405 int shift = luaL_checkinteger(L, 2);
rlm@1 4406 if (shift < 0)
rlm@1 4407 {
rlm@1 4408 lua_pushinteger(L, -shift);
rlm@1 4409 lua_replace(L, 2);
rlm@1 4410 return bit_lshift(L);
rlm@1 4411 }
rlm@1 4412 else
rlm@1 4413 return bit_rshift(L);
rlm@1 4414 }
rlm@1 4415
rlm@1 4416 static int bitbit(lua_State *L)
rlm@1 4417 {
rlm@1 4418 int rv = 0;
rlm@1 4419 int numArgs = lua_gettop(L);
rlm@1 4420 for (int i = 1; i <= numArgs; i++)
rlm@1 4421 {
rlm@1 4422 int where = luaL_checkinteger(L, i);
rlm@1 4423 if (where >= 0 && where < 32)
rlm@1 4424 rv |= (1 << where);
rlm@1 4425 }
rlm@1 4426 lua_settop(L, 0);
rlm@1 4427 BRET(rv);
rlm@1 4428 }
rlm@1 4429
rlm@1 4430 // The function called periodically to ensure Lua doesn't run amok.
rlm@1 4431 static void VBALuaHookFunction(lua_State *L, lua_Debug *dbg)
rlm@1 4432 {
rlm@1 4433 if (numTries-- == 0)
rlm@1 4434 {
rlm@1 4435 int kill = 0;
rlm@1 4436
rlm@1 4437 #if (defined(WIN32) && !defined(SDL))
rlm@1 4438 // Uh oh
rlm@1 4439 theApp.winCheckFullscreen();
rlm@1 4440 systemSoundClearBuffer();
rlm@1 4441 int ret = AfxGetApp()->m_pMainWnd->MessageBox(
rlm@1 4442 "The Lua script running has been running a long time. It may have gone crazy. Kill it?\n\n(No = don't check anymore either)",
rlm@1 4443 "Lua Script Gone Nuts?",
rlm@1 4444 MB_YESNO);
rlm@1 4445
rlm@1 4446 if (ret == IDYES)
rlm@1 4447 {
rlm@1 4448 kill = 1;
rlm@1 4449 }
rlm@1 4450
rlm@1 4451 #else
rlm@1 4452 fprintf(
rlm@1 4453 stderr,
rlm@1 4454 "The Lua script running has been running a long time.\nIt may have gone crazy. Kill it? (I won't ask again if you say No)\n");
rlm@1 4455
rlm@1 4456 char buffer[64];
rlm@1 4457 while (true)
rlm@1 4458 {
rlm@1 4459 fprintf(stderr, "(y/n): ");
rlm@1 4460 fgets(buffer, sizeof(buffer), stdin);
rlm@1 4461 if (buffer[0] == 'y' || buffer[0] == 'Y')
rlm@1 4462 {
rlm@1 4463 kill = 1;
rlm@1 4464 break;
rlm@1 4465 }
rlm@1 4466
rlm@1 4467 if (buffer[0] == 'n' || buffer[0] == 'N')
rlm@1 4468 break;
rlm@1 4469 }
rlm@1 4470 #endif
rlm@1 4471 if (kill)
rlm@1 4472 {
rlm@1 4473 luaL_error(L, "Killed by user request.");
rlm@1 4474 VBALuaOnStop();
rlm@1 4475 }
rlm@1 4476
rlm@1 4477 // else, kill the debug hook.
rlm@1 4478 lua_sethook(L, NULL, 0, 0);
rlm@1 4479 }
rlm@1 4480 }
rlm@1 4481
rlm@1 4482 static const struct luaL_reg vbalib[] = {
rlm@1 4483 // {"speedmode", vba_speedmode}, // TODO: NYI
rlm@1 4484 { "frameadvance", vba_frameadvance },
rlm@1 4485 { "pause", vba_pause },
rlm@1 4486 { "framecount", vba_framecount },
rlm@1 4487 { "lagcount", vba_getlagcount },
rlm@1 4488 { "lagged", vba_lagged },
rlm@1 4489 { "emulating", vba_emulating },
rlm@1 4490 { "registerbefore", vba_registerbefore },
rlm@1 4491 { "registerafter", vba_registerafter },
rlm@1 4492 { "registerexit", vba_registerexit },
rlm@1 4493 { "message", vba_message },
rlm@1 4494 { "print", print }, // sure, why not
rlm@1 4495 { NULL, NULL }
rlm@1 4496 };
rlm@1 4497
rlm@1 4498 static const struct luaL_reg memorylib[] = {
rlm@1 4499 { "readbyte", memory_readbyte },
rlm@1 4500 { "readbytesigned", memory_readbytesigned },
rlm@1 4501 { "readword", memory_readword },
rlm@1 4502 { "readwordsigned", memory_readwordsigned },
rlm@1 4503 { "readdword", memory_readdword },
rlm@1 4504 { "readdwordsigned", memory_readdwordsigned },
rlm@1 4505 { "readbyterange", memory_readbyterange },
rlm@1 4506 { "writebyte", memory_writebyte },
rlm@1 4507 { "writeword", memory_writeword },
rlm@1 4508 { "writedword", memory_writedword },
rlm@1 4509 { "getregister", memory_getregister },
rlm@1 4510 { "setregister", memory_setregister },
rlm@1 4511 { "gbromreadbyte", memory_gbromreadbyte },
rlm@1 4512 { "gbromreadbytesigned", memory_gbromreadbytesigned },
rlm@1 4513 { "gbromreadword", memory_gbromreadword },
rlm@1 4514 { "gbromreadwordsigned", memory_gbromreadwordsigned },
rlm@1 4515 { "gbromreaddword", memory_gbromreaddword },
rlm@1 4516 { "gbromreaddwordsigned", memory_gbromreaddwordsigned },
rlm@1 4517 { "gbromreadbyterange", memory_gbromreadbyterange },
rlm@1 4518
rlm@1 4519 // alternate naming scheme for word and double-word and unsigned
rlm@1 4520 { "readbyteunsigned", memory_readbyte },
rlm@1 4521 { "readwordunsigned", memory_readword },
rlm@1 4522 { "readdwordunsigned", memory_readdword },
rlm@1 4523 { "readshort", memory_readword },
rlm@1 4524 { "readshortunsigned", memory_readword },
rlm@1 4525 { "readshortsigned", memory_readwordsigned },
rlm@1 4526 { "readlong", memory_readdword },
rlm@1 4527 { "readlongunsigned", memory_readdword },
rlm@1 4528 { "readlongsigned", memory_readdwordsigned },
rlm@1 4529 { "writeshort", memory_writeword },
rlm@1 4530 { "writelong", memory_writedword },
rlm@1 4531 { "gbromreadbyteunsigned", memory_gbromreadbyte },
rlm@1 4532 { "gbromreadwordunsigned", memory_gbromreadword },
rlm@1 4533 { "gbromreaddwordunsigned", memory_gbromreaddword },
rlm@1 4534 { "gbromreadshort", memory_gbromreadword },
rlm@1 4535 { "gbromreadshortunsigned", memory_gbromreadword },
rlm@1 4536 { "gbromreadshortsigned", memory_gbromreadwordsigned },
rlm@1 4537 { "gbromreadlong", memory_gbromreaddword },
rlm@1 4538 { "gbromreadlongunsigned", memory_gbromreaddword },
rlm@1 4539 { "gbromreadlongsigned", memory_gbromreaddwordsigned },
rlm@1 4540
rlm@1 4541 // memory hooks
rlm@1 4542 { "registerwrite", memory_registerwrite },
rlm@1 4543 //{"registerread", memory_registerread},
rlm@1 4544 { "registerexec", memory_registerexec },
rlm@1 4545 // alternate names
rlm@1 4546 { "register", memory_registerwrite },
rlm@1 4547 { "registerrun", memory_registerexec },
rlm@1 4548 { "registerexecute", memory_registerexec },
rlm@1 4549
rlm@1 4550 { NULL, NULL }
rlm@1 4551 };
rlm@1 4552
rlm@1 4553 static const struct luaL_reg joypadlib[] = {
rlm@1 4554 { "get", joypad_get },
rlm@1 4555 { "getdown", joypad_getdown },
rlm@1 4556 { "getup", joypad_getup },
rlm@1 4557 { "set", joypad_set },
rlm@1 4558
rlm@1 4559 // alternative names
rlm@1 4560 { "read", joypad_get },
rlm@1 4561 { "write", joypad_set },
rlm@1 4562 { "readdown", joypad_getdown },
rlm@1 4563 { "readup", joypad_getup },
rlm@1 4564 { NULL, NULL }
rlm@1 4565 };
rlm@1 4566
rlm@1 4567 static const struct luaL_reg savestatelib[] = {
rlm@1 4568 { "create", savestate_create },
rlm@1 4569 { "save", savestate_save },
rlm@1 4570 { "load", savestate_load },
rlm@1 4571
rlm@1 4572 { NULL, NULL }
rlm@1 4573 };
rlm@1 4574
rlm@1 4575 static const struct luaL_reg movielib[] = {
rlm@1 4576 { "active", movie_isactive },
rlm@1 4577 { "recording", movie_isrecording },
rlm@1 4578 { "playing", movie_isplaying },
rlm@1 4579 { "mode", movie_getmode },
rlm@1 4580
rlm@1 4581 { "length", movie_getlength },
rlm@1 4582 { "author", movie_getauthor },
rlm@1 4583 { "name", movie_getfilename },
rlm@1 4584 { "rerecordcount", movie_rerecordcount },
rlm@1 4585 { "setrerecordcount", movie_setrerecordcount },
rlm@1 4586
rlm@1 4587 { "rerecordcounting", movie_rerecordcounting },
rlm@1 4588 { "framecount", vba_framecount }, // for those familiar with
rlm@1 4589 // other emulators that have
rlm@1 4590 // movie.framecount()
rlm@1 4591 // instead of
rlm@1 4592 // emulatorname.framecount()
rlm@1 4593
rlm@1 4594 { "stop", movie_stop },
rlm@1 4595
rlm@1 4596 // alternative names
rlm@1 4597 { "close", movie_stop },
rlm@1 4598 { "getauthor", movie_getauthor },
rlm@1 4599 { "getname", movie_getfilename },
rlm@1 4600 { NULL, NULL }
rlm@1 4601 };
rlm@1 4602
rlm@1 4603 static const struct luaL_reg guilib[] = {
rlm@1 4604 { "register", gui_register },
rlm@1 4605 { "text", gui_text },
rlm@1 4606 { "box", gui_drawbox },
rlm@1 4607 { "line", gui_drawline },
rlm@1 4608 { "pixel", gui_drawpixel },
rlm@1 4609 { "opacity", gui_setopacity },
rlm@1 4610 { "transparency", gui_transparency },
rlm@1 4611 { "popup", gui_popup },
rlm@1 4612 { "parsecolor", gui_parsecolor },
rlm@1 4613 { "gdscreenshot", gui_gdscreenshot },
rlm@1 4614 { "gdoverlay", gui_gdoverlay },
rlm@1 4615 { "getpixel", gui_getpixel },
rlm@1 4616
rlm@1 4617 // alternative names
rlm@1 4618 { "drawtext", gui_text },
rlm@1 4619 { "drawbox", gui_drawbox },
rlm@1 4620 { "drawline", gui_drawline },
rlm@1 4621 { "drawpixel", gui_drawpixel },
rlm@1 4622 { "setpixel", gui_drawpixel },
rlm@1 4623 { "writepixel", gui_drawpixel },
rlm@1 4624 { "rect", gui_drawbox },
rlm@1 4625 { "drawrect", gui_drawbox },
rlm@1 4626 { "drawimage", gui_gdoverlay },
rlm@1 4627 { "image", gui_gdoverlay },
rlm@1 4628 { "readpixel", gui_getpixel },
rlm@1 4629 { NULL, NULL }
rlm@1 4630 };
rlm@1 4631
rlm@1 4632 static const struct luaL_reg inputlib[] = {
rlm@1 4633 { "get", input_getcurrentinputstatus },
rlm@1 4634
rlm@1 4635 // alternative names
rlm@1 4636 { "read", input_getcurrentinputstatus },
rlm@1 4637 { NULL, NULL }
rlm@1 4638 };
rlm@1 4639
rlm@1 4640 static const struct luaL_reg soundlib[] = {
rlm@1 4641 { "get", sound_get },
rlm@1 4642
rlm@1 4643 // alternative names
rlm@1 4644 { NULL, NULL }
rlm@1 4645 };
rlm@1 4646
rlm@1 4647 // gocha: since vba dumps avi so badly,
rlm@1 4648 // I add avilib as a workaround for enhanced video encoding.
rlm@1 4649 static const struct luaL_reg avilib[] = {
rlm@1 4650 { "framecount", avi_framecount },
rlm@1 4651 { "pause", avi_pause },
rlm@1 4652 { "resume", avi_resume },
rlm@1 4653 { NULL, NULL }
rlm@1 4654 };
rlm@1 4655
rlm@1 4656 void CallExitFunction(void)
rlm@1 4657 {
rlm@1 4658 if (!LUA)
rlm@1 4659 return;
rlm@1 4660
rlm@1 4661 lua_settop(LUA, 0);
rlm@1 4662 lua_getfield(LUA, LUA_REGISTRYINDEX, luaCallIDStrings[LUACALL_BEFOREEXIT]);
rlm@1 4663
rlm@1 4664 int errorcode = 0;
rlm@1 4665 if (lua_isfunction(LUA, -1))
rlm@1 4666 {
rlm@1 4667 errorcode = lua_pcall(LUA, 0, 0, 0);
rlm@1 4668 }
rlm@1 4669
rlm@1 4670 if (errorcode)
rlm@1 4671 HandleCallbackError(LUA);
rlm@1 4672 }
rlm@1 4673
rlm@1 4674 void VBALuaFrameBoundary(void)
rlm@1 4675 {
rlm@1 4676 // printf("Lua Frame\n");
rlm@1 4677
rlm@1 4678 lua_joypads_used = 0;
rlm@1 4679
rlm@1 4680 // HA!
rlm@1 4681 if (!LUA || !luaRunning)
rlm@1 4682 return;
rlm@1 4683
rlm@1 4684 // Our function needs calling
rlm@1 4685 lua_settop(LUA, 0);
rlm@1 4686 lua_getfield(LUA, LUA_REGISTRYINDEX, frameAdvanceThread);
rlm@1 4687
rlm@1 4688 lua_State *thread = lua_tothread(LUA, 1);
rlm@1 4689
rlm@1 4690 // Lua calling C must know that we're busy inside a frame boundary
rlm@1 4691 frameBoundary = true;
rlm@1 4692 frameAdvanceWaiting = false;
rlm@1 4693
rlm@1 4694 numTries = 1000;
rlm@1 4695
rlm@1 4696 int result = lua_resume(thread, 0);
rlm@1 4697
rlm@1 4698 if (result == LUA_YIELD)
rlm@1 4699 {
rlm@1 4700 // Okay, we're fine with that.
rlm@1 4701 }
rlm@1 4702 else if (result != 0)
rlm@1 4703 {
rlm@1 4704 // Done execution by bad causes
rlm@1 4705 VBALuaOnStop();
rlm@1 4706 lua_pushnil(LUA);
rlm@1 4707 lua_setfield(LUA, LUA_REGISTRYINDEX, frameAdvanceThread);
rlm@1 4708 lua_pushnil(LUA);
rlm@1 4709 lua_setfield(LUA, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 4710
rlm@1 4711 // Error?
rlm@1 4712 //#if (defined(WIN32) && !defined(SDL))
rlm@1 4713 // info_print(info_uid, lua_tostring(thread, -1)); //Clear_Sound_Buffer();
rlm@1 4714 // AfxGetApp()->m_pMainWnd->MessageBox(lua_tostring(thread, -1), "Lua run error", MB_OK | MB_ICONSTOP);
rlm@1 4715 //#else
rlm@1 4716 // fprintf(stderr, "Lua thread bombed out: %s\n", lua_tostring(thread, -1));
rlm@1 4717 //#endif
rlm@1 4718 printerror(thread, -1);
rlm@1 4719 }
rlm@1 4720 else
rlm@1 4721 {
rlm@1 4722 VBALuaOnStop();
rlm@1 4723 printf("Script died of natural causes.\n");
rlm@1 4724 }
rlm@1 4725
rlm@1 4726 // Past here, VBA actually runs, so any Lua code is called mid-frame. We must
rlm@1 4727 // not do anything too stupid, so let ourselves know.
rlm@1 4728 frameBoundary = false;
rlm@1 4729
rlm@1 4730 if (!frameAdvanceWaiting)
rlm@1 4731 {
rlm@1 4732 VBALuaOnStop();
rlm@1 4733 }
rlm@1 4734 }
rlm@1 4735
rlm@1 4736 /**
rlm@1 4737 * Loads and runs the given Lua script.
rlm@1 4738 * The emulator MUST be paused for this function to be
rlm@1 4739 * called. Otherwise, all frame boundary assumptions go out the window.
rlm@1 4740 *
rlm@1 4741 * Returns true on success, false on failure.
rlm@1 4742 */
rlm@1 4743 int VBALoadLuaCode(const char *filename)
rlm@1 4744 {
rlm@1 4745 static bool sfmtInitialized = false;
rlm@1 4746 if (!sfmtInitialized)
rlm@1 4747 {
rlm@1 4748 init_gen_rand((unsigned)time(NULL));
rlm@1 4749 sfmtInitialized = true;
rlm@1 4750 }
rlm@1 4751
rlm@1 4752 if (filename != luaScriptName)
rlm@1 4753 {
rlm@1 4754 if (luaScriptName)
rlm@1 4755 free(luaScriptName);
rlm@1 4756 luaScriptName = strdup(filename);
rlm@1 4757 }
rlm@1 4758
rlm@1 4759 //stop any lua we might already have had running
rlm@1 4760 VBALuaStop();
rlm@1 4761
rlm@1 4762 // Set current directory from filename (for dofile)
rlm@1 4763 char dir[_MAX_PATH];
rlm@1 4764 char *slash, *backslash;
rlm@1 4765 strcpy(dir, filename);
rlm@1 4766 slash = strrchr(dir, '/');
rlm@1 4767 backslash = strrchr(dir, '\\');
rlm@1 4768 if (!slash || (backslash && backslash < slash))
rlm@1 4769 slash = backslash;
rlm@1 4770 if (slash)
rlm@1 4771 {
rlm@1 4772 slash[1] = '\0'; // keep slash itself for some reasons
rlm@1 4773 chdir(dir);
rlm@1 4774 }
rlm@1 4775
rlm@1 4776 if (!LUA)
rlm@1 4777 {
rlm@1 4778 LUA = lua_open();
rlm@1 4779 luaL_openlibs(LUA);
rlm@1 4780
rlm@1 4781 luaL_register(LUA, "emu", vbalib); // added for better cross-emulator compatibility
rlm@1 4782 luaL_register(LUA, "vba", vbalib); // kept for backward compatibility
rlm@1 4783 luaL_register(LUA, "memory", memorylib);
rlm@1 4784 luaL_register(LUA, "joypad", joypadlib);
rlm@1 4785 luaL_register(LUA, "savestate", savestatelib);
rlm@1 4786 luaL_register(LUA, "movie", movielib);
rlm@1 4787 luaL_register(LUA, "gui", guilib);
rlm@1 4788 luaL_register(LUA, "input", inputlib);
rlm@1 4789 luaL_register(LUA, "sound", soundlib);
rlm@1 4790 luaL_register(LUA, "bit", bit_funcs); // LuaBitOp library
rlm@1 4791 luaL_register(LUA, "avi", avilib); // workaround for enhanced video encoding
rlm@1 4792 lua_settop(LUA, 0); // clean the stack, because each call to luaL_register leaves a table on top
rlm@1 4793
rlm@1 4794 // register a few utility functions outside of libraries (in the global namespace)
rlm@1 4795 lua_register(LUA, "print", print);
rlm@1 4796 lua_register(LUA, "tostring", tostring);
rlm@1 4797 lua_register(LUA, "addressof", addressof);
rlm@1 4798 lua_register(LUA, "copytable", copytable);
rlm@1 4799
rlm@1 4800 // old bit operation functions
rlm@1 4801 lua_register(LUA, "AND", bit_band);
rlm@1 4802 lua_register(LUA, "OR", bit_bor);
rlm@1 4803 lua_register(LUA, "XOR", bit_bxor);
rlm@1 4804 lua_register(LUA, "SHIFT", bit_bshift_emulua);
rlm@1 4805 lua_register(LUA, "BIT", bitbit);
rlm@1 4806
rlm@1 4807 luabitop_validate(LUA);
rlm@1 4808
rlm@1 4809 lua_pushstring(LUA, "math");
rlm@1 4810 lua_gettable(LUA, LUA_GLOBALSINDEX);
rlm@1 4811 lua_pushcfunction(LUA, sfmt_random);
rlm@1 4812 lua_setfield(LUA, -2, "random");
rlm@1 4813 lua_pushcfunction(LUA, sfmt_randomseed);
rlm@1 4814 lua_setfield(LUA, -2, "randomseed");
rlm@1 4815 lua_settop(LUA, 0);
rlm@1 4816
rlm@1 4817 // push arrays for storing hook functions in
rlm@1 4818 for (int i = 0; i < LUAMEMHOOK_COUNT; i++)
rlm@1 4819 {
rlm@1 4820 lua_newtable(LUA);
rlm@1 4821 lua_setfield(LUA, LUA_REGISTRYINDEX, luaMemHookTypeStrings[i]);
rlm@1 4822 }
rlm@1 4823 }
rlm@1 4824
rlm@1 4825 // We make our thread NOW because we want it at the bottom of the stack.
rlm@1 4826 // If all goes wrong, we let the garbage collector remove it.
rlm@1 4827 lua_State *thread = lua_newthread(LUA);
rlm@1 4828
rlm@1 4829 // Load the data
rlm@1 4830 int result = luaL_loadfile(LUA, filename);
rlm@1 4831
rlm@1 4832 if (result)
rlm@1 4833 {
rlm@1 4834 //#if (defined(WIN32) && !defined(SDL))
rlm@1 4835 // info_print(info_uid, lua_tostring(LUA, -1)); //Clear_Sound_Buffer();
rlm@1 4836 // AfxGetApp()->m_pMainWnd->MessageBox(lua_tostring(LUA, -1), "Lua load error", MB_OK | MB_ICONSTOP);
rlm@1 4837 //#else
rlm@1 4838 // fprintf(stderr, "Failed to compile file: %s\n", lua_tostring(LUA, -1));
rlm@1 4839 //#endif
rlm@1 4840 printerror(LUA, -1);
rlm@1 4841
rlm@1 4842 // Wipe the stack. Our thread
rlm@1 4843 lua_settop(LUA, 0);
rlm@1 4844 return 0; // Oh shit.
rlm@1 4845 }
rlm@1 4846
rlm@1 4847 // Get our function into it
rlm@1 4848 lua_xmove(LUA, thread, 1);
rlm@1 4849
rlm@1 4850 // Save the thread to the registry. This is why I make the thread FIRST.
rlm@1 4851 lua_setfield(LUA, LUA_REGISTRYINDEX, frameAdvanceThread);
rlm@1 4852
rlm@1 4853 // Initialize settings
rlm@1 4854 luaRunning = true;
rlm@1 4855 skipRerecords = false;
rlm@1 4856 numMemHooks = 0;
rlm@1 4857 transparencyModifier = 255; // opaque
rlm@1 4858 lua_joypads_used = 0; // not used
rlm@1 4859 //wasPaused = systemIsPaused();
rlm@1 4860 //systemSetPause(false);
rlm@1 4861
rlm@1 4862 // Set up our protection hook to be executed once every 10,000 bytecode instructions.
rlm@1 4863 lua_sethook(thread, VBALuaHookFunction, LUA_MASKCOUNT, 10000);
rlm@1 4864
rlm@1 4865 #ifdef WIN32
rlm@1 4866 info_print = PrintToWindowConsole;
rlm@1 4867 info_onstart = WinLuaOnStart;
rlm@1 4868 info_onstop = WinLuaOnStop;
rlm@1 4869 if (!LuaConsoleHWnd)
rlm@1 4870 LuaConsoleHWnd = CreateDialog(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDD_LUA),
rlm@1 4871 AfxGetMainWnd()->GetSafeHwnd(), (DLGPROC) DlgLuaScriptDialog);
rlm@1 4872 info_uid = (int)LuaConsoleHWnd;
rlm@1 4873 #else
rlm@1 4874 info_print = NULL;
rlm@1 4875 info_onstart = NULL;
rlm@1 4876 info_onstop = NULL;
rlm@1 4877 #endif
rlm@1 4878 if (info_onstart)
rlm@1 4879 info_onstart(info_uid);
rlm@1 4880
rlm@1 4881 // And run it right now. :)
rlm@1 4882 VBALuaFrameBoundary();
rlm@1 4883 systemRenderFrame();
rlm@1 4884
rlm@1 4885 // We're done.
rlm@1 4886 return 1;
rlm@1 4887 }
rlm@1 4888
rlm@1 4889 /**
rlm@1 4890 * Equivalent to repeating the last VBALoadLuaCode() call.
rlm@1 4891 */
rlm@1 4892 int VBAReloadLuaCode(void)
rlm@1 4893 {
rlm@1 4894 if (!luaScriptName)
rlm@1 4895 {
rlm@1 4896 systemScreenMessage("There's no script to reload.");
rlm@1 4897 return 0;
rlm@1 4898 }
rlm@1 4899 else
rlm@1 4900 return VBALoadLuaCode(luaScriptName);
rlm@1 4901 }
rlm@1 4902
rlm@1 4903 /**
rlm@1 4904 * Terminates a running Lua script by killing the whole Lua engine.
rlm@1 4905 *
rlm@1 4906 * Always safe to call, except from within a lua call itself (duh).
rlm@1 4907 *
rlm@1 4908 */
rlm@1 4909 void VBALuaStop(void)
rlm@1 4910 {
rlm@1 4911 //already killed
rlm@1 4912 if (!LUA)
rlm@1 4913 return;
rlm@1 4914
rlm@1 4915 //execute the user's shutdown callbacks
rlm@1 4916 CallExitFunction();
rlm@1 4917
rlm@1 4918 /*info.*/ numMemHooks = 0;
rlm@1 4919 for (int i = 0; i < LUAMEMHOOK_COUNT; i++)
rlm@1 4920 CalculateMemHookRegions((LuaMemHookType)i);
rlm@1 4921
rlm@1 4922 //sometimes iup uninitializes com
rlm@1 4923 //MBG TODO - test whether this is really necessary. i dont think it is
rlm@1 4924 #if (defined(WIN32) && !defined(SDL))
rlm@1 4925 CoInitialize(0);
rlm@1 4926 #endif
rlm@1 4927
rlm@1 4928 if (info_onstop)
rlm@1 4929 info_onstop(info_uid);
rlm@1 4930
rlm@1 4931 //lua_gc(LUA,LUA_GCCOLLECT,0);
rlm@1 4932 lua_close(LUA); // this invokes our garbage collectors for us
rlm@1 4933 LUA = NULL;
rlm@1 4934 VBALuaOnStop();
rlm@1 4935 }
rlm@1 4936
rlm@1 4937 /**
rlm@1 4938 * Returns true if there is a Lua script running.
rlm@1 4939 *
rlm@1 4940 */
rlm@1 4941 int VBALuaRunning(void)
rlm@1 4942 {
rlm@1 4943 // FIXME: return false when no callback functions are registered.
rlm@1 4944 return (int) (LUA != NULL); // should return true if callback functions are active.
rlm@1 4945 }
rlm@1 4946
rlm@1 4947 /**
rlm@1 4948 * Returns true if Lua would like to steal the given joypad control.
rlm@1 4949 *
rlm@1 4950 * Range is 0 through 3
rlm@1 4951 */
rlm@1 4952 int VBALuaUsingJoypad(int which)
rlm@1 4953 {
rlm@1 4954 if (which < 0 || which > 3)
rlm@1 4955 which = systemGetDefaultJoypad();
rlm@1 4956 return lua_joypads_used & (1 << which);
rlm@1 4957 }
rlm@1 4958
rlm@1 4959 /**
rlm@1 4960 * Reads the buttons Lua is feeding for the given joypad, in the same
rlm@1 4961 * format as the OS-specific code.
rlm@1 4962 *
rlm@1 4963 * <del>This function must not be called more than once per frame. </del>Ideally exactly once
rlm@1 4964 * per frame (if VBALuaUsingJoypad says it's safe to do so)
rlm@1 4965 */
rlm@1 4966 int VBALuaReadJoypad(int which)
rlm@1 4967 {
rlm@1 4968 if (which < 0 || which > 3)
rlm@1 4969 which = systemGetDefaultJoypad();
rlm@1 4970
rlm@1 4971 //lua_joypads_used &= ~(1 << which);
rlm@1 4972 return lua_joypads[which];
rlm@1 4973 }
rlm@1 4974
rlm@1 4975 /**
rlm@1 4976 * If this function returns true, the movie code should NOT increment
rlm@1 4977 * the rerecord count for a load-state.
rlm@1 4978 *
rlm@1 4979 * This function will not return true if a script is not running.
rlm@1 4980 */
rlm@1 4981 bool8 VBALuaRerecordCountSkip(void)
rlm@1 4982 {
rlm@1 4983 // FIXME: return true if (there are any active callback functions && skipRerecords)
rlm@1 4984 return LUA && luaRunning && skipRerecords;
rlm@1 4985 }
rlm@1 4986
rlm@1 4987 /**
rlm@1 4988 * Given a screen with the indicated resolution,
rlm@1 4989 * draw the current GUI onto it.
rlm@1 4990 */
rlm@1 4991 void VBALuaGui(uint8 *screen, int ppl, int width, int height)
rlm@1 4992 {
rlm@1 4993 if (!LUA /* || !luaRunning*/)
rlm@1 4994 return;
rlm@1 4995
rlm@1 4996 // First, check if we're being called by anybody
rlm@1 4997 lua_getfield(LUA, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 4998
rlm@1 4999 if (lua_isfunction(LUA, -1))
rlm@1 5000 {
rlm@1 5001 // We call it now
rlm@1 5002 numTries = 1000;
rlm@1 5003
rlm@1 5004 int ret = lua_pcall(LUA, 0, 0, 0);
rlm@1 5005 if (ret != 0)
rlm@1 5006 {
rlm@1 5007 // This is grounds for trashing the function
rlm@1 5008 // Note: This must be done before the messagebox pops up,
rlm@1 5009 // otherwise the messagebox will cause a paint event which causes a weird
rlm@1 5010 // infinite call sequence that makes Snes9x silently exit with error code 3,
rlm@1 5011 // if a Lua GUI function crashes. (nitsuja)
rlm@1 5012 lua_pushnil(LUA);
rlm@1 5013 lua_setfield(LUA, LUA_REGISTRYINDEX, guiCallbackTable);
rlm@1 5014
rlm@1 5015 //#if (defined(WIN32) && !defined(SDL))
rlm@1 5016 // info_print(info_uid, lua_tostring(LUA, -1)); //AfxGetApp()->m_pMainWnd->MessageBox(lua_tostring(LUA, -1), "Lua Error
rlm@1 5017 // in GUI function", MB_OK);
rlm@1 5018 //#else
rlm@1 5019 // fprintf(stderr, "Lua error in gui.register function: %s\n", lua_tostring(LUA, -1));
rlm@1 5020 //#endif
rlm@1 5021 printerror(LUA, -1);
rlm@1 5022 }
rlm@1 5023 }
rlm@1 5024
rlm@1 5025 // And wreak the stack
rlm@1 5026 lua_settop(LUA, 0);
rlm@1 5027
rlm@1 5028 if (!gui_used)
rlm@1 5029 return;
rlm@1 5030
rlm@1 5031 gui_used = false;
rlm@1 5032
rlm@1 5033 int x, y;
rlm@1 5034
rlm@1 5035 //int pitch = (((ppl * systemColorDepth + 7)>>3)+3)&~3;
rlm@1 5036 int pitch = ppl * (systemColorDepth / 8) + (systemColorDepth == 24 ? 0 : 4);
rlm@1 5037
rlm@1 5038 if (width > LUA_SCREEN_WIDTH)
rlm@1 5039 width = LUA_SCREEN_WIDTH;
rlm@1 5040 if (height > LUA_SCREEN_HEIGHT)
rlm@1 5041 height = LUA_SCREEN_HEIGHT;
rlm@1 5042
rlm@1 5043 GetColorFunc getColor;
rlm@1 5044 SetColorFunc setColor;
rlm@1 5045 getColorIOFunc(systemColorDepth, &getColor, &setColor);
rlm@1 5046
rlm@1 5047 for (y = 0; y < height; y++)
rlm@1 5048 {
rlm@1 5049 uint8 *scr = &screen[y * pitch];
rlm@1 5050 for (x = 0; x < width; x++, scr += systemColorDepth / 8)
rlm@1 5051 {
rlm@1 5052 const uint8 gui_alpha = gui_data[(y * LUA_SCREEN_WIDTH + x) * 4 + 3];
rlm@1 5053 if (gui_alpha == 0)
rlm@1 5054 {
rlm@1 5055 // do nothing
rlm@1 5056 continue;
rlm@1 5057 }
rlm@1 5058
rlm@1 5059 const uint8 gui_red = gui_data[(y * LUA_SCREEN_WIDTH + x) * 4 + 2];
rlm@1 5060 const uint8 gui_green = gui_data[(y * LUA_SCREEN_WIDTH + x) * 4 + 1];
rlm@1 5061 const uint8 gui_blue = gui_data[(y * LUA_SCREEN_WIDTH + x) * 4];
rlm@1 5062 int red, green, blue;
rlm@1 5063
rlm@1 5064 if (gui_alpha == 255)
rlm@1 5065 {
rlm@1 5066 // direct copy
rlm@1 5067 red = gui_red;
rlm@1 5068 green = gui_green;
rlm@1 5069 blue = gui_blue;
rlm@1 5070 }
rlm@1 5071 else
rlm@1 5072 {
rlm@1 5073 // alpha-blending
rlm@1 5074 uint8 scr_red, scr_green, scr_blue;
rlm@1 5075 getColor(scr, &scr_red, &scr_green, &scr_blue);
rlm@1 5076 red = (((int)gui_red - scr_red) * gui_alpha / 255 + scr_red) & 255;
rlm@1 5077 green = (((int)gui_green - scr_green) * gui_alpha / 255 + scr_green) & 255;
rlm@1 5078 blue = (((int)gui_blue - scr_blue) * gui_alpha / 255 + scr_blue) & 255;
rlm@1 5079 }
rlm@1 5080
rlm@1 5081 setColor(scr, (uint8) red, (uint8) green, (uint8) blue);
rlm@1 5082 }
rlm@1 5083 }
rlm@1 5084
rlm@1 5085 return;
rlm@1 5086 }
rlm@1 5087
rlm@1 5088 void VBALuaClearGui(void)
rlm@1 5089 {
rlm@1 5090 gui_used = false;
rlm@1 5091 }
rlm@1 5092
rlm@1 5093 lua_State *VBAGetLuaState()
rlm@1 5094 {
rlm@1 5095 return LUA;
rlm@1 5096 }
rlm@1 5097
rlm@1 5098 char *VBAGetLuaScriptName()
rlm@1 5099 {
rlm@1 5100 return luaScriptName;
rlm@1 5101 }
rlm@1 5102