public virtual void issueRequest(ref ThreadRequest req) { lock (req_queue) { req_queue.Enqueue(req); } }
private void MainWindow_OnClosing(object sender, CancelEventArgs e) { //Stop request timer requestHandler.Stop(); //Send Terminate Rendering request to the rt_thread ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.TERMINATE_REQUEST; glControl.engine.issueRenderingRequest(ref req); //Wait for the request to finish while (true) { lock (req) { if (req.status == THREAD_REQUEST_STATUS.FINISHED) { break; } } } //Cleanup GL Context glControl.engine.resMgr.Cleanup(); glControl.Dispose(); }
private Task createTask(ThreadRequest tr) { Task tk = new Task(); tk.task_uid = taskGUIDCounter; tk.thread_request = tr; //Create and start Thread Thread t = null; switch (tr.type) { case THREAD_REQUEST_TYPE.LOAD_NMS_ARCHIVES_REQUEST: string filepath = (string)tr.arguments[0]; string gameDir = (string)tr.arguments[1]; ResourceManager resMgr = (ResourceManager)tr.arguments[2]; t = new Thread(() => NMSUtils.loadNMSArchives(filepath, gameDir, ref resMgr, ref tk.thread_request.response)); break; default: Console.WriteLine("DISPATCHER : Unsupported Thread Request"); break; } tk.thread = t; tk.thread.IsBackground = true; tk.thread.Start(); return(tk); }
public async Task <Thread> Put(ThreadRequest req) { var book = await _context.Book.FindAsync(req.BookId); var now = DateTime.Now; var thread = new Thread { To = book.User, From = req.From, BookId = req.BookId, DateAdded = now, IsDeleted = false, Message = new List <Message> { new Message { Text = "Hello, I am interested in your book.", SentBy = "From", DateAdded = now, IsDeleted = false } } }; _context.Thread.Add(thread); await _context.SaveChangesAsync(); return(thread); }
public static void sendRequest(ref ThreadRequest req) { //This function simply issues the request for handling from the active GL Control //It is the senders responsibility to handle and keep track of any results if necessary //Should be awesome for blind requests that have to activeControl?.issueRenderingRequest(ref req); }
//Shader Compilation public static void issuemodifyShaderRequest(GLSLShaderConfig config, GLSLShaderText shaderText) { Console.WriteLine("Sending Shader Modification Request"); ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_MODIFY_SHADER_REQUEST; req.arguments.Add(config); req.arguments.Add(shaderText); //Send request CallBacks.issueRequestToGLControl(ref req); }
/// <summary> /// Sends the thread request. /// </summary> /// <param name="state">The state.</param> private void SendRequest(object state) { var subscriber = _multiplexer.GetSubscriber( ); var request = new ThreadRequest( ); var channelMessage = ChannelMessage <ThreadRequest> .Create(request); byte[] serializedObject = ChannelHelper.Serialize(channelMessage); byte[] compressedObject = ChannelHelper.Compress(serializedObject); subscriber.Publish("ReadiNowDiagnosticRequests", compressedObject, CommandFlags.FireAndForget); }
private void SceneTreeView_Drop(object sender, DragEventArgs e) { var tv = sender as TreeView; IInputElement target = SceneTreeView.InputHitTest(e.GetPosition(SceneTreeView)); if (old_tb != start_tb) { old_tb.Background = null; } TextBlock tb = (TextBlock)target; if (tb == null || target_drag == null) { return; } if (init_drag != target_drag) { //Remove child from parent model node ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.CHANGE_MODEL_PARENT_REQUEST; req.arguments.Add(init_drag); req.arguments.Add(target_drag); glControl.engine.issueRenderingRequest(ref req); /* * lock (init_drag) * { * if (init_drag.parent != null) * { * lock (init_drag.parent.Children) * { * init_drag.parent.Children.Remove(init_drag); * } * } * * //Add to target node * init_drag.parent = target_drag; * } * * lock (target_drag.Children) * { * target_drag.Children.Add(init_drag); * } */ init_drag = null; target_drag = null; e.Handled = true; } }
//Open File private void OpenFile(string filename, bool testScene, int testSceneID) { Console.WriteLine("Importing " + filename); ThreadRequest req; //Pause renderer req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_PAUSE_RENDER_REQUEST; req.arguments.Clear(); //Send request glControl.issueRenderingRequest(ref req); glControl.waitForRenderingRequest(ref req); //Clear treeview Application.Current.Dispatcher.BeginInvoke((System.Action)(() => { SceneTreeView.Items.Clear(); })); RenderState.rootObject?.Dispose(); if (testScene) { glControl.addTestScene(testSceneID); } else { glControl.addScene(filename); } //Populate RenderState.rootObject.ID = itemCounter; Util.setStatus("Creating Treeview..."); //Add to UI Application.Current.Dispatcher.BeginInvoke((System.Action)(() => { SceneTreeView.Items.Add(RenderState.rootObject); })); Util.setStatus("Ready"); //Generate Request for resuming rendering ThreadRequest req2 = new ThreadRequest(); req2.type = THREAD_REQUEST_TYPE.GL_RESUME_RENDER_REQUEST; req2.arguments.Clear(); glControl.issueRenderingRequest(ref req2); //glControl.waitForRenderingRequest(ref req2); }
private void ResizeControl(object sender, System.Timers.ElapsedEventArgs e) { resizeTimer.Stop(); //Make new request ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_RESIZE_REQUEST; req.arguments.Clear(); req.arguments.Add(ClientSize.Width); req.arguments.Add(ClientSize.Height); engine.issueRenderingRequest(ref req); }
public async Task <IActionResult> Put(string id, [FromBody] ThreadRequest threadDto) { var thread = _mapper.Map <ThreadRequest, Thread>(threadDto); var result = await _threadService.UpdateAsync(id, thread); if (!result.Success) { return(BadRequest(new ErrorViewModel())); } var threadDTO = _mapper.Map <Thread, ThreadResponse>(result.Resource); return(Ok(threadDTO)); }
private IntPtr HwndMessageHook(IntPtr wnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled) { switch (msg) { case WmExitSizeMove: { //Send resizing request ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_RESIZE_REQUEST; req.arguments.Add(glControl.Width); req.arguments.Add(glControl.Height); //Send request glControl.engine.issueRenderingRequest(ref req); issuedRequests.Add(req); //Send Unpause rendering requenst req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_RESUME_RENDER_REQUEST; //Send request glControl.issueRenderingRequest(ref req); issuedRequests.Add(req); //Mark as handled event handled = true; break; } case WmEnterSizeMove: { //Send Unpause rendering requenst ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GL_PAUSE_RENDER_REQUEST; req.arguments.Clear(); //Send request glControl.engine.issueRenderingRequest(ref req); issuedRequests.Add(req); //Mark as handled event handled = true; break; } } return(IntPtr.Zero); }
public void waitForRenderingRequest(ref ThreadRequest req) { while (true) { lock (req) { if (req.status == THREAD_REQUEST_STATUS.FINISHED) { return; } else { Thread.Sleep(2); } } } }
//Request Handler private void queryRequests(object sender, System.Timers.ElapsedEventArgs e) { int i = 0; lock (issuedRequests) { while (i < issuedRequests.Count) { ThreadRequest req = issuedRequests[i]; lock (req) { if (req.status == THREAD_REQUEST_STATUS.FINISHED) { switch (req.type) { case THREAD_REQUEST_TYPE.NEW_TEST_SCENE_REQUEST: case THREAD_REQUEST_TYPE.NEW_SCENE_REQUEST: Console.WriteLine("Shouldn't be here"); break; case THREAD_REQUEST_TYPE.LOAD_NMS_ARCHIVES_REQUEST: //Enable Open File Functions Application.Current.Dispatcher.BeginInvoke((System.Action)(() => { OpenFileHandle.IsEnabled = true; if (req.response == 0) { OpenFilePAKHandle.IsEnabled = true; } })); Util.setStatus("Ready"); break; default: break; } issuedRequests.RemoveAt(i); //Remove request } else { i++; } } } } }
public void addTestScene(int sceneID) { //Cleanup first modelUpdateQueue.Clear(); //Clear Update Queues //Generate Request for rendering thread ThreadRequest req1 = new ThreadRequest(); req1.type = THREAD_REQUEST_TYPE.NEW_TEST_SCENE_REQUEST; req1.arguments.Add(sceneID); issueRenderingRequest(ref req1); //Wait for requests to finish before return waitForRenderingRequest(ref req1); //find Animation Capable nodes activeModel = null; //TODO: Fix that with the gizmos findAnimScenes(RenderState.rootObject); //Repopulate animScenes findActionScenes(RenderState.rootObject); //Re-populate actionSystem }
/// <summary> /// 得到一个闲置的线程,执行传入的任务,如果没有可用的线程则将其加入一个等待队列 /// </summary> /// <param name="action"></param> /// <param name="arg"></param> /// <returns></returns> public void StartTask(Action <object> action, object arg) { if (threadPool.Count < processorCount) { ThreadRequest request = new ThreadRequest(); request.StartThread(action, arg); threadPool.Add(request); } else { if (unusedThreadStack.Count > 0) { ThreadRequest request = unusedThreadStack.Pop(); request.StartThread(action, arg); } else { VoidTask voidTask = new VoidTask(); voidTask.task = action; voidTask.arg = arg; waitingVoidTasks.Enqueue(voidTask); } } }
public T Exchange(T mine, int timeout) { lock (lockObj) { //Se já existir um request então este request pode emparelhar com ele if (request != null) { //dois requests estão a emparelhar request.isExchanging = true; //Trocar mensagens T myMessage = request.message; request.message = mine; //Acorda a thread à espera de emparelhamento Monitor.Pulse(lockObj); //Retorna a mensagem return(myMessage); } //Ainda não existe nenhum request em espera de emparelhamento, logo tem de esperar por outro ThreadRequest req = new ThreadRequest(mine); request = req; //Momento inicial da espera int lastTime = (timeout != Timeout.Infinite) ? Environment.TickCount : 0; do { try { //Esperar por outro emparelhamento Monitor.Wait(lockObj, timeout); } catch (ThreadInterruptedException) { //Se sair por excepção e estiver a emparelhar: if (req.isExchanging) { //sinalizar esta thread como interrompida Thread.CurrentThread.Interrupt(); //retornar a mensagem return(req.message); } //Se sair por excepção e não estiver a emparelhar elimina o request e lança excepção request = null; throw; } //Se a thread acordou e estiver a emparelhar: if (req.isExchanging) { //Apagar o request request = null; //Retornar a mensagem return(req.message); } //enquanto não tiver passado timeOut. Isto porque podem ocorrer saidas espurias } while (SyncUtils.AdjustTimeout(ref lastTime, ref timeout) != 0); //Se a thread saiu por timeOut e está a emparelhar então continua e retorna if (req.isExchanging) { //Apagar o request request = null; //Retornar a mensagem return(req.message); } //Se a thread saiu por timeOut e não está a emparelhar então apaga o request e lança excepção request = null; throw new TimeoutException(); } }
public void issueRenderingRequest(ref ThreadRequest r) { reqHandler.issueRequest(ref r); }
public void handleRequests() { if (reqHandler.hasOpenRequests()) { ThreadRequest req = reqHandler.Fetch(); lock (req) { switch (req.type) { case THREAD_REQUEST_TYPE.QUERY_GLCONTROL_STATUS_REQUEST: //At this point the renderer is up and running req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.INIT_RESOURCE_MANAGER: resMgr.Init(); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.NEW_SCENE_REQUEST: inputPollTimer.Stop(); rt_addRootScene((string)req.arguments[0]); req.status = THREAD_REQUEST_STATUS.FINISHED; inputPollTimer.Start(); break; #if DEBUG case THREAD_REQUEST_TYPE.NEW_TEST_SCENE_REQUEST: inputPollTimer.Stop(); rt_addTestScene((int)req.arguments[0]); req.status = THREAD_REQUEST_STATUS.FINISHED; inputPollTimer.Start(); break; #endif case THREAD_REQUEST_TYPE.CHANGE_MODEL_PARENT_REQUEST: Model source = (Model)req.arguments[0]; Model target = (Model)req.arguments[1]; System.Windows.Application.Current.Dispatcher.Invoke((System.Action)(() => { if (source.parent != null) { source.parent.Children.Remove(source); } //Add to target node source.parent = target; target.Children.Add(source); })); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.UPDATE_SCENE_REQUEST: Scene req_scn = (Scene)req.arguments[0]; req_scn.update(); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GL_COMPILE_ALL_SHADERS_REQUEST: resMgr.compileMainShaders(); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.MOUSEPOSITION_INFO_REQUEST: Vector4[] t = (Vector4[])req.arguments[2]; renderMgr.getMousePosInfo((int)req.arguments[0], (int)req.arguments[1], ref t); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GL_RESIZE_REQUEST: rt_ResizeViewport((int)req.arguments[0], (int)req.arguments[1]); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GL_MODIFY_SHADER_REQUEST: GLShaderHelper.modifyShader((GLSLShaderConfig)req.arguments[0], (GLSLShaderText)req.arguments[1]); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GIZMO_PICKING_REQUEST: //TODO: Send the nessessary arguments to the render manager and mark the active gizmoparts Gizmo g = (Gizmo)req.arguments[0]; renderMgr.gizmoPick(ref g, (Vector2)req.arguments[1]); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.TERMINATE_REQUEST: rt_State = EngineRenderingState.EXIT; inputPollTimer.Stop(); req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GL_PAUSE_RENDER_REQUEST: rt_State = EngineRenderingState.PAUSED; req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.GL_RESUME_RENDER_REQUEST: rt_State = EngineRenderingState.ACTIVE; req.status = THREAD_REQUEST_STATUS.FINISHED; break; case THREAD_REQUEST_TYPE.NULL: break; } } } }
//Do stuff once the GUI is ready private void MainWindow_OnLoaded(object sender, RoutedEventArgs e) { //Add Hook for catching the end of resizing event in WPF var helper = new WindowInteropHelper(this); if (helper.Handle != null) { var source = HwndSource.FromHwnd(helper.Handle); if (source != null) { source.AddHook(HwndMessageHook); } } //OVERRIDE SETTINGS //FileUtils.dirpath = "I:\\SteamLibrary1\\steamapps\\common\\No Man's Sky\\GAMEDATA\\PCBANKS"; //Load Settings SettingsForm.loadSettingsStatic(); glControl.StartWorkThreads(); //Check if the rt_thread is ready ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.QUERY_GLCONTROL_STATUS_REQUEST; issuedRequests.Add(req); glControl.issueRenderingRequest(ref req); while (req.status != THREAD_REQUEST_STATUS.FINISHED) { Thread.Sleep(10); } //Populate GLControl Scene scene = new Scene(); scene.type = TYPES.MODEL; scene.name = "DEFAULT SCENE"; //Add default scene to the resource manager RenderState.activeResMgr.GLScenes["DEFAULT_SCENE"] = scene; //Force rootobject RenderState.rootObject = scene; glControl.modelUpdateQueue.Enqueue(scene); glControl.engine.renderMgr.populate(scene); SceneTreeView.Items.Clear(); SceneTreeView.Items.Add(scene); //Check if Temp folder exists #if DEBUG if (!Directory.Exists("Temp")) { Directory.CreateDirectory("Temp"); } #endif //Set active Components Util.activeStatusStrip = StatusLabel; Util.activeControl = glControl; Util.activeWindow = this; //Bind Settings RenderViewOptionsControl.Content = RenderState.renderViewSettings; RenderOptionsControl.Content = RenderState.renderSettings; //Add event handlers to GUI elements sliderzNear.ValueChanged += Sliders_OnValueChanged; sliderzFar.ValueChanged += Sliders_OnValueChanged; sliderFOV.ValueChanged += Sliders_OnValueChanged; sliderLightIntensity.ValueChanged += Sliders_OnValueChanged; sliderlightDistance.ValueChanged += Sliders_OnValueChanged; sliderMovementSpeed.ValueChanged += Sliders_OnValueChanged; sliderMovementFactor.ValueChanged += Sliders_OnValueChanged; //Invoke the method in order to setup the control at startup Sliders_OnValueChanged(null, new RoutedPropertyChangedEventArgs <double>(0.0f, 0.0f)); this.Dispatcher.UnhandledException += OnDispatcherUnhandledException; //Disable Open File Functions OpenFileHandle.IsEnabled = false; OpenFilePAKHandle.IsEnabled = false; TestOptions.Visibility = Visibility.Hidden; //Hide the test options by default #if (DEBUG) //Enable the Test options if it is a debug version TestOptions.Visibility = Visibility.Visible; setTestComponents(); #endif //Issue work request ThreadRequest rq = new ThreadRequest(); rq.arguments.Add("NMSmanifest"); rq.arguments.Add(Path.Combine(RenderState.settings.GameDir, "PCBANKS")); rq.arguments.Add(RenderState.activeResMgr); rq.type = THREAD_REQUEST_TYPE.LOAD_NMS_ARCHIVES_REQUEST; workDispatcher.sendRequest(rq); issuedRequests.Add(rq); }
/// <summary> /// Creates a new thread in the specified forum with the current token user as the author. /// Requires <see cref="APIPermission.POSTSWRITE" /> /// <summary> /// <param name="forumId">The forum id.</param> /// <param name="subject">The subject of the thread.</param> /// <param name="message">The message to post.</param> public ThreadResult ThreadCreate(int forumId, string subject, string message) => ThreadRequest.Create(Client, forumId, subject, message);
/// <summary> /// Searches all the threads made by the specified user. /// Requires <see cref="APIPermission.POSTS" /> /// <summary> /// <param name="userId">The user id.</param> /// <param name="page">The page number.</param> /// <param name="perPage">The number of results per page.</param> public ThreadResult[] ThreadSearchByUserId(int userId, int page = 1, int perPage = 1) => ThreadRequest.SearchByUserId(Client, userId, page, perPage);
/// <summary> /// Gets the thread from the specified thread id. /// Requires <see cref="APIPermission.POSTS" /> /// <summary> /// <param name="threadId">The thread id.</param> public ThreadResult ThreadGet(int threadId) => ThreadRequest.Get(Client, threadId);
public void issueRenderingRequest(ref ThreadRequest req) { engine.issueRenderingRequest(ref req); }
public void sendRequest(ThreadRequest tr) { tasks.Add(createTask(tr)); }
private void frameUpdate() { VSync = RenderState.renderSettings.UseVSYNC; //Update Vsync //Console.WriteLine(RenderState.renderSettings.RENDERMODE); //Gizmo Picking //Send picking request //Make new request activeGizmo = null; if (RenderState.renderViewSettings.RenderGizmos) { ThreadRequest req = new ThreadRequest(); req.type = THREAD_REQUEST_TYPE.GIZMO_PICKING_REQUEST; req.arguments.Clear(); req.arguments.Add(activeGizmo); req.arguments.Add(mouseState.Position); engine.issueRenderingRequest(ref req); } //Set time to the renderManager engine.renderMgr.progressTime(dt); //Reset Stats RenderStats.occludedNum = 0; //Update moving queue while (modelUpdateQueue.Count > 0) { Model m = modelUpdateQueue.Dequeue(); m.update(); } //rootObject?.update(); //Update Distances from camera RenderState.rootObject?.updateLODDistances(); //Update Distances from camera engine.renderMgr.clearInstances(); //Clear All mesh instances RenderState.rootObject?.updateMeshInfo(); //Reapply frustum culling and re-setup visible instances //Update gizmo if (activeModel != null) { //TODO: Move gizmos //gizTranslate.setReference(activeModel); //gizTranslate.updateMeshInfo(); //GLMeshVao gz = resMgr.GLPrimitiveMeshVaos["default_translation_gizmo"]; //GLMeshBufferManager.addInstance(ref gz, TranslationGizmo); } //Identify dynamic Objects foreach (Model s in engine.animationSys.AnimScenes) { modelUpdateQueue.Enqueue(s.parentScene); } //Console.WriteLine("Dt {0}", dt); if (RenderState.renderViewSettings.EmulateActions) { engine.actionSys.update((float)dt); } //Progress animations if (RenderState.renderSettings.ToggleAnimations) { engine.animationSys.update((float)dt); } //Camera & Light Positions //Update common transforms RenderState.activeResMgr.GLCameras[0].aspect = (float)ClientSize.Width / ClientSize.Height; //Apply extra viewport rotation Matrix4 Rotx = Matrix4.CreateRotationX(MathUtils.radians(RenderState.rotAngles.X)); Matrix4 Roty = Matrix4.CreateRotationY(MathUtils.radians(RenderState.rotAngles.Y)); Matrix4 Rotz = Matrix4.CreateRotationZ(MathUtils.radians(RenderState.rotAngles.Z)); RenderState.rotMat = Rotz * Rotx * Roty; //RenderState.rotMat = Matrix4.Identity; RenderState.activeResMgr.GLCameras[0].Move(dt); RenderState.activeResMgr.GLCameras[0].updateViewMatrix(); RenderState.activeResMgr.GLCameras[1].updateViewMatrix(); //Update Frame Counter fps(); //Update Text Counters RenderState.activeResMgr.txtMgr.getText(TextManager.Semantic.FPS).update(string.Format("FPS: {0:000.0}", (float)RenderStats.fpsCount)); RenderState.activeResMgr.txtMgr.getText(TextManager.Semantic.OCCLUDED_COUNT).update(string.Format("OccludedNum: {0:0000}", RenderStats.occludedNum)); }