void LaunchMarket(const char *url) { #ifdef _WIN32 ShellExecute(NULL, "open", url, NULL, NULL, SW_SHOWNORMAL); #elif __linux__ std::string command = std::string("xdg-open ") + url; int err = system(command.c_str()); if (err) { ILOG("Would have gone to %s but xdg-utils seems not to be installed", url) } #elif __APPLE__ std::string command = std::string("open ") + url; system(command.c_str()); #else ILOG("Would have gone to %s but LaunchMarket is not implemented on this platform", url); #endif }
extern "C" void Java_com_henrikrydgard_libnative_NativeRenderer_displayRender(JNIEnv *env, jobject obj) { // Too spammy // ILOG("NativeApp.displayRender()"); if (renderer_inited) { // TODO: Look into if these locks are a perf loss { lock_guard guard(input_state.lock); pad_buttons_down |= pad_buttons_async_set; pad_buttons_down &= ~pad_buttons_async_clear; input_state.pad_buttons = pad_buttons_down; UpdateInputState(&input_state); } { lock_guard guard(input_state.lock); input_state.pad_lstick_x = left_joystick_x_async; input_state.pad_lstick_y = left_joystick_y_async; NativeUpdate(input_state); } { lock_guard guard(input_state.lock); EndInputState(&input_state); } NativeRender(); time_update(); } else { ELOG("BAD: Ended up in nativeRender even though app has quit.%s", ""); // Shouldn't really get here. Let's draw magenta. glstate.depthWrite.set(GL_TRUE); glstate.colorMask.set(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); glClearColor(1.0, 0.0, 1.0f, 1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } if (!frameCommand.empty()) { ILOG("frameCommand %s %s", frameCommand.c_str(), frameCommandParam.c_str()); jstring cmd = env->NewStringUTF(frameCommand.c_str()); jstring param = env->NewStringUTF(frameCommandParam.c_str()); env->CallVoidMethod(obj, postCommand, cmd, param); frameCommand = ""; frameCommandParam = ""; } }
void TestGetMatrix(int matrix, MatrixSize sz) { ILOG("Testing matrix %s", GetMatrixNotation(matrix, sz)); u8 fullMatrix[16]; u8 cols[4]; u8 rows[4]; GetMatrixColumns(matrix, sz, cols); GetMatrixRows(matrix, sz, rows); GetMatrixRegs(fullMatrix, sz, matrix); int n = GetMatrixSide(sz); VectorSize vsz = GetVectorSize(sz); for (int i = 0; i < n; i++) { // int colName = GetColumnName(matrix, sz, i, 0); // int rowName = GetRowName(matrix, sz, i, 0); int colName = cols[i]; int rowName = rows[i]; ILOG("Column %i: %s", i, GetVectorNotation(colName, vsz)); ILOG("Row %i: %s", i, GetVectorNotation(rowName, vsz)); u8 colRegs[4]; u8 rowRegs[4]; GetVectorRegs(colRegs, vsz, colName); GetVectorRegs(rowRegs, vsz, rowName); // Check that the individual regs are the expected ones. std::stringstream a, b, c, d; for (int j = 0; j < n; j++) { a.clear(); b.clear(); a << (int)fullMatrix[i * 4 + j] << " "; b << (int)colRegs[j] << " "; c.clear(); d.clear(); c << (int)fullMatrix[j * 4 + i] << " "; d << (int)rowRegs[j] << " "; } ILOG("Col: %s vs %s", a.str().c_str(), b.str().c_str()); if (a.str() != b.str()) ILOG("WRONG!"); ILOG("Row: %s vs %s", c.str().c_str(), d.str().c_str()); if (c.str() != d.str()) ILOG("WRONG!"); } }
bool RequestHeader::GetParamValue(const char *param_name, std::string *value) const { if (!params) return false; std::string p(params); std::vector<std::string> v; SplitString(p, '&', v); for (size_t i = 0; i < v.size(); i++) { std::vector<std::string> parts; SplitString(v[i], '=', parts); ILOG("Param: %s Value: %s", parts[0].c_str(), parts[1].c_str()); if (parts[0] == param_name) { *value = parts[1]; return true; } } return false; }
void NativeInit(int argc, const char *argv[], const char *savegame_directory, const char *external_directory, const char *installID) { host = new NativeHost; logger = new AndroidLogger(); LogManager::Init(); LogManager *logman = LogManager::GetInstance(); ILOG("Logman: %p", logman); LogTypes::LOG_LEVELS logLevel = LogTypes::LINFO; for(int i = 0; i < LogTypes::NUMBER_OF_LOGS; i++) { LogTypes::LOG_TYPE type = (LogTypes::LOG_TYPE)i; logman->SetLogLevel(type, logLevel); } }
void GLSLProgram::GLRestore() { // Quoth http://developer.android.com/reference/android/opengl/GLSurfaceView.Renderer.html; // "Note that when the EGL context is lost, all OpenGL resources associated with that context will be automatically deleted. // You do not need to call the corresponding "glDelete" methods such as glDeleteTextures to manually delete these lost resources." // Hence, we comment out: // glDeleteShader(this->vsh_); // glDeleteShader(this->fsh_); // glDeleteProgram(this->program_); this->program_ = 0; this->vsh_ = 0; this->fsh_ = 0; ILOG("Restoring GLSL program %s/%s", strlen(this->vshader_filename) > 0 ? this->vshader_filename : "(mem)", strlen(this->fshader_filename) > 0 ? this->fshader_filename : "(mem)"); glsl_recompile(this); // Note that any shader uniforms are still lost, hopefully the client sets them every frame at a minimum... }
void VulkanRenderManager::ThreadFunc() { setCurrentThreadName("RenderMan"); int threadFrame = threadInitFrame_; bool nextFrame = false; bool firstFrame = true; while (true) { { if (nextFrame) { threadFrame++; if (threadFrame >= vulkan_->GetInflightFrames()) threadFrame = 0; } FrameData &frameData = frameData_[threadFrame]; std::unique_lock<std::mutex> lock(frameData.pull_mutex); while (!frameData.readyForRun && run_) { VLOG("PULL: Waiting for frame[%d].readyForRun", threadFrame); frameData.pull_condVar.wait(lock); } if (!frameData.readyForRun && !run_) { // This means we're out of frames to render and run_ is false, so bail. break; } VLOG("PULL: frame[%d].readyForRun = false", threadFrame); frameData.readyForRun = false; // Previously we had a quick exit here that avoided calling Run() if run_ was suddenly false, // but that created a race condition where frames could end up not finished properly on resize etc. // Only increment next time if we're done. nextFrame = frameData.type == VKRRunType::END; assert(frameData.type == VKRRunType::END || frameData.type == VKRRunType::SYNC); } VLOG("PULL: Running frame %d", threadFrame); if (firstFrame) { ILOG("Running first frame (%d)", threadFrame); firstFrame = false; } Run(threadFrame); VLOG("PULL: Finished frame %d", threadFrame); } // Wait for the device to be done with everything, before tearing stuff down. vkDeviceWaitIdle(vulkan_->GetDevice()); VLOG("PULL: Quitting"); }
VulkanRenderManager::~VulkanRenderManager() { ILOG("VulkanRenderManager destructor"); StopThread(); vulkan_->WaitUntilQueueIdle(); VkDevice device = vulkan_->GetDevice(); vkDestroySemaphore(device, acquireSemaphore_, nullptr); vkDestroySemaphore(device, renderingCompleteSemaphore_, nullptr); for (int i = 0; i < vulkan_->GetInflightFrames(); i++) { VkCommandBuffer cmdBuf[2]{ frameData_[i].mainCmd, frameData_[i].initCmd }; vkFreeCommandBuffers(device, frameData_[i].cmdPoolInit, 1, &frameData_[i].initCmd); vkFreeCommandBuffers(device, frameData_[i].cmdPoolMain, 1, &frameData_[i].mainCmd); vkDestroyCommandPool(device, frameData_[i].cmdPoolInit, nullptr); vkDestroyCommandPool(device, frameData_[i].cmdPoolMain, nullptr); vkDestroyFence(device, frameData_[i].fence, nullptr); } queueRunner_.DestroyDeviceObjects(); }
uint8_t *VFSReadFile(const char *filename, size_t *size) { int fn_len = strlen(filename); for (int i = 0; i < num_entries; i++) { int prefix_len = strlen(entries[i].prefix); if (prefix_len >= fn_len) continue; if (0 == memcmp(filename, entries[i].prefix, prefix_len)) { ILOG("Prefix match: %s (%s) -> %s", entries[i].prefix, filename, filename + prefix_len); uint8_t *data = entries[i].reader->ReadAsset(filename + prefix_len, size); if (data) return data; else continue; // Else try the other registered file systems. } } ELOG("Missing filesystem for %s", filename); return 0; }
extern "C" void Java_org_ppsspp_ppsspp_NativeApp_shutdown(JNIEnv *, jclass) { if (renderer_inited && useCPUThread && graphicsContext) { // Only used in Java EGL path. EmuThreadStop("shutdown"); ILOG("BeginAndroidShutdown"); graphicsContext->BeginAndroidShutdown(); // Skipping GL calls, the old context is gone. while (graphicsContext->ThreadFrame()) { ILOG("graphicsContext->ThreadFrame executed to clear buffers"); } ILOG("Joining emuthread"); EmuThreadJoin(); ILOG("Joined emuthread"); graphicsContext->ThreadEnd(); graphicsContext->ShutdownFromRenderThread(); ILOG("Graphics context now shut down from NativeApp_shutdown"); } ILOG("NativeApp.shutdown() -- begin"); if (renderer_inited) { ILOG("Shutting down renderer"); // This will be from the wrong thread? :/ graphicsContext->Shutdown(); delete graphicsContext; graphicsContext = nullptr; renderer_inited = false; } else { ILOG("Not shutting down renderer - not initialized"); } NativeShutdown(); VFSShutdown(); while (frameCommands.size()) frameCommands.pop(); ILOG("NativeApp.shutdown() -- end"); }
void IState::deInit(void) { ILOG() << "IState::deInit(" << mStateID << ")" << std::endl; if(true == mInit) { mCleanup = true; mInit = false; mElapsedTime += mElapsedClock.getElapsedTime().asSeconds(); if(true == mPaused) { mPausedTime += mPausedClock.getElapsedTime().asSeconds(); } } }
void EmuScreen::pspKey(int pspKeyCode, int flags) { if (pspKeyCode >= VIRTKEY_FIRST) { int vk = pspKeyCode - VIRTKEY_FIRST; if (flags & KEY_DOWN) { virtKeys[vk] = true; onVKeyDown(pspKeyCode); } if (flags & KEY_UP) { virtKeys[vk] = false; onVKeyUp(pspKeyCode); } } else { ILOG("pspKey %i %i", pspKeyCode, flags); if (flags & KEY_DOWN) __CtrlButtonDown(pspKeyCode); if (flags & KEY_UP) __CtrlButtonUp(pspKeyCode); } }
bool Server::Listen6(int port, bool ipv6_only) { listener_ = socket(AF_INET6, SOCK_STREAM, 0); if (listener_ < 0) return false; struct sockaddr_in6 server_addr; memset(&server_addr, 0, sizeof(server_addr)); server_addr.sin6_family = AF_INET6; server_addr.sin6_addr = in6addr_any; server_addr.sin6_port = htons(port); int opt = 1; // Enable re-binding to avoid the pain when restarting the server quickly. setsockopt(listener_, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)); // Enable listening on IPv6 and IPv4? opt = ipv6_only ? 1 : 0; setsockopt(listener_, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&opt, sizeof(opt)); if (bind(listener_, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { closesocket(listener_); ELOG("Failed to bind to port %i. Bailing.", port); return false; } fd_util::SetNonBlocking(listener_, true); // 1024 is the max number of queued requests. if (listen(listener_, 1024) < 0) { closesocket(listener_); return false; } socklen_t len = sizeof(server_addr); if (getsockname(listener_, (struct sockaddr *)&server_addr, &len) == 0) { port = ntohs(server_addr.sin6_port); } ILOG("HTTP server started on port %i", port); port_ = port; return true; }
PrototypeManager::~PrototypeManager() { ILOG() << "PrototypeManager::dtor()" << std::endl; // Make sure we delete all registered Prototype classes std::map<const typePrototypeID, Prototype*>::iterator anPrototypeIter; // Start at the beginning of the list of ISystem classes anPrototypeIter = mPrototypes.begin(); while(anPrototypeIter != mPrototypes.end()) { Prototype* anPrototype = anPrototypeIter->second; // Remove the Prototype from our list mPrototypes.erase(anPrototypeIter++); // Now delete the Prototype delete anPrototype; } }
void closeProxyConnection(struct proxyConnection *cp) { if(!(cp->error || cp->done) && !(cp->secure_eof && cp->plain_eof)) return; DLOG("Closing connection"); int secure_fd=cp->secure->fd; int status=0; if(cp->secure_up && !cp->error) { sslWriteClosureAlert(cp->secure); } status=close(cp->secure->fd); socketShutdown(cp->secure->fd); sslFreeConnection(&cp->secure); status=close(cp->plain); socketShutdown(cp->plain); memset(cp,0,sizeof(struct proxyConnection)); ILOG("Connection closed"); }
void IState::init(void) { ILOG() << "IState::DoInit(" << mStateID << ")" << std::endl; // If Cleanup hasn't been called yet, call it now! if(true == mCleanup) { handleCleanup(); } // Initialize if necessary if(false == mInit) { mInit = true; mPaused = false; mElapsedTime = 0.0f; mElapsedClock.restart(); mPausedTime = 0.0f; mPausedClock.restart(); } }
extern "C" void Java_org_ppsspp_ppsspp_NativeApp_audioInit(JNIEnv *, jclass) { sampleRate = optimalSampleRate; if (NativeQueryConfig("force44khz") != "0" || optimalSampleRate == 0) { sampleRate = 44100; } if (optimalFramesPerBuffer > 0) { framesPerBuffer = optimalFramesPerBuffer; } else { framesPerBuffer = 512; } // Some devices have totally bonkers buffer sizes like 8192. They will have terrible latency anyway, so to avoid having to // create extra smart buffering code, we'll just let their regular mixer deal with it, missing the fast path (as if they had one...) if (framesPerBuffer > 512) { framesPerBuffer = 512; sampleRate = 44100; } ILOG("NativeApp.audioInit() -- Using OpenSL audio! frames/buffer: %i optimal sr: %i actual sr: %i", optimalFramesPerBuffer, optimalSampleRate, sampleRate); AndroidAudio_Init(&NativeMix, library_path, framesPerBuffer, sampleRate); }
void NativeShutdown() { screenManager->shutdown(); delete screenManager; screenManager = 0; g_gameInfoCache.Shutdown(); delete host; host = 0; g_Config.Save(); #ifndef _WIN32 LogManager::Shutdown(); #endif // This means that the activity has been completely destroyed. PPSSPP does not // boot up correctly with "dirty" global variables currently, so we hack around that // by simply exiting. #ifdef ANDROID ILOG("NativeShutdown called"); exit(0); #endif }
/** * Check if the new version of the app is available * @param silent If this is set to false, no error messages will be displayed to the user */ void MiniLaunchBar::CheckForNewVersion(bool silent) { ILOG(_T("Looking for an update...")); UpdaterVersionInfo versionInfo; bool success = Updater::CheckVersion(CHECK_VERSION_URL, versionInfo); if (!success) { ELOG(_T("Could not get update information")); if (!silent) MessageBoxes::ShowError(_("Could not get update information")); return; } wxString thisVersion = VersionInfo::GetVersionString(); ILOG(wxString::Format(_T("This version: %s"), thisVersion)); ILOG(wxString::Format(_T("Current version: %s"), versionInfo.Version)); ILOG(wxString::Format(_T("Page URL: %s"), versionInfo.PageURL)); ILOG(wxString::Format(_T("Download URL: %s"), versionInfo.DownloadURL)); ILOG(wxString::Format(_T("Release notes: %s"), versionInfo.ReleaseNotes)); if (Updater::CompareVersions(thisVersion, versionInfo.Version) >= 0) { ILOG(_T("=> No new version")); if (!silent) MessageBoxes::ShowInformation(_("You have the latest version.")); return; } else { ILOG(_T("=> A new version is available")); } wxString message; message = wxString::Format(_("A new version of Appetizer is available!\n\nYour version: %s\nNew version: %s\nRelease notes: %s\nDo you wish to download it now?"), thisVersion, versionInfo.Version, versionInfo.ReleaseNotes); int result = MessageBoxes::ShowConfirmation(message, 2|8, wxEmptyString, false, _("New version of Appetizer")); if (result == wxID_YES) { bool wasLaunched = ::wxLaunchDefaultBrowser(versionInfo.PageURL, wxBROWSER_NEW_WINDOW); if (!wasLaunched) MessageBoxes::ShowError(_("Error launching web browser")); } }
stlink_t* stlink_v1_open_inner(const int verbose) { ugly_init(verbose); stlink_t *sl = stlink_open(verbose); if (sl == NULL) { fputs("Error: could not open stlink device\n", stderr); return NULL; } stlink_version(sl); if ((sl->version.st_vid != USB_ST_VID) || (sl->version.stlink_pid != USB_STLINK_PID)) { ugly_log(UERROR, LOG_TAG, "WTF? successfully opened, but unable to read version details. BROKEN!\n"); return NULL; } DLOG("Reading current mode...\n"); switch (stlink_current_mode(sl)) { case STLINK_DEV_MASS_MODE: return sl; case STLINK_DEV_DEBUG_MODE: // TODO go to mass? return sl; default: ILOG("Current mode unusable, trying to get back to a useful state...\n"); break; } DLOG("Attempting to exit DFU mode\n"); _stlink_sg_exit_dfu_mode(sl); // re-query device info (and retest) stlink_version(sl); if ((sl->version.st_vid != USB_ST_VID) || (sl->version.stlink_pid != USB_STLINK_PID)) { ugly_log(UERROR, LOG_TAG, "WTF? successfully opened, but unable to read version details. BROKEN!\n"); return NULL; } return sl; }
VkResult VulkanContext::CreateDevice() { if (!init_error_.empty() || physical_device_ < 0) { ELOG("Vulkan init failed: %s", init_error_.c_str()); return VK_ERROR_INITIALIZATION_FAILED; } VkDeviceQueueCreateInfo queue_info = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }; float queue_priorities[1] = { 1.0f }; queue_info.queueCount = 1; queue_info.pQueuePriorities = queue_priorities; bool found = false; for (int i = 0; i < (int)queue_count; i++) { if (queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) { queue_info.queueFamilyIndex = i; found = true; break; } } assert(found); deviceExtensionsLookup_.DEDICATED_ALLOCATION = EnableDeviceExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME); VkDeviceCreateInfo device_info { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; device_info.queueCreateInfoCount = 1; device_info.pQueueCreateInfos = &queue_info; device_info.enabledLayerCount = (uint32_t)device_layer_names_.size(); device_info.ppEnabledLayerNames = device_info.enabledLayerCount ? device_layer_names_.data() : nullptr; device_info.enabledExtensionCount = (uint32_t)device_extensions_enabled_.size(); device_info.ppEnabledExtensionNames = device_info.enabledExtensionCount ? device_extensions_enabled_.data() : nullptr; device_info.pEnabledFeatures = &featuresEnabled_; VkResult res = vkCreateDevice(physical_devices_[physical_device_], &device_info, nullptr, &device_); if (res != VK_SUCCESS) { init_error_ = "Unable to create Vulkan device"; ELOG("Unable to create Vulkan device"); } else { VulkanLoadDeviceFunctions(device_); } ILOG("Device created.\n"); return res; }
void StateManager::addActiveState(IState* theState) { // Check that they didn't provide a bad pointer assert(NULL != theState && "StateManager::addActiveState() received a bad pointer"); // Log the adding of each state ILOG() << "StateManager::addActiveState(" << theState->getID() << ")" << std::endl; // Is there a state currently running? then Pause it if(!mStack.empty()) { // Pause the currently running state since we are changing the // currently active state to the one provided mStack.back()->pause(); } // Add the active state mStack.push_back(theState); // Initialize the new active state mStack.back()->doInit(); }
void ProcessGPUFeatures() { gl_extensions.bugs = 0; ILOG("Checking for GL driver bugs... vendor=%i model='%s'", (int)gl_extensions.gpuVendor, gl_extensions.model); // Should be table driven instead, this is a quick hack for Galaxy Y if (System_GetProperty(SYSPROP_NAME) == "samsung:GT-S5360") { gl_extensions.bugs |= BUG_FBO_UNUSABLE; } if (gl_extensions.gpuVendor == GPU_VENDOR_POWERVR) { if (!strcmp(gl_extensions.model, "PowerVR SGX 543") || !strcmp(gl_extensions.model, "PowerVR SGX 540") || !strcmp(gl_extensions.model, "PowerVR SGX 530") || !strcmp(gl_extensions.model, "PowerVR SGX 520") ) { WLOG("GL DRIVER BUG: PVR with bad and terrible precision"); gl_extensions.bugs |= BUG_PVR_SHADER_PRECISION_TERRIBLE | BUG_PVR_SHADER_PRECISION_BAD; } else { WLOG("GL DRIVER BUG: PVR with bad precision"); gl_extensions.bugs |= BUG_PVR_SHADER_PRECISION_BAD; } gl_extensions.bugs |= BUG_PVR_GENMIPMAP_HEIGHT_GREATER; } }
CEntity::CEntity(){ ILOG() << "IEntity::ctor()" << std::endl; pos.x=0;pos.y=0; speed.x=0;speed.y=0; accel.x=0;accel.y=0; moveLeft = false; moveRight = false; canJump = false; type = ENTITY_TYPE_GENERIC; dead = false; flags = ENTITY_FLAG_GRAVITY; maxSpeed.x = 500; maxSpeed.y = 500; CurrentFrameCol = 0; CurrentFrameRow = 0; }
bool AndroidEGLGraphicsContext::Init(ANativeWindow *wnd, int backbufferWidth, int backbufferHeight, int backbufferFormat, int androidVersion) { wnd_ = wnd; gl = HostGL_CreateGLInterface(); if (!gl) { ELOG("ERROR: Failed to create GL interface"); return false; } ILOG("EGL interface created. Desired backbuffer size: %dx%d", backbufferWidth, backbufferHeight); // Apparently we still have to set this through Java through setFixedSize on the bufferHolder for it to take effect... gl->SetBackBufferDimensions(backbufferWidth, backbufferHeight); gl->SetMode(MODE_DETECT_ES); bool use565 = false; // This workaround seems only be needed on some really old devices. if (androidVersion < ANDROID_VERSION_ICS) { switch (backbufferFormat) { case 4: // PixelFormat.RGB_565 use565 = true; break; default: break; } } if (!gl->Create(wnd, false, use565)) { ELOG("EGL creation failed! (use565=%d)", (int)use565); // TODO: What do we do now? delete gl; return false; } gl->MakeCurrent(); CheckGLExtensions(); draw_ = Draw::T3DCreateGLContext(); return true; }
void WidgetRdpView::slotTimerResizeHappendFired() { if (inErrorMode_) return; if (!connectionEstablished_) { // We have to increase the count of attempts to try to establish a new connection retryCount_++; if (retryCount_ > 5) { IERR("WidgetRdpView: aborting because of the detection of an rdp reconnection loop, user has to reopen this VmMask"); // replace the RDP-Widget with an Label showing an error loGrid_->removeWidget(freeRDPwidget_); delete (freeRDPwidget_); freeRDPwidget_ = 0; lblErrorMessage_->setText("connection to VM-Mask lost, please close this tab and try again"); loGrid_->addWidget(lblErrorMessage_, 0, 0, 1, 1, Qt::AlignHCenter); inErrorMode_ = true; } else { ILOG("WidgetRdpView: timer is ready - connectViaRdp()"); resizeVmDesktopAndConnectViaRdp(); } } else { if (!onDisconnecting_) { disconnectRdpConnection(); // in the disconnect event we will fire the timer timerResizeHappend_ } } }
extern "C" void JNICALL Java_org_ppsspp_ppsspp_NativeApp_backbufferResize(JNIEnv *, jclass, jint bufw, jint bufh, jint format) { ILOG("NativeApp.backbufferResize(%d x %d)", bufw, bufh); bool new_size = pixel_xres != bufw || pixel_yres != bufh; int old_w = pixel_xres; int old_h = pixel_yres; // pixel_*res is the backbuffer resolution. pixel_xres = bufw; pixel_yres = bufh; backbuffer_format = format; g_dpi = display_dpi_x; g_dpi_scale_x = 240.0f / g_dpi; g_dpi_scale_y = 240.0f / g_dpi; g_dpi_scale_real_x = g_dpi_scale_x; g_dpi_scale_real_y = g_dpi_scale_y; dp_xres = display_xres * g_dpi_scale_x; dp_yres = display_yres * g_dpi_scale_y; // Touch scaling is from display pixels to dp pixels. dp_xscale = (float)dp_xres / (float)display_xres; dp_yscale = (float)dp_yres / (float)display_yres; pixel_in_dps_x = (float)pixel_xres / dp_xres; pixel_in_dps_y = (float)pixel_yres / dp_yres; ILOG("g_dpi=%f g_dpi_scale_x=%f g_dpi_scale_y=%f", g_dpi, g_dpi_scale_x, g_dpi_scale_y); ILOG("dp_xscale=%f dp_yscale=%f", dp_xscale, dp_yscale); ILOG("dp_xres=%d dp_yres=%d", dp_xres, dp_yres); ILOG("pixel_xres=%d pixel_yres=%d", pixel_xres, pixel_yres); if (new_size) { ILOG("Size change detected (previously %d,%d) - calling NativeResized()", old_w, old_h); NativeResized(); } else { ILOG("Size didn't change."); } }
int azPrint(lua_State *L) { int argc = lua_gettop(L); wxString output; for (int n = 1; n <= argc; ++n) { if (lua_isboolean(L, n)) { output += lua_toboolean(L, n) ? _T("true") : _T("false"); continue; } const char* c = lua_tostring(L, n); if (!c) { output += _T("<null>"); continue; } output += wxString::FromUTF8(c); } ILOG(_T("%s %s"), _T("[Lua Script]"), output); return 0; }
// JavaEGL extern "C" void Java_org_ppsspp_ppsspp_NativeRenderer_displayInit(JNIEnv * env, jobject obj) { // We should be running on the render thread here. std::string errorMessage; if (renderer_inited) { // Would be really nice if we could get something on the GL thread immediately when shutting down. ILOG("NativeApp.displayInit() restoring"); if (useCPUThread) { EmuThreadStop("displayInit"); graphicsContext->BeginAndroidShutdown(); ILOG("BeginAndroidShutdown. Looping until emu thread done..."); // Skipping GL calls here because the old context is lost. while (graphicsContext->ThreadFrame()) { continue; } ILOG("Joining emu thread"); EmuThreadJoin(); } else { NativeShutdownGraphics(); } graphicsContext->ThreadEnd(); graphicsContext->ShutdownFromRenderThread(); ILOG("Shut down both threads. Now let's bring it up again!"); graphicsContext->InitFromRenderThread(nullptr, 0, 0, 0, 0); if (useCPUThread) { EmuThreadStart(); } else { NativeInitGraphics(graphicsContext); } graphicsContext->ThreadStart(); ILOG("Restored."); } else { ILOG("NativeApp.displayInit() first time"); graphicsContext->InitFromRenderThread(nullptr, 0, 0, 0, 0); graphicsContext->ThreadStart(); renderer_inited = true; } NativeMessageReceived("recreateviews", ""); }
static void EmuThreadFunc() { JNIEnv *env; gJvm->AttachCurrentThread(&env, nullptr); setCurrentThreadName("Emu"); ILOG("Entering emu thread"); // Wait for render loop to get started. if (!graphicsContext || !graphicsContext->Initialized()) { ILOG("Runloop: Waiting for displayInit..."); while (!graphicsContext || !graphicsContext->Initialized()) { sleep_ms(20); } } else { ILOG("Runloop: Graphics context available! %p", graphicsContext); } NativeInitGraphics(graphicsContext); ILOG("Graphics initialized. Entering loop."); // There's no real requirement that NativeInit happen on this thread. // We just call the update/render loop here. emuThreadState = (int)EmuThreadState::RUNNING; while (emuThreadState != (int)EmuThreadState::QUIT_REQUESTED) { UpdateRunLoopAndroid(env); } ILOG("QUIT_REQUESTED found, left loop. Setting state to STOPPED."); emuThreadState = (int)EmuThreadState::STOPPED; NativeShutdownGraphics(); // Also ask the main thread to stop, so it doesn't hang waiting for a new frame. graphicsContext->StopThread(); gJvm->DetachCurrentThread(); ILOG("Leaving emu thread"); }