public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
layer.ScaleOpacity(Opacity, Style);
return(layer);
}
private void OnBegin(RenderTask task, GPUContext context)
{
// Setup
var req = _queue[0];
req.Media.OnThumbnailRenderingBegin((SceneRenderTask)task, context, ref req);
}
public void RenderTaskFinishedSignal()
{
tlog.Debug(tag, $"RenderTaskFinishedSignal START");
using (Animatable ani = new Animatable())
{
var testingTarget = new RenderTask(ani.SwigCPtr.Handle, false);
Assert.IsNotNull(testingTarget, "Can't create success object RenderTask.");
Assert.IsInstanceOf <RenderTask>(testingTarget, "Should return RenderTask instance.");
try
{
testingTarget.FinishedSignal();
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
testingTarget.Dispose();
}
tlog.Debug(tag, $"RenderTaskFinishedSignal END (OK)");
}
public void RenderTaskSetClearColor()
{
tlog.Debug(tag, $"RenderTaskSetClearColor START");
using (Animatable ani = new Animatable())
{
ani.RegisterProperty("ArrowImage", new PropertyValue(arrowImage), Tizen.NUI.PropertyAccessMode.ReadWrite);
var testingTarget = new RenderTask(ani.SwigCPtr.Handle, false);
Assert.IsNotNull(testingTarget, "Can't create success object RenderTask.");
Assert.IsInstanceOf <RenderTask>(testingTarget, "Should return RenderTask instance.");
try
{
testingTarget.SetClearColor(new Vector4(1.0f, 1.0f, 1.0f, 1.0f));
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
testingTarget.Dispose();
}
tlog.Debug(tag, $"RenderTaskSetClearColor END (OK)");
}
public void RenderTaskSetScreenToFrameBufferMappingView()
{
tlog.Debug(tag, $"RenderTaskSetScreenToFrameBufferMappingView START");
using (View view = new View()
{
Size = new Size(100, 50)
})
{
var testingTarget = new RenderTask(view.SwigCPtr.Handle, false);
Assert.IsNotNull(testingTarget, "Can't create success object RenderTask.");
Assert.IsInstanceOf <RenderTask>(testingTarget, "Should return RenderTask instance.");
try
{
testingTarget.SetScreenToFrameBufferMappingView(view);
var result = testingTarget.GetScreenToFrameBufferMappingView();
tlog.Debug(tag, "ScreenToFrameBufferMappingView : " + result);
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
testingTarget.Dispose();
}
tlog.Debug(tag, $"RenderTaskSetScreenToFrameBufferMappingView END (OK)");
}
public void RenderTaskSetScreenToFrameBufferFunction()
{
tlog.Debug(tag, $"RenderTaskSetScreenToFrameBufferFunction START");
using (Animatable ani = new Animatable())
{
var testingTarget = new RenderTask(ani.SwigCPtr.Handle, false);
Assert.IsNotNull(testingTarget, "Can't create success object RenderTask.");
Assert.IsInstanceOf <RenderTask>(testingTarget, "Should return RenderTask instance.");
using (FrameBuffer buffer = new FrameBuffer(1, 2, 3))
{
try
{
testingTarget.SetScreenToFrameBufferFunction(new SWIGTYPE_p_f_r_Dali__Vector2__bool(buffer.SwigCPtr.Handle));
var result = testingTarget.GetScreenToFrameBufferFunction();
tlog.Debug(tag, "ScreenToFrameBufferFunction : " + result);
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
}
testingTarget.Dispose();
}
tlog.Debug(tag, $"RenderTaskSetScreenToFrameBufferFunction END (OK)");
}
private void OnMessage(string s)
{
//Debug.Log ("Got a message " + s);
if ((s != null) && !s.Equals(""))
{
JSONNode node = JSONNode.Parse(s);
//Debug.Log ("Parsed it");
string op = node["op"];
//Debug.Log ("Operation is " + op);
if ("publish".Equals(op))
{
string topic = node["topic"];
//if (topic == "/odom") {
// int xxxx = 0;
//}
//Debug.Log ("Got a message on " + topic);
foreach (Type p in _subscribers)
{
if (topic.Equals(GetMessageTopic(p)))
{
//Debug.Log ("And will parse it " + GetMessageTopic (p));
ROSBridgeMsg msg = ParseMessage(p, node["msg"]);
RenderTask newTask = new RenderTask(p, topic, msg);
lock (_queueLock) {
bool found = false;
for (int i = 0; i < _taskQ.Count; i++)
{
if (_taskQ[i].getTopic().Equals(topic))
{
_taskQ.RemoveAt(i);
_taskQ.Insert(i, newTask);
found = true;
break;
}
}
if (!found)
{
_taskQ.Add(newTask);
}
}
}
}
}
else if ("service_response".Equals(op))
{
//Debug.Log ("Got service response " + node.ToString ());
_serviceName = node["service"];
_serviceValues = (node["values"] == null) ? "" : node["values"].ToString();
}
else
{
Debug.Log("Must write code here for other messages");
}
}
else
{
Debug.Log("Got an empty message from the web socket");
}
}
public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
var color = ColorHSV.FromColor(Color.GetColorWpf(tank));
layer.Colorize(color.Hue, color.Saturation / 100.0, color.Value / 100.0 - 0.5, color.Alpha / 255.0);
return(layer);
}
public void RemoveTask(RenderTask task)
{
Interop.RenderTask.RenderTaskListRemoveTask(SwigCPtr, RenderTask.getCPtr(task));
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public static void DrawIcons(GPUContext context, RenderTask task, GPUTexture target, GPUTexture targetDepth, Scene scene)
{
#if UNIT_TEST_COMPILANT
throw new NotImplementedException("Unit tests, don't support methods calls. Only properties can be get or set.");
#else
Internal_DrawIcons(FlaxEngine.Object.GetUnmanagedPtr(context), FlaxEngine.Object.GetUnmanagedPtr(task), FlaxEngine.Object.GetUnmanagedPtr(target), FlaxEngine.Object.GetUnmanagedPtr(targetDepth), FlaxEngine.Object.GetUnmanagedPtr(scene));
#endif
}
private void RemoveTask(RenderTask task)
{
CloudBlobContainer container = this.BlobClient.GetContainerReference(ComicConfigSectionGroup.Blob.TaskContainer);
CloudBlobDirectory directory = container.GetDirectoryReference(ComicConfigSectionGroup.Blob.RenderTaskDirectory);
CloudBlob blob = directory.GetBlobReference(task.TaskId.ToString());
blob.DeleteIfExists();
}
public virtual void queue <T1>(Set <T1> clusters) where T1 : Cluster <T>
{
lock (this)
{
// Overwrite any pending cluster tasks - we don't care about intermediate states.
mNextClusters = new RenderTask(outerInstance, clusters);
}
SendEmptyMessage(RUN_TASK);
}
internal void SaveProjectIconEnd()
{
if (_savedTask)
{
_savedTask.Dispose();
_savedTask = null;
}
FlaxEngine.Object.Destroy(ref _savedBackBuffer);
}
internal void SaveProjectIcon()
{
TakeScreenshot(StringUtils.CombinePaths(Globals.ProjectCacheFolder, "icon.png"));
_savedTask = _task;
_savedBackBuffer = _backBuffer;
_task = null;
_backBuffer = null;
}
public RenderTask GetTask(uint index)
{
RenderTask ret = new RenderTask(Interop.RenderTask.RenderTaskListGetTask(SwigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public RenderTask CreateTask()
{
RenderTask ret = new RenderTask(Interop.RenderTask.RenderTaskListCreateTask(SwigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public new void QueueRender()
{
if (RenderTask != null)
{
RenderTask.ViewMatrix = ViewMatrix;
RenderTask.ProjectionMatrix = ProjectionMatrix;
RenderTask.Scene = Scene;
RenderTask.QueueRender();
}
}
/// <summary>
/// Render the task to the texture.
/// </summary>
/// <param name="gameTime"></param>
/// <param name="graphicsDevice">Graphicsdevice the spritebatch should use.</param>
/// <param name="task">The RenderTask that is to be rendered to a texture.</param>
/// <param name="renderTarget">The target to render to.</param>
public static void Render(GameTime gameTime, RenderTask task, SpriteBatch spriteBatch, RenderTarget2D renderTarget)
{
spriteBatch.GraphicsDevice.SetRenderTarget(renderTarget);
spriteBatch.GraphicsDevice.Clear(Color.Transparent);
task(gameTime, spriteBatch, Vector2.Zero);
spriteBatch.End();
UIComponent.BeginUISpriteBatch(spriteBatch);
}
/// <summary>
/// Called when ask rendering ends.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="context">The GPU execution context.</param>
protected virtual void OnEnd(RenderTask task, GPUContext context)
{
// Check if was using old backbuffer
if (_backBufferOld)
{
_oldBackbufferLiveTimeLeft--;
if (_oldBackbufferLiveTimeLeft < 0)
{
Object.Destroy(ref _backBufferOld);
}
}
}
public void RenderTaskConstructor()
{
tlog.Debug(tag, $"RenderTaskConstructor START");
var testingTarget = new RenderTask();
Assert.IsNotNull(testingTarget, "Can't create success object RenderTask.");
Assert.IsInstanceOf <RenderTask>(testingTarget, "Should return RenderTask instance.");
testingTarget.Dispose();
tlog.Debug(tag, $"RenderTaskConstructor END (OK)");
}
private void CreateModelTasks()
{
foreach (var playerModelConfig in mPlayerModelConfigs.Values)
{
var task = new RenderTask
{
PlayerModelConfig = playerModelConfig,
TaskType = TaskType.BaseModel
};
renderTasks.Enqueue(task);
}
}
public ClientRenderTask(RenderTask source)
{
this.TaskId = source.TaskId;
this.Status = source.Status;
this.CompletedOperations = source.CompletedOperations;
this.TotalOperations = source.TotalOperations;
this.OwnerUid = source.OwnerUid;
this.Effect = source.Effect;
this.PhotoSource = source.PhotoSource;
this.TemplateId = source.TemplateId;
this.Frames = source.Frames;
}
private void OnMessage(string s)
{
if ((s != null) && !s.Equals(""))
{
JSONNode node = JSONNode.Parse(s);
string op = node["op"];
if ("publish".Equals(op))
{
string topic = node["topic"];
foreach (ROSBridgeSubscriber subscriber in _subscribers)
{
if (topic.Equals(subscriber.GetMessageTopic()))
{
ROSBridgeMsg msg = subscriber.ParseMessage(node["msg"]);
RenderTask newTask = new RenderTask(subscriber, topic, msg);
lock (_queueLock)
{
bool found = false;
for (int i = 0; i < _taskQ.Count; i++)
{
if (_taskQ[i].getTopic().Equals(topic))
{
_taskQ.RemoveAt(i);
_taskQ.Insert(i, newTask);
found = true;
break;
}
}
if (!found)
{
_taskQ.Add(newTask);
}
}
}
}
}
else if ("service_response".Equals(op))
{
Debug.Log("Got service response " + node.ToString());
_serviceName = node["service"];
_serviceValues = (node["values"] == null) ? "" : node["values"].ToString();
}
else
{
Debug.Log("Must write code here for other messages");
}
}
else
{
Debug.Log("Got an empty message from the web socket");
}
}
/// <inheritdoc />
public override void OnInit()
{
// Create cache folder
if (!Directory.Exists(_cacheFolder))
{
Directory.CreateDirectory(_cacheFolder);
}
// Find atlases in a Editor cache directory
var files = Directory.GetFiles(_cacheFolder, "cache_*.flax", SearchOption.TopDirectoryOnly);
int atlases = 0;
for (int i = 0; i < files.Length; i++)
{
// Load asset
var asset = FlaxEngine.Content.LoadAsync(files[i]);
if (asset == null)
{
continue;
}
// Validate type
if (asset is PreviewsCache atlas)
{
// Cache atlas
atlases++;
_cache.Add(atlas);
}
else
{
// Skip asset
Editor.LogWarning(string.Format("Asset \'{0}\' is inside Editor\'s private directory for Assets Thumbnails Cache. Please move it.", asset.Path));
}
}
Editor.Log(string.Format("Previews cache count: {0} (capacity for {1} icons)", atlases, atlases * PreviewsCache.AssetIconsPerAtlas));
// Prepare at least one atlas
if (_cache.Count == 0)
{
GetValidAtlas();
}
// Create render task but disabled for now
_output = GPUDevice.Instance.CreateTexture("ThumbnailsOutput");
var desc = GPUTextureDescription.New2D(PreviewsCache.AssetIconSize, PreviewsCache.AssetIconSize, PreviewsCache.AssetIconsAtlasFormat);
_output.Init(ref desc);
_task = Object.New <RenderTask>();
_task.Order = 50; // Render this task later
_task.Enabled = false;
_task.Render += OnRender;
}
public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
if (ShiftX == 0 && ShiftY == 0)
{
return(layer);
}
var result = new BitmapRam(Math.Max(1, layer.Width + ShiftX), Math.Max(1, layer.Height + ShiftY));
result.DrawImage(layer, ShiftX, ShiftY);
return(result);
}
/// <summary>
/// Converts list of tasks to a batch request
/// </summary>
public static RenderBatchRequest GetRenderBatchRequest(string id, params RenderSubTask[] tasks)
{
RenderTask mainTask = tasks.FirstOrDefault()?.Parent;
return(new RenderBatchRequest()
{
TaskID = id,
Version = mainTask.Version,
SessionID = mainTask.SessionID,
FileID = mainTask.FileID,
Settings = tasks.Select(x => x.ToRenderPacketModel()).ToList()
});
}
public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
if (FlipHorz)
{
layer.FlipHorz();
}
if (FlipVert)
{
layer.FlipVert();
}
return(layer);
}
public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
if (Strength == 0)
{
return(layer);
}
int totalAlpha = 0;
long totalBrightness = 0;
using (layer.UseRead())
unsafe
{
for (int y = 0; y < layer.Height; y++)
{
byte *linePtr = layer.Data + y * layer.Stride;
byte *lineEndPtr = linePtr + layer.Width * 4;
while (linePtr < lineEndPtr)
{
int brightness = *(linePtr) * 722 + *(linePtr + 1) * 7152 + *(linePtr + 2) * 2126;
totalBrightness += brightness * *(linePtr + 3);
totalAlpha += *(linePtr + 3);
linePtr += 4;
}
}
}
if (totalAlpha == 0)
{
return(layer);
}
using (var image = layer.ToMagickImage())
{
var averageBrightness = (double)totalBrightness * 100.0 / (double)totalAlpha / 255.0 / 10000.0;
image.BackgroundColor = MagickColors.Transparent;
double strength = Strength / 100;
double scaleValue = 1 + (Brightness / averageBrightness - 1) * strength;
double scaleSaturation = Saturation == SaturationMode.Zero ? 0 : 1;
if (Saturation == SaturationMode.Reduce && scaleValue < 1)
{
scaleSaturation = 1 - (1 - scaleValue * scaleValue) * strength;
}
image.Modulate(new Percentage(100 * scaleValue), new Percentage(100 * scaleSaturation), new Percentage(100));
layer.CopyPixelsFrom(image.ToBitmapSource());
return(layer);
}
}
public override BitmapBase Apply(RenderTask renderTask, BitmapBase layer)
{
Tank tank = renderTask.Tank;
using (var image = layer.ToMagickImage())
{
image.BackgroundColor = MagickColors.Transparent;
image.FilterType = FilterType.Lanczos;
image.AdaptiveBlur(Radius, Sigma);
layer.CopyPixelsFrom(image.ToBitmapSource());
return(layer);
}
}
private void UpdateTask(RenderTask task)
{
try
{
CloudBlobContainer container = this.BlobClient.GetContainerReference(ComicConfigSectionGroup.Blob.TaskContainer);
CloudBlobDirectory directory = container.GetDirectoryReference(ComicConfigSectionGroup.Blob.RenderTaskDirectory);
CloudBlob progressBlob = directory.GetBlobReference(task.TaskId.ToString());
progressBlob.UploadText(task.ToXml());
}
catch (Exception x)
{
this.Log.Error("Unable to update render progress", x);
}
}
protected void BeginNextTask()
{
//If we're transitioning from a previous task, lets tear that shit down
if (currentRenderTask != null)
TearDownPreviousTask();
if (currentRenderTask == null && renderTasks.Count == 0)
{
mShutDown = true;
return;
}
//Dequeue the next task
currentRenderTask = renderTasks.Dequeue();
_playerEntity = mSceneMgr.CreateEntity(currentRenderTask.PlayerModelConfig.EntityName, currentRenderTask.PlayerModelConfig.ModelName);
_playerNode = mSceneMgr.RootSceneNode.CreateChildSceneNode("PlayerNode");
_playerNode.AttachObject(_playerEntity);
_playerNode._setDerivedPosition(_playerNode.Position + new Vector3(0, -0.5f * _playerEntity.BoundingRadius, 0));
//Set up name of dat animation collection
var animationCollectionName = currentRenderTask.PlayerModelConfig.EntityName;
switch (currentRenderTask.TaskType)
{
case TaskType.Item:
animationCollectionName += "_" + currentRenderTask.ItemConfig.EntityName;
break;
case TaskType.Wearable:
animationCollectionName += "_" + currentRenderTask.WearableConfig.EntityName;
break;
}
mAnimationCollection = new AnimationCollection { Name = animationCollectionName };
mStateIterator = _playerEntity.AllAnimationStates.GetAnimationStateIterator();
if (_playerEntity != null)
{
switch (currentRenderTask.TaskType)
{
case TaskType.Item:
{
_currentItem = mSceneMgr.CreateEntity(currentRenderTask.ItemConfig.EntityName,
currentRenderTask.ItemConfig.ModelName);
var ic = currentRenderTask.ItemConfig;
_playerEntity.AttachObjectToBone(currentRenderTask.PlayerModelConfig.RHandBoneName, _currentItem,
new Quaternion(ic.QuatW, ic.QuatX, ic.QuatY, ic.QuatZ),
new Vector3(ic.OffsetX, ic.OffsetY, ic.OffsetZ));
//Make player entity transparent so all we see is the item
_playerEntity.SetMaterialName("transparent_mask");
}
break;
case TaskType.Wearable:
_playerEntity.SetMaterialName(currentRenderTask.WearableConfig.Material);
break;
}
}
//_ent.SetMaterialName("Normal");
/*
var sub = _ent.GetSubEntity(0);
sub.SetCustomParameter(CUSTOM_SHININESS, new Vector4(10.0f, 0.0f, 0.0f, 0.0f));
sub.SetCustomParameter(CUSTOM_DIFFUSE, new Vector4(1.0f, 1.0f, 0.7f, 1.0f));
sub.SetCustomParameter(CUSTOM_SPECULAR, new Vector4(1.0f, 1.0f, 1.0f, 1.0f));*/
NextAnimation();
}
private void CreateItemTasks()
{
foreach (var itemConfig in mItemConfigs.Values)
{
foreach (var playerModelConfig in mPlayerModelConfigs.Values)
{
var task = new RenderTask
{
ItemConfig = itemConfig,
PlayerModelConfig = playerModelConfig,
TaskType = TaskType.Item
};
renderTasks.Enqueue(task);
}
}
}
private void CreateWearableTasks()
{
foreach (var wearableConfig in mWearableConfigs.Values)
{
if (!mPlayerModelConfigs.ContainsKey(wearableConfig.ModelName))
continue;
var task = new RenderTask
{
WearableConfig = wearableConfig,
PlayerModelConfig = mPlayerModelConfigs[wearableConfig.ModelName],
TaskType = TaskType.Wearable
};
renderTasks.Enqueue(task);
}
}
private void TearDownPreviousTask()
{
mSceneMgr.DestroyAllEntities();
mSceneMgr.DestroyAllAnimations();
_playerNode.RemoveAndDestroyAllChildren();
mSceneMgr.DestroySceneNode(_playerNode);
_playerEntity = null;
_playerNode.Dispose();
_playerNode = null;
mAnimationCollection = null;
mStateIterator = null;
mRenderedAnims = new List<string>();
mCurrentAnimState = null;
mAnimTime = 0;
mAnimMaxTime = 0;
mFrameCount = 0;
currentRenderTask = null;
}
void ILayer.Render(Graphics g, Map map)
{
// We don't need to regenerate the tiles
if (map.Envelope.Equals(_lastViewport) && _numPendingDownloads == 0)
{
g.DrawImage(_bitmap, Point.Empty);
return;
}
// Create a backbuffer
lock (_renderLock)
{
if (_bitmap == null || _bitmap.Size != map.Size)
{
_bitmap = new Bitmap(map.Size.Width, map.Size.Height, PixelFormat.Format32bppArgb);
using (var tmpGraphics = Graphics.FromImage(_bitmap))
tmpGraphics.Clear(Color.Transparent);
}
}
// Save the last viewport
_lastViewport = map.Envelope;
// Cancel old rendercycle
((ITileAsyncLayer)this).Cancel();
var mapViewport = map.Envelope;
var mapSize = map.Size;
var mapColumnWidth = _cellSize.Width+_cellBuffer.Width;
var mapColumnHeight = _cellSize.Height + _cellBuffer.Width;
var columns = (int)Math.Ceiling((double) mapSize.Width/mapColumnWidth);
var rows = (int) Math.Ceiling((double) mapSize.Height/mapColumnHeight);
var renderMapSize = new Size(columns * _cellSize.Width + _cellBuffer.Width,
rows * _cellSize.Height + _cellBuffer.Height);
var horizontalFactor = (double) renderMapSize.Width/mapSize.Width;
var verticalFactor = (double) renderMapSize.Height/mapSize.Height;
var diffX = 0.5d*(horizontalFactor*mapViewport.Width - mapViewport.Width);
var diffY = 0.5d*(verticalFactor*mapViewport.Height-mapViewport.Height);
var totalRenderMapViewport = mapViewport.Grow(diffX, diffY);
var columnWidth = totalRenderMapViewport.Width/columns;
var rowHeight = totalRenderMapViewport.Height/rows;
var rmdx = (int)((mapSize.Width-renderMapSize.Width) * 0.5f);
var rmdy = (int)((mapSize.Height - renderMapSize.Height) * 0.5f);
var tileSize = Size.Add(_cellSize, Size.Add(_cellBuffer, _cellBuffer));
var miny = totalRenderMapViewport.MinY;
var pty = rmdy + renderMapSize.Height - tileSize.Height;
for (var i = 0; i < rows; i ++)
{
var minx = totalRenderMapViewport.MinX;
var ptx = rmdx;
for (var j = 0; j < columns; j++)
{
var tmpMap = new Map(_cellSize);
tmpMap.Layers.Add(_baseLayer);
tmpMap.DisposeLayersOnDispose = false;
tmpMap.ZoomToBox(new Envelope(minx, minx + columnWidth, miny, miny + rowHeight));
var cancelToken = new System.Threading.CancellationTokenSource();
var token = cancelToken.Token;
var pt = new Point(ptx, pty);
var t = new System.Threading.Tasks.Task(delegate
{
if (token.IsCancellationRequested)
token.ThrowIfCancellationRequested();
var res = RenderCellOnThread(token, pt, tmpMap);
if (res)
{
System.Threading.Interlocked.Decrement(ref _numPendingDownloads);
var e = DownloadProgressChanged;
if (e != null)
e(_numPendingDownloads);
}
}, token);
var dt = new RenderTask {CancellationToken = cancelToken, Task = t};
lock (_currentTasks)
{
_currentTasks.Add(dt);
_numPendingDownloads++;
}
t.Start();
minx += columnWidth;
ptx += _cellSize.Width;
}
miny += rowHeight;
pty -= _cellSize.Height;
}
}
internal override void ProcessTask(RenderTask task)
{
if (gm != null)
gm.ProcessTask(task);
}
private void CreateModelTasks()
{
foreach (var playerModelConfig in mPlayerModelConfigs.Values)
{
var task = new RenderTask
{
PlayerModelConfig = playerModelConfig,
TaskType = TaskType.BaseModel
};
renderTasks.Enqueue(task);
}
}
internal virtual void ProcessTask(RenderTask task)
{
if (!isSuspended && parent != null)
parent.ProcessTask(task);
}
