bool nsPartialFileInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; // Grab our members first. PRUint64 start; PRUint64 length; if (!ReadParam(aMsg, aIter, &start) || !ReadParam(aMsg, aIter, &length)) return false; // Then run base class deserialization. if (!nsFileInputStream::Read(aMsg, aIter)) return false; // Set members. mStart = start; mLength = length; // XXX This isn't really correct, we should probably set this to whatever // the sender had. However, it doesn't look like nsFileInputStream deals // with sending a partially-consumed stream either, so... mPosition = 0; // Mirror nsPartialFileInputStream::Init here. We can't call it directly // because nsFileInputStream::Read() already calls the base class Init // method. return NS_SUCCEEDED(nsFileInputStream::Seek(NS_SEEK_SET, start)); }
bool nsMultiplexInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; PRUint32 count; if (!ReadParam(aMsg, aIter, &count)) return PR_FALSE; for (PRUint32 i = 0; i < count; i++) { IPC::InputStream inputStream; if (!ReadParam(aMsg, aIter, &inputStream)) return PR_FALSE; nsCOMPtr<nsIInputStream> stream(inputStream); nsresult rv = AppendStream(stream); if (NS_FAILED(rv)) return PR_FALSE; } if (!ReadParam(aMsg, aIter, &mCurrentStream) || !ReadParam(aMsg, aIter, &mStartedReadingCurrent) || !ReadParam(aMsg, aIter, &mStatus)) return PR_FALSE; return PR_TRUE; }
bool nsFileInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; nsCString path; bool followLinks; PRInt32 flags; if (!ReadParam(aMsg, aIter, &path) || !ReadParam(aMsg, aIter, &followLinks) || !ReadParam(aMsg, aIter, &flags)) return false; nsCOMPtr<nsIFile> file; nsresult rv = NS_NewNativeLocalFile(path, followLinks, getter_AddRefs(file)); if (NS_FAILED(rv)) return false; // IO flags = -1 means readonly, and // permissions are unimportant since we're reading rv = Init(file, -1, -1, flags); if (NS_FAILED(rv)) return false; return true; }
PRBool nsMIMEInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; if (!ReadParam(aMsg, aIter, &mHeaders) || !ReadParam(aMsg, aIter, &mContentLength) || !ReadParam(aMsg, aIter, &mStartedReading)) return PR_FALSE; // nsMIMEInputStream::Init() already appended mHeaderStream & mCLStream mHeaderStream->ShareData(mHeaders.get(), mStartedReading? mHeaders.Length() : 0); mCLStream->ShareData(mContentLength.get(), mStartedReading? mContentLength.Length() : 0); IPC::InputStream inputStream; if (!ReadParam(aMsg, aIter, &inputStream)) return PR_FALSE; nsCOMPtr<nsIInputStream> stream(inputStream); mData = stream; if (stream) { nsresult rv = mStream->AppendStream(mData); if (NS_FAILED(rv)) return PR_FALSE; } if (!ReadParam(aMsg, aIter, &mAddContentLength)) return PR_FALSE; return PR_TRUE; }
extern "C" __declspec(dllexport) bool ProcessStr(BSTR in_str, BSTR *out_str) { IPC ipc; if (!ipc.isInit()) return false; if (!ipc.process(in_str, out_str)) return false; return true; }
void nsBufferedInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; WriteParam(aMsg, mBufferSize); IPC::InputStream inputStream(Source()); WriteParam(aMsg, inputStream); }
bool EditorMode::PlayProject(String addArgs, bool debug) { ToolEnvironment* env = GetSubsystem<ToolEnvironment>(); ToolSystem* tsystem = GetSubsystem<ToolSystem>(); const String& editorBinary = env->GetEditorBinary(); Project* project = tsystem->GetProject(); if (!project) return false; Vector<String> paths; paths.Push(env->GetCoreDataDir()); paths.Push(env->GetPlayerDataDir()); paths.Push(project->GetResourcePath()); // fixme: this is for loading from cache paths.Push(project->GetProjectPath()); paths.Push(project->GetProjectPath() + "Cache"); String resourcePaths; resourcePaths.Join(paths, "!"); Vector<String> vargs; String args = ToString("--player --project \"%s\"", AddTrailingSlash(project->GetProjectPath()).CString()); vargs = args.Split(' '); if (debug) vargs.Insert(0, "--debug"); if (addArgs.Length() > 0) vargs.Insert(0, addArgs.Split(' ')); String dump; dump.Join(vargs, " "); LOGINFOF("Launching Broker %s %s", editorBinary.CString(), dump.CString()); IPC* ipc = GetSubsystem<IPC>(); playerBroker_ = ipc->SpawnWorker(editorBinary, vargs); if (playerBroker_) { SubscribeToEvent(playerBroker_, E_IPCJSERROR, HANDLER(EditorMode, HandleIPCJSError)); SubscribeToEvent(playerBroker_, E_IPCWORKEREXIT, HANDLER(EditorMode, HandleIPCWorkerExit)); SubscribeToEvent(playerBroker_, E_IPCWORKERLOG, HANDLER(EditorMode, HandleIPCWorkerLog)); } return playerBroker_.NotNull(); }
void nsFileInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; nsCString path; mFile->GetNativePath(path); WriteParam(aMsg, path); bool followLinks; mFile->GetFollowLinks(&followLinks); WriteParam(aMsg, followLinks); WriteParam(aMsg, mBehaviorFlags); }
void nsMIMEInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; WriteParam(aMsg, mHeaders); WriteParam(aMsg, mContentLength); WriteParam(aMsg, mStartedReading); IPC::InputStream inputStream(mData); WriteParam(aMsg, inputStream); WriteParam(aMsg, mAddContentLength); }
void ipc_thread_function() { while (true) { ipc.update(); Sleep(100); } }
void nsMultiplexInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; PRUint32 count = mStreams.Count(); WriteParam(aMsg, count); for (PRUint32 i = 0; i < count; i++) { IPC::InputStream inputStream(mStreams.ObjectAt(i)); WriteParam(aMsg, inputStream); } WriteParam(aMsg, mCurrentStream); WriteParam(aMsg, mStartedReadingCurrent); WriteParam(aMsg, mStatus); }
bool nsBufferedInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; PRUint32 bufferSize; IPC::InputStream inputStream; if (!ReadParam(aMsg, aIter, &bufferSize) || !ReadParam(aMsg, aIter, &inputStream)) return false; nsCOMPtr<nsIInputStream> stream(inputStream); nsresult rv = Init(stream, bufferSize); if (NS_FAILED(rv)) return false; return true; }
void nsPartialFileInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; // Write our members first. WriteParam(aMsg, mStart); WriteParam(aMsg, mLength); // XXX This isn't really correct, we should probably send this too. However, // it doesn't look like nsFileInputStream deals with sending a // partially-consumed stream either, so... if (mPosition) { NS_WARNING("No support for sending a partially-consumed input stream!"); } // Now run base class serialization. nsFileInputStream::Write(aMsg); }
void nsStringInputStream::Write(IPC::Message *aMsg) { using IPC::WriteParam; nsCAutoString value; GetData(value); WriteParam(aMsg, value); }
void nsStringInputStream::Write(IPC::Message *aMsg) { #ifdef MOZ_IPC using IPC::WriteParam; nsCAutoString value; GetData(value); WriteParam(aMsg, value); #endif }
PRBool nsBufferedInputStream::Read(const IPC::Message *aMsg, void **aIter) { #ifdef MOZ_IPC using IPC::ReadParam; PRUint32 bufferSize; IPC::InputStream inputStream; if (!ReadParam(aMsg, aIter, &bufferSize) || !ReadParam(aMsg, aIter, &inputStream)) return PR_FALSE; nsCOMPtr<nsIInputStream> stream(inputStream); nsresult rv = Init(stream, bufferSize); if (NS_FAILED(rv)) return PR_FALSE; return PR_TRUE; #else return PR_FALSE; #endif }
bool nsStringInputStream::Read(const IPC::Message *aMsg, void **aIter) { using IPC::ReadParam; nsCAutoString value; if (!ReadParam(aMsg, aIter, &value)) return PR_FALSE; nsresult rv = SetData(value.get(), value.Length()); if (NS_FAILED(rv)) return PR_FALSE; return PR_TRUE; }
void Reprojector::load(IPC& ipc, bool flipped) { bool serial_first_non_zero = false; string serial = ""; for (int i = 4; i < 10; ++i) { string str_temp = ""; str_temp += serial_number[i]; if (!serial_first_non_zero && str_temp != "0") serial_first_non_zero = true; if (serial_first_non_zero) serial += serial_number[i]; } bool has_complete_calib_data = false; if (directory_exists(data_path_current_module)) if (file_exists(data_path_current_module + "\\0.jpg")) if (file_exists(data_path_current_module + "\\1.jpg")) if (file_exists(data_path_current_module + "\\stereoCalibData.txt")) if (file_exists(data_path_current_module + "\\rect0.txt")) if (file_exists(data_path_current_module + "\\rect1.txt")) has_complete_calib_data = true; if (!has_complete_calib_data) { static bool block_thread = true; ipc.send_message("menu_plus", "show window", ""); ipc.get_response("menu_plus", "show download", "", [](const string message_body) { COUT << "unblock" << endl; block_thread = false; }); while (block_thread) { ipc.update(); Sleep(100); } create_directory(data_path); create_directory(data_path_current_module); copy_file(executable_path + "\\rectifier.exe", data_path_current_module + "\\rectifier.exe"); copy_file(executable_path + "\\opencv_core249.dll", data_path_current_module + "\\opencv_core249.dll"); copy_file(executable_path + "\\opencv_highgui249.dll", data_path_current_module + "\\opencv_highgui249.dll"); copy_file(executable_path + "\\opencv_imgproc249.dll", data_path_current_module + "\\opencv_imgproc249.dll"); copy_file(executable_path + "\\opencv_calib3d249.dll", data_path_current_module + "\\opencv_calib3d249.dll"); copy_file(executable_path + "\\opencv_flann249.dll", data_path_current_module + "\\opencv_flann249.dll"); copy_file(executable_path + "\\opencv_features2d249.dll", data_path_current_module + "\\opencv_features2d249.dll"); //http://s3-us-west-2.amazonaws.com/ractiv.com/data/ //http://d2i9bzz66ghms6.cloudfront.net/data/ string param0 = "http://s3-us-west-2.amazonaws.com/ractiv.com/data/" + serial + "/0.jpg"; string param1 = data_path_current_module + "\\0.jpg"; string* serial_ptr = &serial; IPC* ipc_ptr = &ipc; ipc.get_response("menu_plus", "download", param0 + "`" + param1, [serial_ptr, ipc_ptr](const string message_body) { if (message_body == "false") ipc_ptr->send_message("daemon_plus", "exit", ""); else { string param0 = "http://s3-us-west-2.amazonaws.com/ractiv.com/data/" + *serial_ptr + "/1.jpg"; string param1 = data_path_current_module + "\\1.jpg"; ipc_ptr->get_response("menu_plus", "download", param0 + "`" + param1, [serial_ptr, ipc_ptr](const string message_body) { if (message_body == "false") ipc_ptr->send_message("daemon_plus", "exit", ""); else { string param0 = "http://s3-us-west-2.amazonaws.com/ractiv.com/data/" + *serial_ptr + "/stereoCalibData.txt"; string param1 = data_path_current_module + "\\stereoCalibData.txt"; ipc_ptr->get_response("menu_plus", "download", param0 + "`" + param1, [serial_ptr, ipc_ptr](const string message_body) { if (message_body == "false") ipc_ptr->send_message("daemon_plus", "exit", ""); else { bool has_complete_calib_data = false; while (!has_complete_calib_data) { system(("cd " + cmd_quote + data_path_current_module + cmd_quote + " && rectifier.exe").c_str()); if (directory_exists(data_path_current_module)) if (file_exists(data_path_current_module + "\\0.jpg")) if (file_exists(data_path_current_module + "\\1.jpg")) if (file_exists(data_path_current_module + "\\stereoCalibData.txt")) if (file_exists(data_path_current_module + "\\rect0.txt")) if (file_exists(data_path_current_module + "\\rect1.txt")) has_complete_calib_data = true; } block_thread = false; } }); } }); } }); block_thread = true; while (block_thread) { ipc.update(); Sleep(100); } } ifstream file_stereo_calib_data(data_path_current_module + "\\stereoCalibData.txt"); bool is_number_new = false; bool is_number_old = false; int block_count = 0; int block[4]; vector<Point> disparity_data; string str_num_temp = ""; string disparities_string = ""; while (getline(file_stereo_calib_data, disparities_string)) { const int i_max = disparities_string.length(); for (int i = 0; i < i_max; ++i) { string str_temp = ""; str_temp += disparities_string[i]; if (str_temp != "," && str_temp != ";") is_number_new = true; else is_number_new = false; if (is_number_new) { if (!is_number_old) str_num_temp = str_temp; else str_num_temp += str_temp; } else if (is_number_old) { block[block_count] = stoi(str_num_temp); ++block_count; } if (block_count == 3) { bool found = false; for (int a = 0; a < disparity_data.size(); ++a) { if (disparity_data[a].x == block[0]) { found = true; disparity_data[a].y = (disparity_data[a].y + abs(block[1] - block[2])) / 2; } else if (disparity_data[a].y == abs(block[1] - block[2])) { found = true; disparity_data[a].x = min(disparity_data[a].x, block[0]); } } if (!found) disparity_data.push_back(Point(block[0], abs(block[1] - block[2]))); block_count = 0; } is_number_old = is_number_new; } } sort(disparity_data.begin(), disparity_data.end(), compare_point_x()); double *t, *y; t = new double[disparity_data.size()]; y = new double[disparity_data.size()]; for (unsigned int a = 0; a < disparity_data.size(); a++) { t[a] = (double)(disparity_data[a].y); y[a] = (double)(disparity_data[a].x); } CCurveFitting cf; cf.curve_fitting4(t, disparity_data.size(), y, &a_out, &b_out, &c_out, &d_out); delete []t; delete []y; ifstream file0(data_path_current_module + "\\rect0.txt"); is_number_new = false; is_number_old = false; block_count = 0; rect_mat0 = new Point*[WIDTH_LARGE]; for (int i = 0; i < WIDTH_LARGE; ++i) rect_mat0[i] = new Point[HEIGHT_LARGE]; string rect0_string = ""; while (getline(file0, rect0_string)) { const int i_max = rect0_string.length(); for (int i = 0; i < i_max; ++i) { string str_temp = ""; str_temp += rect0_string[i]; if (str_temp != " " && str_temp != "," && str_temp != ";") is_number_new = true; else is_number_new = false; if (is_number_new) { if (!is_number_old) str_num_temp = str_temp; else str_num_temp += str_temp; } else if (is_number_old) { block[block_count] = stoi(str_num_temp); ++block_count; } if (block_count == 4) { if (!flipped) rect_mat0[block[0]][block[1]] = Point(block[2], block[3]); else rect_mat0[block[0]][HEIGHT_LARGE_MINUS - block[1]] = Point(block[2], block[3]); block_count = 0; } is_number_old = is_number_new; } } ifstream file1(data_path_current_module + "\\rect1.txt"); is_number_new = false; is_number_old = false; block_count = 0; rect_mat1 = new Point*[WIDTH_LARGE]; for (int i = 0; i < WIDTH_LARGE; ++i) rect_mat1[i] = new Point[HEIGHT_LARGE]; string rect1_string = ""; while (getline(file1, rect1_string)) { const int i_max = rect1_string.length(); for (int i = 0; i < i_max; ++i) { string str_temp = ""; str_temp += rect1_string[i]; if (str_temp != " " && str_temp != "," && str_temp != ";") is_number_new = true; else is_number_new = false; if (is_number_new) { if (!is_number_old) str_num_temp = str_temp; else str_num_temp += str_temp; } else if (is_number_old) { block[block_count] = stoi(str_num_temp); ++block_count; } if (block_count == 4) { if (!flipped) rect_mat1[block[0]][block[1]] = Point(block[2], block[3]); else rect_mat1[block[0]][HEIGHT_LARGE_MINUS - block[1]] = Point(block[2], block[3]); block_count = 0; } is_number_old = is_number_new; } } }
int main(int argc, char* argv[]) { // Initialize shared memory if (ipc.init(false)) exit(1); // Initialize nominal beaconContainer parseWaypoints(); // Create camera semaphore/ mutex sem_init(&semCam, 0, 0); if (pthread_mutex_init(&mutexImageData, NULL) != 0) { printf("\n Camera mutex init failed\n"); exit(1); } // Start camera thread pthread_t tid; int err = pthread_create(&tid, NULL, &camThread, NULL); if (err != 0) { printf("\nCan't create camera thread :[%s]", strerror(err)); exit(1); } lastPhotogramMicros = getMicroSec(); // Main loop for(;;photogram++) { TRACE(DEBUG, "\nPHOTOGRAM %d, milliseconds: %ld\n", photogram, getMillisSinceStart()); // Update time variables photogramMicros = getMicroSec(); lastPhotogramSpentTime = getSpent(photogramMicros - lastPhotogramMicros); microsSinceStart += lastPhotogramSpentTime; lastPhotogramMicros = photogramMicros; // Get drone roll, pitch and yaw attitudeT attitude, delayedAttitude; ipc.getAttitude(attitude); attitudeSignal.push(attitude, lastPhotogramSpentTime); delayedAttitude = attitudeSignal.getSignal(); droneRoll = delayedAttitude.roll * 0.01; dronePitch = delayedAttitude.pitch * 0.01; droneYaw = delayedAttitude.yaw * 0.01; // Update estimated servo values rollStatusServo.update(lastPhotogramSpentTime); pitchStatusServo.update(lastPhotogramSpentTime); if (rollStatusServo.inBigStep() || pitchStatusServo.inBigStep()) { sem_wait(&semCam); continue; } // Update estimated camera roll and pitch roll = droneRoll + rollStatusServo.getEstimatedAngle(); pitch = dronePitch + pitchStatusServo.getEstimatedAngle(); // Switch beacon containers to preserve one history record if (beaconContainer == &beaconContainerA) { beaconContainer = &beaconContainerB; oldBeaconContainer = &beaconContainerA; } else { beaconContainer = &beaconContainerA; oldBeaconContainer = &beaconContainerB; } beaconContainer->clean(); // Wait until new frame is received sem_wait(&semCam); // Where the magic happens findBeacons(); groupBeacons(); findWaypoints(); computePosition(); } StopCamera(); printf("Finished.\n"); return 0; }
int main() #endif { // freopen("C:\\touch_plus_software_log.txt", "w", stdout); console_log_ipc = &ipc; #ifdef _WIN32 char buffer[MAX_PATH]; GetModuleFileName(NULL, buffer, MAX_PATH); string::size_type pos = string(buffer).find_last_of("\\/"); executable_path = string(buffer).substr(0, pos); #elif __APPLE__ char path_buffer[1024]; uint32_t path_size = sizeof(path_buffer); _NSGetExecutablePath(path_buffer, &path_size); string path_str(path_buffer); executable_path = path_str.substr(0, path_str.find_last_of("/")); #endif data_path = executable_path + slash + "userdata"; settings_file_path = data_path + slash + "settings.nrocinunerrad"; ipc_path = executable_path + slash + "ipc"; if (!directory_exists(ipc_path)) create_directory(ipc_path); else delete_all_files(ipc_path); if (file_exists(executable_path + "/lock")) delete_file(executable_path + "/lock"); Settings settings; if (!file_exists(settings_file_path)) { settings.launch_on_startup = "1"; settings.power_saving_mode = "0"; settings.check_for_updates = "1"; settings.touch_control = "1"; settings.table_mode = "0"; settings.detect_interaction_plane = "0"; settings.click_height = "5"; if (!directory_exists(data_path)) create_directory(data_path); ofstream settings_ofs(settings_file_path, ios::binary); settings_ofs.write((char*)&settings, sizeof(settings)); console_log("settings file created"); } else { ifstream ifs(settings_file_path, ios::binary); ifs.read((char*)&settings, sizeof(settings)); console_log("settings file loaded"); } IPC* ipc_ptr = &ipc; Settings* settings_ptr = &settings; ipc.map_function("get toggles", [ipc_ptr, settings_ptr](const string message_body) { string response = ""; response += settings_ptr->launch_on_startup + settings_ptr->power_saving_mode + settings_ptr->check_for_updates + settings_ptr->touch_control + settings_ptr->table_mode + settings_ptr->detect_interaction_plane + settings_ptr->click_height; ipc_ptr->send_message("menu_plus", "get toggles", response); }); ipc.map_function("set toggle", [ipc_ptr, settings_ptr](const string message_body) { const string toggle_name = message_body.substr(0, message_body.size() - 1); const string toggle_value = message_body.substr(message_body.size() - 1, message_body.size()); if (toggle_name == "launch_on_startup") settings_ptr->launch_on_startup = toggle_value; else if (toggle_name == "power_saving_mode") settings_ptr->power_saving_mode = toggle_value; else if (toggle_name == "check_for_updates") settings_ptr->check_for_updates = toggle_value; else if (toggle_name == "touch_control") settings_ptr->touch_control = toggle_value; else if (toggle_name == "table_mode") settings_ptr->table_mode = toggle_value; else if (toggle_name == "detect_interaction_plane") settings_ptr->detect_interaction_plane = toggle_value; else if (toggle_name == "click_height") { settings_ptr->click_height = toggle_value; console_log(toggle_value); } ofstream settings_ofs(settings_file_path, ios::binary); settings_ofs.write((char*)settings_ptr, sizeof(*settings_ptr)); ipc_ptr->send_message("menu_plus", "set toggle", ""); ipc_ptr->send_message("track_plus", "load settings", ""); }); ipc.map_function("exit", [](const string message_body) { block_guardian = true; ipc.send_message("everyone", "exit", ""); ipc.clear(); exit(0); }); thread guardian_thread(guardian_thread_function); thread ipc_thread(ipc_thread_function); #ifdef _WIN32 while (true) { if (settings.launch_on_startup == "1" && !file_exists(get_startup_folder_path() + slash + "Touch+ Software.lnk")) create_shortcut(executable_path + slash + "daemon_plus" + extension0, get_startup_folder_path() + slash + "Touch+ Software.lnk", executable_path); else if (settings.launch_on_startup != "1" && file_exists(get_startup_folder_path() + slash + "Touch+ Software.lnk")) delete_file(get_startup_folder_path() + slash + "Touch+ Software.lnk"); Sleep(500); } #elif __APPLE__ //todo: port to OSX #endif while (true) Sleep(1000); return 0; }
bool EditorMode::PlayProject(String addArgs, bool debug) { FileSystem* fileSystem = GetSubsystem<FileSystem>(); ToolSystem* tsystem = GetSubsystem<ToolSystem>(); Project* project = tsystem->GetProject(); if (!project) return false; ToolEnvironment* env = GetSubsystem<ToolEnvironment>(); String playerBinary = env->GetEditorBinary(); // TODO: We need to configure project as managed bool managed = false; if (fileSystem->FileExists(project->GetResourcePath() + "AtomicProject.dll")) { managed = true; playerBinary = env->GetAtomicNETManagedIPCPlayerBinary(); } Vector<String> paths; paths.Push(env->GetCoreDataDir()); paths.Push(env->GetPlayerDataDir()); paths.Push(project->GetResourcePath()); // fixme: this is for loading from cache paths.Push(project->GetProjectPath()); paths.Push(project->GetProjectPath() + "Cache"); String resourcePaths; resourcePaths.Join(paths, "!"); Vector<String> vargs; String args = ToString("--player --project \"%s\"", AddTrailingSlash(project->GetProjectPath()).CString()); vargs = args.Split(' '); if (managed) { vargs.Insert(0, ToString("\"%s\"", (fileSystem->GetProgramDir() + "Resources/").CString())); vargs.Insert(0, "--resourcePrefix"); } if (debug) vargs.Insert(0, "--debug"); if (addArgs.Length() > 0) vargs.Insert(0, addArgs.Split(' ')); String dump; dump.Join(vargs, " "); ATOMIC_LOGINFOF("Launching Broker %s %s", playerBinary.CString(), dump.CString()); IPC* ipc = GetSubsystem<IPC>(); playerBroker_ = ipc->SpawnWorker(playerBinary, vargs); if (playerBroker_) { SubscribeToEvent(playerBroker_, E_IPCWORKERSTART, ATOMIC_HANDLER(EditorMode, HandleIPCWorkerStarted)); SubscribeToEvent(E_IPCPLAYERPAUSERESUMEREQUEST, ATOMIC_HANDLER(EditorMode, HandleIPCPlayerPauseResumeRequest)); SubscribeToEvent(E_IPCPLAYERUPDATESPAUSEDRESUMED, ATOMIC_HANDLER(EditorMode, HandleIPCPlayerUpdatesPausedResumed)); SubscribeToEvent(E_IPCPLAYERPAUSESTEPREQUEST, ATOMIC_HANDLER(EditorMode, HandleIPCPlayerPauseStepRequest)); SubscribeToEvent(E_IPCPLAYEREXITREQUEST, ATOMIC_HANDLER(EditorMode, HandleIPCPlayerExitRequest)); SubscribeToEvent(playerBroker_, E_IPCJSERROR, ATOMIC_HANDLER(EditorMode, HandleIPCJSError)); SubscribeToEvent(playerBroker_, E_IPCWORKEREXIT, ATOMIC_HANDLER(EditorMode, HandleIPCWorkerExit)); SubscribeToEvent(playerBroker_, E_IPCWORKERLOG, ATOMIC_HANDLER(EditorMode, HandleIPCWorkerLog)); } return playerBroker_.NotNull(); }
STDMETHODIMP CSimControl::get_Running(BOOL *pVal) { IPC ipc; *pVal = ipc.isInit(); return S_OK; }