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));
}
