void DrawVisibleGeometry(SortingCriteria opaqueSortingCrieria, SortingCriteria transparentSortingCriteria)
{
// Draw opaque.
BeginSampleBuffer(opaqueBuffer);
var sortingSettings = new SortingSettings(camera)
{
distanceMetric = DistanceMetric.Orthographic,
criteria = opaqueSortingCrieria,
};
var drawingSettings = new DrawingSettings(unlitShaderTagId, sortingSettings);
var filteringSettings = new FilteringSettings(RenderQueueRange.opaque);
context.DrawRenderers(
cullingResults, ref drawingSettings, ref filteringSettings
);
EndSampleBuffer(opaqueBuffer);
// Draw skybox.
context.DrawSkybox(camera);
// Draw transparent.
BeginSampleBuffer(transparentBuffer);
sortingSettings.criteria = transparentSortingCriteria;
drawingSettings.sortingSettings = sortingSettings;
filteringSettings.renderQueueRange = RenderQueueRange.transparent;
context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings);
EndSampleBuffer(transparentBuffer);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
var viewData = DebugViewsManager.Instance.CurrentViewData;
if (!viewData)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(ProfilerTag);
using (new ProfilingSample(cmd, ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(_shaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterialPassIndex = 0;
drawingSettings.overrideMaterial = viewData ? viewData.Material : null;
// debug view drawing
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _filteringSettings,
ref _renderStateBlock);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public async Task <GetWeatherDto> GetWeatherAsync(string city, string units, string sortColumn = null, SortOrder sortOrder = SortOrder.Ascending)
{
SortingCriteria sorting = null;
if (!string.IsNullOrWhiteSpace(sortColumn))
{
sorting = new SortingCriteria {
ColumnName = sortColumn, SortOrder = sortOrder
}
}
;
// Create two async calls
var currentWeatherTask = _weatherService.GetCurrentWeatherAsync(city, units);
var forecastWeatherTask = _weatherService.GetDayAverageWeatherForecastAsync(city, units);
// Wait until all calls will be completed
var currentWeather = await currentWeatherTask;
var forecastWeather = await forecastWeatherTask;
if (sorting != null)
{
forecastWeather = forecastWeather.OrderByCriteria(sorting);
}
var dto = new GetWeatherDto
{
Current = _mapper.Map <WeatherItem, WeatherItemDto>(currentWeather),
ForecastItems = _mapper.Map <IEnumerable <WeatherItem>, IEnumerable <WeatherItemDto> >(forecastWeather)
};
return(dto);
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//Blit(cmd, BuiltinRenderTextureType.CurrentActive, tmp.depthBuffer);
context.ExecuteCommandBuffer(cmd);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings,
ref m_RenderStateBlock);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
RenderTexture.ReleaseTemporary(tmp);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (material == null || !renderingData.cameraData.postProcessEnabled)
{
return;
}
// Define rendering conditions (which objects, what data to include, which material, etc)
SortingCriteria opaqueSortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(depthOnlyShaderTag, ref renderingData, opaqueSortFlags);
drawingSettings.perObjectData = PerObjectData.None;
drawingSettings.overrideMaterial = material;
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);
// Render and set result as a global texture so other shaders can use it
CommandBuffer buffer = CommandBufferPool.Get(DEPTH_NORMAL_EFFECT_TAG);
buffer.SetGlobalTexture(globalTextureName, renderTargetHandle.id);
context.ExecuteCommandBuffer(buffer);
CommandBufferPool.Release(buffer);
}
public ActionResult <IEnumerable <OutgoingVehicleDTO> > GetFilteredAds(
[FromHeader, DefaultValue(SortingCriteria.UploadDate)] SortingCriteria sortBy,
[FromHeader, DefaultValue(false)] bool sortAscending,
[FromHeader, DefaultValue(0)] int startIndex,
[FromHeader, DefaultValue(10)] int amount,
[FromHeader] string brand = null,
[FromHeader] string model = null,
[FromHeader] bool?used = null,
[FromHeader] int?priceFrom = null,
[FromHeader] int?priceTo = null,
[FromHeader] string uploaderUsername = null,
[FromHeader] int?yearFrom = null,
[FromHeader] int?yearTo = null,
[FromHeader] FuelType?fuelType = null,
[FromHeader] ChassisType?chassisType = null)
{
VehicleFilters filters = new VehicleFilters
{
Brand = brand,
Model = model,
Used = used,
PriceFrom = priceFrom,
PriceTo = priceTo,
Username = uploaderUsername,
YearFrom = yearFrom,
YearTo = yearTo,
FuelType = fuelType,
ChassisType = chassisType
};
var cars = _services.GetFilteredVehicles(filters, sortBy, sortAscending, startIndex, amount);
return(cars == null?NoContent() : new ActionResult <IEnumerable <OutgoingVehicleDTO> >(cars));
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// Update the Value
m_RenderStateBlock.stencilReference = m_Settings.StencilValue;
m_FilteringSettings.layerMask = m_Settings.ReflectiveSurfaceLayer;
// Draw settings
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
// Render any 'reflective surfaces' with the stencil value,
// will use this to generate the texture later
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingScope(cmd, m_ProfilerSampler))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings,
ref m_RenderStateBlock);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
NormalReconstruction.SetupProperties(cmd, renderingData.cameraData);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DecalNormalBlendLow, m_Settings.normalBlend == DecalNormalBlend.Low);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DecalNormalBlendMedium, m_Settings.normalBlend == DecalNormalBlend.Medium);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DecalNormalBlendHigh, m_Settings.normalBlend == DecalNormalBlend.High);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
m_DrawSystem?.Execute(cmd);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// fetch a command buffer to use
CommandBuffer cmd = CommandBufferPool.Get(profilerTag);
cmd.Clear();
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = materialToBlit;
drawingSettings.overrideMaterialPassIndex = (int)PassId.SelectionPassVisible;
CoreUtils.SetRenderTarget(cmd, m_maskTexture.Identifier(), ClearFlag.All, Color.clear);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawRenderers(renderingData.cullResults,
ref drawingSettings,
ref m_FilteringSettingsOpaque,
ref m_RenderStateBlock);
context.DrawRenderers(renderingData.cullResults,
ref drawingSettings,
ref m_FilteringSettingsTransparent,
ref m_RenderStateBlock);
cmd.SetGlobalColor(s_BlurDirection, new Color(1, 0, 0, 0));
cmd.Blit(m_maskTexture.id, m_blurTexture.id, materialToBlit, (int)PassId.SelectionPassBlur);
cmd.SetGlobalColor(s_BlurDirection, new Color(0, 1, 0, 0));
cmd.Blit(m_blurTexture.id, m_maskTexture.id, materialToBlit, (int)PassId.SelectionPassBlur);
cmd.Blit(m_maskTexture.id, source, materialToBlit, (int)PassId.SelectionPassOutline);
// Add the following code snippet after calling cmd.Blit
// in 2020.2+URP, cmd.Blit has a bug to turn off stereo shader keyword. Enable keyword again manually.
if (renderingData.cameraData.isStereoEnabled)
{
if (SystemInfo.supportsMultiview)
{
cmd.EnableShaderKeyword("STEREO_MULTIVIEW_ON");
}
else
{
cmd.EnableShaderKeyword("STEREO_INSTANCING_ON");
}
}
else
{
cmd.DisableShaderKeyword("STEREO_MULTIVIEW_ON");
cmd.DisableShaderKeyword("STEREO_INSTANCING_ON");
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public IEnumerable <Vehicle> GetFilteredVehicles(VehicleFilters filters, SortingCriteria sortBy, bool sortAscending, int startIndex, int amount)
{
IEnumerable <Vehicle> filteredVehicleList = _vehicles.Include(v => v.VehicleModel);
if (!string.IsNullOrEmpty(filters.Brand))
{
filteredVehicleList = (from v in filteredVehicleList where v.VehicleModel.Brand.Contains(filters.Brand) select v);
}
if (!string.IsNullOrEmpty(filters.Model))
{
filteredVehicleList = (from v in filteredVehicleList where v.VehicleModel.Model.Contains(filters.Model) select v);
}
if (filters.Used.HasValue)
{
filteredVehicleList = (from v in filteredVehicleList where v.Used == filters.Used select v);
}
if (filters.PriceFrom.HasValue)
{
filteredVehicleList = (from v in filteredVehicleList where v.Price >= filters.PriceFrom select v);
}
if (filters.PriceTo.HasValue)
{
filteredVehicleList = (from v in filteredVehicleList where v.Price <= filters.PriceTo select v);
}
if (filters.FuelType.HasValue)
{
filteredVehicleList = (from v in filteredVehicleList where v.Engine.FuelType == filters.FuelType select v);
}
filteredVehicleList = FilterByYear(filters.YearFrom, filters.YearTo, filteredVehicleList);
return(GetSortedVehiclesList(sortBy, sortAscending, startIndex, amount, (IQueryable <Vehicle>)filteredVehicleList));
}
public DrawObjectsRenderPass(RenderPassEvent passEvent, bool opaque, RenderQueueRange range, SortingCriteria criteria)
{
renderPassEvent = passEvent;
isOpaque = opaque;
sortingCriteria = criteria;
filteringSettings = new FilteringSettings(range);
shaderTagId = ShaderTags.ForwardBase;
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(_shaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = _overrideMaterial;
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _filteringSettings, ref _renderStateBlock);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
Camera camera = renderingData.cameraData.camera;
float cameraAspect = (float)camera.pixelWidth / (float)camera.pixelHeight;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
if (m_CameraSettings.overrideCamera)
{
Matrix4x4 projectionMatrix = Matrix4x4.Perspective(m_CameraSettings.cameraFieldOfView, cameraAspect,
camera.nearClipPlane, camera.farClipPlane);
Matrix4x4 viewMatrix = camera.worldToCameraMatrix;
Vector4 cameraTranslation = viewMatrix.GetColumn(3);
viewMatrix.SetColumn(3, cameraTranslation + m_CameraSettings.offset);
Vector4 plane = new Vector4(0, 1, 0, 0);
Matrix4x4 reflectMatrix = Matrix4x4.identity;
CalculateReflectionMatrix(ref reflectMatrix, plane);
viewMatrix = camera.worldToCameraMatrix * reflectMatrix;
cmd.SetInvertCulling(true);
cmd.SetViewProjectionMatrices(viewMatrix, projectionMatrix);
context.ExecuteCommandBuffer(cmd);
}
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings,
ref m_RenderStateBlock);
if (m_CameraSettings.overrideCamera && m_CameraSettings.restoreCamera)
{
Matrix4x4 projectionMatrix = Matrix4x4.Perspective(camera.fieldOfView, cameraAspect,
camera.nearClipPlane, camera.farClipPlane);
cmd.Clear();
cmd.SetViewProjectionMatrices(camera.worldToCameraMatrix, projectionMatrix);
}
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
cmd.SetInvertCulling(false);
}
private IEnumerable <Vehicle> GetSortedVehiclesList(SortingCriteria sortBy, bool sortAscending, int startIndex, int amount, IQueryable <Vehicle> listToSort = null)
{
if (listToSort == null)
{
listToSort = _vehicles;
}
listToSort = listToSort.Include(v => v.VehicleModel);
listToSort.SortBy(sortBy, sortAscending);
return(listToSort.Skip(startIndex).Take(amount));
}
public ActionResult <IEnumerable <OutgoingVehicleDTO> > GetSortedAds(
[FromHeader, DefaultValue(SortingCriteria.UploadDate)] SortingCriteria sortBy,
[FromHeader, DefaultValue(false)] bool sortAscending,
[FromHeader, DefaultValue(0)] int startIndex,
[FromHeader, DefaultValue(10)] int amount)
{
var cars = _services.GetSortedVehicles(sortBy, sortAscending, startIndex, amount);
return(cars == null?NoContent() : new ActionResult <IEnumerable <OutgoingVehicleDTO> >(cars));
}
public IEnumerable <OutgoingVehicleDTO> GetSortedVehicles(SortingCriteria sortBy, bool sortAscending, int startIndex, int amount)
{
var v = _repository.GetSortedVehicles(sortBy, sortAscending, startIndex, amount);
if (v == null)
{
return(null);
}
return(v.Select(x => x.ToOutgoingDTO()));
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
ref CameraData cameraData = ref renderingData.cameraData;
/// <inheritdoc/>
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = overrideMaterial;
drawingSettings.overrideMaterialPassIndex = overrideMaterialPassIndex;
Camera camera = renderingData.cameraData.camera;
float cameraAspect = (float)camera.pixelWidth / (float)camera.pixelHeight;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
using (new ProfilingSample(cmd, m_ProfilerTag))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
ConfigureTarget(m_TemporaryOutlineTexture.Identifier());
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings, ref m_RenderStateBlock);
}
// ------------
//
// ------------
// CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
RenderTextureDescriptor opaqueDesc = renderingData.cameraData.cameraTargetDescriptor;
opaqueDesc.depthBufferBits = 0;
// Can't read and write to same color target, create a temp render target to blit.
if (destination == RenderTargetHandle.CameraTarget)
{
cmd.GetTemporaryRT(m_TemporaryOutlineTexture.id, opaqueDesc, filterMode);
Blit(cmd, source, m_TemporaryOutlineTexture.Identifier(), blitMaterial, blitShaderPassIndex);
Blit(cmd, m_TemporaryOutlineTexture.Identifier(), source);
}
else
{
//Blit(cmd, source, destination.Identifier(), blitMaterial, blitShaderPassIndex);
cmd.GetTemporaryRT(m_TemporaryOutlineTexture.id, opaqueDesc, filterMode);
Blit(cmd, destination.Identifier(), m_TemporaryOutlineTexture.Identifier(), blitMaterial, blitShaderPassIndex);
Blit(cmd, m_TemporaryOutlineTexture.Identifier(), source);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public void Print(BookType bookType, SortingCriteria sortingData)
{
List <Book> sortedBooks;
switch (sortingData)
{
case SortingCriteria.None:
sortedBooks = _books;
break;
case SortingCriteria.ByAuthor:
sortedBooks = _books.OrderBy(b => b.Author).ToList();
break;
case SortingCriteria.ByTitle:
sortedBooks = _books.OrderBy(b => b.Title).ToList();
break;
default:
throw new ArgumentException($"The sortingCriteria={sortingData} is not supported", nameof(sortingData));
}
foreach (Book item in sortedBooks)
{
switch (bookType)
{
case BookType.All:
item.Print();
break;
case BookType.Technical:
if (item is TecnicalBook)
{
item.Print();
}
break;
case BookType.Fiction:
if (item is FictionBook)
{
item.Print();
}
break;
default:
break;
}
}
}
public void Render(ScriptableRenderContext context, Camera camera, SortingCriteria opaqueSortingCrieria, SortingCriteria transparentSortingCriteria)
{
this.context = context;
this.camera = camera;
PrepareBuffer();
PrepareUIGeometryForSceneWindow();
if (!Cull())
{
return;
}
Setup();
DrawVisibleGeometry(opaqueSortingCrieria, transparentSortingCriteria);
DrawUnsupportedShaders();
DrawGizmos();
Submit();
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
// Here you can implement the rendering logic.
// Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
// https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
// You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
//=============================================================
//draw objects(e.g. reflective wet ground plane) with lightmode "MobileSSPRWater", which will sample _MobileSSPR_ColorRT
DrawingSettings baseDrawingSetting, layerDrawingSetting;
//BaseLayer DrawingSetting
if (m_ShaderTagIdList.Count > 0)
{
baseDrawingSetting = CreateDrawingSettings(m_ShaderTagIdList[0], ref renderingData,
renderingData.cameraData.defaultOpaqueSortFlags);
}
else
{
return;
}
if (m_ShaderTagIdList.Count > 1)
{
layerDrawingSetting = CreateDrawingSettings(m_ShaderTagIdList[1], ref renderingData,
renderingData.cameraData.defaultOpaqueSortFlags);
}
else
{
return;
}
float inter = 1.0f / settings.PassLayerNum;
//BaseLayer
cmd.Clear();
cmd.SetGlobalFloat("_FUR_OFFSET", 0);
context.ExecuteCommandBuffer(cmd);
context.DrawRenderers(renderingData.cullResults, ref baseDrawingSetting, ref filter);
//TransparentLayer
for (int i = 1; i < settings.PassLayerNum; i++)
{
cmd.Clear();
cmd.SetGlobalFloat("_FUR_OFFSET", i * inter);
context.ExecuteCommandBuffer(cmd);
context.DrawRenderers(renderingData.cullResults, ref layerDrawingSetting, ref filter);
}
CommandBufferPool.Release(cmd);
}
public async Task <(List <Car> adList, Response response)> GetSortedAds(SortingCriteria sortBy, bool sortAscending, int startIndex, int amount)
{
try
{
var result = await _api.GetSortedAdsAsync((int)sortBy, sortAscending, startIndex, amount);
return(GetCarList(result), Response.Ok);
}
catch (HttpOperationException)
{
return(null, Response.InvalidResponse);
}
catch (HttpRequestException)
{
NoServerResponse.Invoke();
return(null, Response.NoResponse);
}
}
public async Task <ActionResult <IEnumerable <OutgoingVehicleDTO> > > GetUserUploadedAds(
[Required] string username,
[FromHeader][DefaultValue(SortingCriteria.UploadDate)] SortingCriteria sortBy,
[FromHeader][DefaultValue(false)] bool sortAscending,
[FromHeader][DefaultValue(0)] int startIndex,
[FromHeader][DefaultValue(10)] int amount)
{
if (username == null)
{
return(BadRequest());
}
var ads = await _services.GetUserUploadedAds(username, sortBy, sortAscending, startIndex, amount);
return(ads == null?
NotFound() :
new ActionResult <IEnumerable <OutgoingVehicleDTO> >(ads));
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (layerMask == 0)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
SortingCriteria sortingCriteria = SortingCriteria.CommonTransparent;
var drawSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawSettings.perObjectData = PerObjectData.None;
drawSettings.overrideMaterial = depthOnlyMaterial;
ref CameraData cameraData = ref renderingData.cameraData;
protected DrawingSettings CreateDrawingSettings(Camera camera, SortingCriteria sortingCriteria, PerObjectData perObjectData, bool supportsDynamicBatching)
{
SortingSettings sortingSettings = new SortingSettings(camera)
{
criteria = sortingCriteria
};
DrawingSettings settings = new DrawingSettings(m_ShaderTagIDs[0], sortingSettings)
{
perObjectData = perObjectData,
enableInstancing = true,
enableDynamicBatching = supportsDynamicBatching
};
for (int i = 1; i < m_ShaderTagIDs.Count; ++i)
{
settings.SetShaderPassName(i, m_ShaderTagIDs[i]);
}
return(settings);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
// fetch a command buffer to use
CommandBuffer cmd = CommandBufferPool.Get(profilerTag);
cmd.Clear();
CoreUtils.SetRenderTarget(cmd, m_maskTexture.Identifier(), ClearFlag.All, Color.clear);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
drawingSettings.overrideMaterial = materialToBlit;
// Mask visible
drawingSettings.overrideMaterialPassIndex = (int)PassId.SelectionPassVisible;
context.DrawRenderers(renderingData.cullResults,
ref drawingSettings,
ref m_FilteringSettingsOpaque,
ref m_RenderStateBlock);
context.DrawRenderers(renderingData.cullResults,
ref drawingSettings,
ref m_FilteringSettingsTransparent,
ref m_RenderStateBlock);
cmd.SetGlobalColor(s_BlurDirection, new Color(1, 0, 0, 0));
cmd.Blit(m_maskTexture.id, m_blurTexture.id, materialToBlit, (int)PassId.SelectionPassBlur);
cmd.SetGlobalColor(s_BlurDirection, new Color(0, 1, 0, 0));
cmd.Blit(m_blurTexture.id, m_maskTexture.id, materialToBlit, (int)PassId.SelectionPassBlur);
cmd.Blit(m_maskTexture.id, source, materialToBlit, (int)PassId.SelectionPassOutline);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public async Task <ActionResult <IEnumerable <OutgoingVehicleDTO> > > GetUserLikedAds(
[Required] string username,
[FromHeader][DefaultValue(SortingCriteria.UploadDate)] SortingCriteria sortBy,
[FromHeader][DefaultValue(false)] bool sortAscending,
[FromHeader][DefaultValue(0)] int startIndex,
[FromHeader][DefaultValue(10)] int amount)
{
var user = HttpContext.User;
if (username == null || (!user.IsInRole(UserRole.Admin) && user.Identity.Name != username))
{
return(BadRequest());
}
var ads = await _services.GetUserLikedAds(username, sortBy, sortAscending, startIndex, amount);
return(ads == null?
NoContent() :
new ActionResult <IEnumerable <OutgoingVehicleDTO> >(ads));
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = (_renderQueueType == RenderQueueType.Transparent)
? SortingCriteria.CommonTransparent
: renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings =
CreateDrawingSettings(_shaderTagIdList, ref renderingData, sortingCriteria);
// NOTE: Do NOT mix ProfilingScope with named CommandBuffers i.e. CommandBufferPool.Get("name").
// Currently there's an issue which results in mismatched markers.
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, _profilingSampler))
{
//Write Depth
drawingSettings.overrideMaterial = WriteDepthMaterial;
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref _filteringSettings,
ref _renderStateBlock);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
DrawingSettings drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, m_ProfilingSampler))
{
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
if (isDeferred)
{
cmd.SetGlobalTexture("_CameraNormalsTexture", deferredLights.GbufferAttachmentIdentifiers[deferredLights.GBufferNormalSmoothnessIndex]);
}
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DBufferMRT1, m_Settings.surfaceData == DecalSurfaceData.Albedo);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DBufferMRT2, m_Settings.surfaceData == DecalSurfaceData.AlbedoNormal);
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DBufferMRT3, m_Settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS);
// TODO: This should be replace with mrt clear once we support it
// Clear render targets
ClearDBuffers(cmd, renderingData.cameraData);
// Split here allows clear to be executed before DrawRenderers
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
m_DrawSystem.Execute(cmd);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref m_FilteringSettings);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
