void ImageLoader::RegisterExtraGfx(const std::string& folderName, const std::string& name)
{
if (name.length() == 0) return;
std::wstring wFolderName = Str2WStr(folderName);
std::wstring wName = Str2WStr(name);
std::vector<std::wstring> searchPath;
if (!gIsOverworld)
searchPath.push_back(normalizePathSlashes(getCustomFolderPath())); // Check custom folder
searchPath.push_back(normalizePathSlashes(GM_FULLDIR)); // Check episode dir
searchPath.push_back(normalizePathSlashes(GM_FULLDIR) + L"/graphics/" + wFolderName); // Check episode dir
searchPath.push_back(normalizePathSlashes(gAppPathWCHAR) + L"/graphics/" + wFolderName); // Check base game
std::shared_ptr<LunaImage> img = nullptr;
for (auto pathIt = searchPath.cbegin(); pathIt != searchPath.cend(); pathIt++)
{
std::wstring imgPath = *pathIt + L"/" + wName + L".png";
img = LunaImage::fromFile(imgPath.c_str());
if (img)
{
break;
}
}
// Add to map, even if null
m_ExtraGfx[name] = img;
}
bool DirMan::rmAbsPath(const std::string &dirPath)
{
BOOL ret = TRUE;
struct DirStackEntry
{
std::wstring path;
HANDLE hFind;
WIN32_FIND_DATAW data;
};
std::stack<DirStackEntry> dirStack;
DirStackEntry ds;
ds.hFind = NULL;
memset(&ds.data, 0, sizeof(WIN32_FIND_DATAW));
ds.path = Str2WStr(dirPath);
dirStack.push(ds);
while(!dirStack.empty())
{
DirStackEntry *e = &dirStack.top();
e->hFind = FindFirstFileW((e->path + L"/*").c_str(), &e->data);
bool walkUp = false;
if(e->hFind != INVALID_HANDLE_VALUE)
{
do
{
if((wcscmp(e->data.cFileName, L"..") == 0) || (wcscmp(e->data.cFileName, L".") == 0))
continue;
std::wstring path = e->path + L"/" + e->data.cFileName;
if((e->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
{
FindClose(e->hFind);
ds.path = path;
dirStack.push(ds);
walkUp = true;
break;
}
else
{
if(DeleteFileW(path.c_str()) == FALSE)
ret = FALSE;
}
}
while(FindNextFileW(e->hFind, &e->data));
}
if(!walkUp)
{
if(e->hFind) FindClose(e->hFind);
if(RemoveDirectoryW(e->path.c_str()) == FALSE)
ret = FALSE;
e = NULL;
dirStack.pop();
}
}
return (ret == TRUE);
}
void PerfTracker::renderStats() const {
for (int i = 0; i < PerfTracker::PERF_MAX; i++) {
std::ostringstream s;
s << PerfTypeNames[i] << ": ";
s << m_PerfTimesSnapshot[i];
RenderStringOp* printTextOp = new RenderStringOp(Str2WStr(s.str()), 3, 10, 100.0f+(float)i*15.0f);
Renderer::Get().AddOp(printTextOp);
}
}
bool DirMan::exists(const std::string &dirPath)
{
DWORD ftyp = GetFileAttributesW(Str2WStr(dirPath).c_str());
if(ftyp == INVALID_FILE_ATTRIBUTES)
return false; //something is wrong with your path!
if(ftyp & FILE_ATTRIBUTE_DIRECTORY)
return true; // this is a directory!
return false; // this is not a directory!
}
bool Files::deleteFile(const std::string &path)
{
#ifdef _WIN32
std::wstring wpath = Str2WStr(path);
return (DeleteFileW(wpath.c_str()) == TRUE);
#else
return ::unlink(path.c_str()) == 0;
#endif
}
std::shared_ptr<BMPBox> LuaProxy::Graphics::loadMedia(const std::string& filename) {
std::wstring full_path;
if (!isAbsolutePath(filename)) {
full_path = getCustomFolderPath() + Str2WStr(filename);
}
else
{
full_path = Str2WStr(filename);
}
std::shared_ptr<BMPBox> img = std::make_shared<BMPBox>(full_path, gLunaRender.GetScreenDC());
if (img->ImageLoaded() == false) {
// If image loading failed, return null
return NULL;
}
return img;
}
void DirMan::DirMan_private::setPath(const std::string &dirPath)
{
m_dirPathW = Str2WStr(dirPath);
wchar_t fullPath[MAX_PATH];
GetFullPathNameW(m_dirPathW.c_str(), MAX_PATH, fullPath, NULL);
m_dirPathW = fullPath;
//Force UNIX paths
std::replace(m_dirPathW.begin(), m_dirPathW.end(), L'\\', L'/');
m_dirPath = WStr2Str(m_dirPathW);
delEnd(m_dirPathW, L'/');
delEnd(m_dirPath, '/');
}
void LuaProxy::Graphics::placeSprite(int type, const LuaProxy::Graphics::LuaImageResource& img, int xPos, int yPos, const std::string& extra, int time)
{
CSpriteRequest req;
req.type = type;
req.img_resource_code = -1;
req.direct_img = img.img;
req.x = xPos;
req.y = yPos;
req.time = time;
req.str = Str2WStr(extra);
gSpriteMan.InstantiateSprite(&req, false);
}
bool Files::fileExists(const std::string &path)
{
#ifdef _WIN32
std::wstring wpath = Str2WStr(path);
return PathFileExistsW(wpath.c_str()) == TRUE;
#else
FILE *ops = fopen(path.c_str(), "rb");
if(ops)
{
fclose(ops);
return true;
}
return false;
#endif
}
luabind::object LuaProxy::findlevel(const std::string &toFindName, lua_State* L)
{
for(int i = 0; i < (signed)GM_LEVEL_COUNT; ++i){
WorldLevel* ctrl = ::SMBXLevel::get(i);
if(ctrl){
std::wstring tarLevelName = Str2WStr(std::string(toFindName));
if(!ctrl->levelTitle)
continue;
std::wstring sourceLevelName(ctrl->levelTitle);
if(tarLevelName == sourceLevelName){
return luabind::object(L, LevelObject(i));
}
}
}
return luabind::object();
}
luabind::object LuaProxy::findlayer(const std::string& layername, lua_State *L)
{
std::wstring tarLayerName = Str2WStr(layername);
for(int i = 0; i < 100; ++i){
LayerControl* ctrl = ::Layer::Get(i);
if(ctrl){
if(!ctrl->ptLayerName)
continue;
std::wstring sourceLayerName(ctrl->ptLayerName);
if(tarLayerName == sourceLayerName){
return luabind::object(L, Layer(i));
}
}
}
return luabind::object();
}
bool DirMan::mkAbsPath(const std::string &dirPath)
{
wchar_t tmp[MAX_PATH];
wchar_t *p = NULL;
size_t len;
wcscpy(tmp, Str2WStr(dirPath).c_str());
len = wcslen(tmp);
if(tmp[len - 1] == L'/')
tmp[len - 1] = 0;
for(p = tmp + 1; *p; p++)
{
if(*p == L'/')
{
*p = 0;
CreateDirectoryW(tmp, NULL);
*p = '/';
}
}
return (CreateDirectoryW(tmp, NULL) != FALSE);
}
void DutTransferSignals(HANDLE hDevice, PCSTR szSigFileName)
{
ULONG nWritten;
DEV_RET Out;
size_t len;
PWSTR wszFileName = (PWSTR)__MALLOC(SYM_FILE_MAX_PATH_LENGTH * sizeof(WCHAR));
PSTR szFileName = (PSTR) __MALLOC(SYM_FILE_MAX_PATH_LENGTH * sizeof(CHAR));
szFileName[0] = '\0';
assert(strlen(szSigFileName) + strlen(FILE_OBJ_NAME_PREFIX) < SYM_FILE_MAX_PATH_LENGTH);
strcat_s(szFileName, SYM_FILE_MAX_PATH_LENGTH, FILE_OBJ_NAME_PREFIX);
strcat_s(szFileName, SYM_FILE_MAX_PATH_LENGTH, szSigFileName);
len = Str2WStr(szFileName, wszFileName , SYM_FILE_MAX_PATH_LENGTH);
if (len == 0)
{
printf("Please specify a signal file (name length no more than 100)\n");
return;
}
DeviceIoControl (
hDevice,
DUT_IO_CODE(CMD_TRANSFER),
wszFileName,
SYM_FILE_MAX_PATH_LENGTH * sizeof(WCHAR),
&Out,
sizeof(DEV_RET),
&nWritten,
NULL);
if (nWritten != sizeof(DEV_RET))
printf("Input error!\n");
else
printf("Ret:0x%08x\n", Out.hResult);
__FREE(wszFileName);
__FREE(szFileName);
}
luabind::object LuaProxy::findlevels(const std::string &toFindName, lua_State* L)
{
luabind::object obj = luabind::newtable(L);
bool found = false;
for(int i = 0, j = 0; i < (signed)GM_LEVEL_COUNT; ++i){
WorldLevel* ctrl = ::SMBXLevel::get(i);
if(ctrl){
std::wstring tarLevelName = Str2WStr(std::string(toFindName));
if(!ctrl->levelTitle)
continue;
std::wstring sourceLayerName(ctrl->levelTitle);
if(sourceLayerName.find(tarLevelName) != std::wstring::npos){
if(!found)
found = true;
obj[j++] = LevelObject(i);
}
}
}
if(!found){
return luabind::object();
}
return obj;
}
return (DeleteFileW(wpath.c_str()) == TRUE);
#else
return ::unlink(path.c_str()) == 0;
#endif
}
bool Files::copyFile(const std::string &to, const std::string &from, bool override)
{
if(!override && fileExists(to))
return false;// Don't override exist target if not requested
bool ret = true;
#ifdef _WIN32
std::wstring wfrom = Str2WStr(from);
std::wstring wto = Str2WStr(to);
ret = (bool)CopyFileW(wfrom.c_str(), wto.c_str(), !override);
#else
char buf[BUFSIZ];
ssize_t size;
ssize_t sizeOut;
int source = open(from.c_str(), O_RDONLY, 0);
if(source == -1)
return false;
int dest = open(to.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0640);
if(dest == -1)
bool LuaProxy::Graphics::loadImage(const std::string& filename, int resNumber, int transColor)
{
return gLunaRender.LoadBitmapResource(Str2WStr(filename), resNumber, transColor);
}
bool DirMan::rmAbsDir(const std::string &dirPath)
{
return RemoveDirectoryW(Str2WStr(dirPath).c_str()) != FALSE;
}
bool DirMan::mkAbsDir(const std::string &dirPath)
{
return (CreateDirectoryW(Str2WStr(dirPath).c_str(), NULL) != FALSE);
}
luabind::object LuaProxy::Graphics::loadAnimatedImage(const std::string& filename, int& smbxFrameTime, lua_State* L)
{
luabind::object tLuaImageResources = luabind::newtable(L);
std::vector<std::shared_ptr<BMPBox>> frames = gLunaRender.LoadAnimatedBitmapResource(Str2WStr(filename), &smbxFrameTime);
for (unsigned int i = 0; i < frames.size(); i++){
tLuaImageResources[i + 1] = luabind::object(L, new LuaProxy::Graphics::LuaImageResource(frames[i]), luabind::adopt(luabind::result));
}
return tLuaImageResources;
}
void LuaProxy::triggerEvent(const std::string& evName)
{
SMBXEvents::TriggerEvent(Str2WStr(evName), 0);
}
void LuaProxy::Graphics::draw(const luabind::object& namedArgs, lua_State* L)
{
if (luabind::type(namedArgs) != LUA_TTABLE) {
luaL_error(L, "Argument #1 must be a table with named arguments!");
return;
}
double x, y;
RENDER_TYPE type;
double priority;
RenderOp* renderOperation;
bool isSceneCoordinates;
LUAHELPER_GET_NAMED_ARG_OR_RETURN_VOID(namedArgs, x);
LUAHELPER_GET_NAMED_ARG_OR_RETURN_VOID(namedArgs, y);
LUAHELPER_GET_NAMED_ARG_OR_RETURN_VOID(namedArgs, type);
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, isSceneCoordinates, false);
if (type == RTYPE_TEXT)
{
priority = RENDEROP_DEFAULT_PRIORITY_TEXT;
std::string text;
int fontType;
LUAHELPER_GET_NAMED_ARG_OR_RETURN_VOID(namedArgs, text);
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, fontType, 3);
RenderStringOp* strRenderOp = new RenderStringOp();
strRenderOp->m_String = Str2WStr(text);
if (fontType == 3)
for (auto& nextChar : strRenderOp->m_String)
nextChar = towupper(nextChar);
strRenderOp->m_X = static_cast<float>(x);
strRenderOp->m_Y = static_cast<float>(y);
strRenderOp->m_FontType = fontType;
strRenderOp->sceneCoords = isSceneCoordinates;
renderOperation = strRenderOp;
}
else if (type == RTYPE_IMAGE)
{
priority = RENDEROP_DEFAULT_PRIORITY_RENDEROP;
LuaImageResource* image;
double sourceX;
double sourceY;
double sourceWidth;
double sourceHeight;
float opacity;
LUAHELPER_GET_NAMED_ARG_OR_RETURN_VOID(namedArgs, image);
if (!image || !image->img || !image->img->ImageLoaded()) {
luaL_error(L, "Image may not be nil.");
return;
}
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, sourceX, 0.0);
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, sourceY, 0.0);
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, sourceWidth, static_cast<double>(image->img->m_W));
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, sourceHeight, static_cast<double>(image->img->m_H));
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, opacity, 1.0f);
RenderBitmapOp* bitmapRenderOp = new RenderBitmapOp();
bitmapRenderOp->direct_img = image->img;
bitmapRenderOp->sx = sourceX;
bitmapRenderOp->sy = sourceY;
bitmapRenderOp->sw = sourceWidth;
bitmapRenderOp->sh = sourceHeight;
bitmapRenderOp->x = x;
bitmapRenderOp->y = y;
bitmapRenderOp->sceneCoords = isSceneCoordinates;
bitmapRenderOp->opacity = opacity;
renderOperation = bitmapRenderOp;
}
else
{
luaL_error(L, "No valid 'type'. Must be RTYPE_TEXT or RTYPE_IMAGE");
return;
}
LUAHELPER_GET_NAMED_ARG_OR_DEFAULT_OR_RETURN_VOID(namedArgs, priority, priority);
renderOperation->m_renderPriority = priority;
gLunaRender.AddOp(renderOperation);
}
