Ejemplo n.º 1
0
        /// <summary>
        /// Render a batch of RenderSettings
        /// </summary>
        public async Task <RenderBatchResponse> RenderBatch(RenderBatchRequest req)
        {
            if (Client == null)
            {
                throw new InvalidOperationException("Client not connected");
            }
            if (CurrentTask != null)
            {
                throw new InvalidOperationException("Already rendering");
            }

            RenderBatchResponse resp = null;

            _taskCancelToken = new CancellationTokenSource();
            try
            {
                CurrentTask = req.TaskID;

                UpdateActivity("Render Loading..");

                resp = await Client.Send <RenderBatchResponse>(req, _taskCancelToken.Token);
            }
            finally
            {
                UpdateActivity("");
                CurrentTask      = null;
                _taskCancelToken = null;
            }
            return(resp);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Async executes a batch of subtasks on node
        /// </summary>
        private async Task <SubTaskBatchResult> ExecuteSubTasksAsync(RenderNode node, Action <RenderSubTask, RenderBatchResult> onResult, params RenderSubTask[] tasks)
        {
            List <RenderRequest> reqs = tasks.Select(x => x.GetRenderRequest()).ToList();

            List <RenderBatchResult> results = new List <RenderBatchResult>();
            Action <RenderNode, RenderBatchResult> onAnyResult = (bnode, result) =>
            {
                RenderSubTask task = tasks.FirstOrDefault(x => x.ID == result.TaskID);
                if (task != null)
                {
                    lock (results)
                        results.Add(result);
                    onResult(task, result);
                }
            };

            Stopwatch time = new Stopwatch();

            time.Start();
            try
            {
                node.OnBatchResult += onAnyResult;


                RenderBatchRequest req = RenderSubTask.GetRenderBatchRequest(ID, tasks);
                req.Settings.ForEach(x => x.RenderType = node.RenderType);
                RenderBatchResponse resp = await node.RenderBatch(req);

                if (resp == null)
                {
                    return(new SubTaskBatchResult(new Exception("Render fail: (null)")));
                }

                if (resp.Success == false)
                {
                    return(new SubTaskBatchResult(new Exception("Render fail: " + resp.Message)));
                }

                if (req.Settings.Count > 0)
                {
                    decimal pixelsRendered = req.Settings.Sum(x => (x.Height * (x.Y2 - x.Y)) * (x.Width * (x.X2 - x.X)));
                    node.UpdatePerformance((int)pixelsRendered, (int)time.ElapsedMilliseconds);
                }
            }
            finally
            {
                node.OnBatchResult -= onAnyResult;
                time.Stop();
            }
            return(new SubTaskBatchResult(results.ToArray()));
        }