473 lines
23 KiB
C#
473 lines
23 KiB
C#
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.Universal;
|
|
using static Beautify.Universal.Beautify;
|
|
|
|
#if !UNITY_6000_4_OR_NEWER
|
|
namespace Beautify.Universal {
|
|
|
|
public partial class BeautifyRendererFeature {
|
|
|
|
#if UNITY_2022_1_OR_NEWER
|
|
#if UNITY_6000_2_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void SetupRenderPasses(ScriptableRenderer renderer,
|
|
in RenderingData renderingData) {
|
|
|
|
CameraData cameraData = renderingData.cameraData;
|
|
Camera cam = cameraData.camera;
|
|
if ((cameraLayerMask & (1 << cam.gameObject.layer)) == 0) return;
|
|
|
|
if (cam.targetTexture != null && cam.targetTexture.format == RenderTextureFormat.Depth) return; // ignore depth pre-pass cams!
|
|
|
|
m_BeautifyRenderPass.SetupRenderTargets(renderer);
|
|
m_BeautifyBloomLumMaskPass.SetupRenderTargets(renderer);
|
|
m_BeautifyAnamorphicFlaresLumMaskPass.SetupRenderTargets(renderer);
|
|
m_BeautifySharpenExclusionMaskPass.SetupRenderTargets(renderer);
|
|
}
|
|
#endif
|
|
|
|
partial class BeautifyRenderPass {
|
|
|
|
#if UNITY_2022_1_OR_NEWER
|
|
public void SetupRenderTargets(ScriptableRenderer renderer) {
|
|
BeautifyRenderPass.renderer = renderer;
|
|
#if UNITY_2022_2_OR_NEWER
|
|
#pragma warning disable CS0618
|
|
source = renderer.cameraColorTargetHandle;
|
|
#pragma warning restore CS0618
|
|
#else
|
|
source = renderer.cameraColorTarget;
|
|
#endif
|
|
}
|
|
#else
|
|
public override void OnCameraSetup (CommandBuffer cmd, ref RenderingData renderingData) {
|
|
source = renderer.cameraColorTarget;
|
|
}
|
|
#endif
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
|
|
if (bMat == null) return;
|
|
|
|
if (beautify == null) {
|
|
beautify = VolumeManager.instance.stack.GetComponent<Beautify>();
|
|
}
|
|
if (beautify == null || !beautify.IsActive()) return;
|
|
|
|
sourceDesc = cameraTextureDescriptor;
|
|
sourceDesc.msaaSamples = 1;
|
|
sourceDesc.depthBufferBits = 0;
|
|
|
|
if (beautify.downsampling.value) {
|
|
UniversalRenderPipelineAsset pipe = (UniversalRenderPipelineAsset)GraphicsSettings.currentRenderPipeline;
|
|
float downsamplingMultiplier = 1f / beautify.downsamplingMultiplier.value;
|
|
if (downsamplingMultiplier < 1f) {
|
|
DownsamplingMode mode = beautify.downsamplingMode.value;
|
|
if (mode == DownsamplingMode.BeautifyEffectsOnly) {
|
|
sourceDesc.width = (int)(sourceDesc.width * downsamplingMultiplier);
|
|
sourceDesc.height = (int)(sourceDesc.height * downsamplingMultiplier);
|
|
if (pipe.renderScale != 1f) {
|
|
pipe.renderScale = 1f;
|
|
}
|
|
}
|
|
else {
|
|
if (pipe.renderScale != downsamplingMultiplier) {
|
|
pipe.renderScale = downsamplingMultiplier;
|
|
beautify.downsamplingMultiplier.value = 1f / pipe.renderScale;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (pipe.renderScale != 1f) {
|
|
pipe.renderScale = 1f;
|
|
}
|
|
}
|
|
}
|
|
|
|
sourceDescHP = sourceDesc;
|
|
if (supportsFPTextures) {
|
|
sourceDescHP.colorFormat = RenderTextureFormat.ARGBHalf;
|
|
}
|
|
|
|
if (!beautify.ignoreDepthTexture.value) {
|
|
ConfigureInput(ScriptableRenderPassInput.Depth);
|
|
}
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
if (bMat == null) {
|
|
Debug.LogError("Beautify material not initialized.");
|
|
return;
|
|
}
|
|
|
|
Camera cam = cameraData.camera;
|
|
if (beautify == null || cam == null || !beautify.IsActive()) return;
|
|
|
|
#if !UNITY_2022_1_OR_NEWER
|
|
if (!usesDirectWriteToCamera) {
|
|
source = renderer.cameraColorTarget;
|
|
}
|
|
#endif
|
|
var cmd = CommandBufferPool.Get("Beautify");
|
|
|
|
passData.camera = cam;
|
|
passData.cmd = cmd;
|
|
|
|
ExecutePass(passData);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
}
|
|
|
|
partial class BeautifySharpenExclusionMaskPass {
|
|
|
|
#if UNITY_2022_1_OR_NEWER
|
|
public void SetupRenderTargets(ScriptableRenderer renderer) {
|
|
#if UNITY_2022_2_OR_NEWER
|
|
#pragma warning disable CS0618
|
|
depthRT = renderer.cameraDepthTargetHandle;
|
|
#pragma warning restore CS0618
|
|
#else
|
|
depthRT = renderer.cameraDepthTarget;
|
|
#endif
|
|
}
|
|
#else
|
|
public override void OnCameraSetup (CommandBuffer cmd, ref RenderingData renderingData) {
|
|
depthRT = renderingData.cameraData.renderer.cameraDepthTarget;
|
|
}
|
|
#endif
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
RenderTextureDescriptor maskDesc = cameraTextureDescriptor;
|
|
maskDesc.colorFormat = canUse16Bit ? RenderTextureFormat.RGB565 : RenderTextureFormat.ARGB32;
|
|
maskDesc.depthBufferBits = 0;
|
|
cmd.GetTemporaryRT(sharpenExclusionMaskId, maskDesc, FilterMode.Point);
|
|
cmd.SetGlobalTexture(sharpenExclusionMaskRT, sharpenExclusionMaskId);
|
|
ConfigureTarget(maskRT, depthRT);
|
|
ConfigureClear(ClearFlag.Color, Color.black);
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
SortingCriteria sortingCriteria = SortingCriteria.None;
|
|
var drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
|
|
var filter = new FilteringSettings(RenderQueueRange.all) { layerMask = BeautifySettings.sharpenExclusionMask };
|
|
#if UNITY_2023_1_OR_NEWER
|
|
CommandBuffer cmd = CommandBufferPool.Get("Beautify Sharpen Exclusion Mask");
|
|
RendererListParams listParams = new RendererListParams(renderingData.cullResults, drawingSettings, filter);
|
|
RendererList list = context.CreateRendererList(ref listParams);
|
|
cmd.DrawRendererList(list);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
#else
|
|
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filter);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
partial class BeautifyBloomLumMaskPass {
|
|
|
|
#if UNITY_2022_1_OR_NEWER
|
|
public void SetupRenderTargets(ScriptableRenderer renderer) {
|
|
#if UNITY_2022_2_OR_NEWER
|
|
#pragma warning disable CS0618
|
|
depthRT = renderer.cameraDepthTargetHandle;
|
|
#pragma warning restore CS0618
|
|
#else
|
|
depthRT = renderer.cameraDepthTarget;
|
|
#endif
|
|
}
|
|
#else
|
|
public override void OnCameraSetup (CommandBuffer cmd, ref RenderingData renderingData) {
|
|
depthRT = renderingData.cameraData.renderer.cameraDepthTarget;
|
|
}
|
|
#endif
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
RenderTextureDescriptor depthDesc = cameraTextureDescriptor;
|
|
depthDesc.colorFormat = RenderTextureFormat.ARGB32;
|
|
depthDesc.depthBufferBits = 0;
|
|
cmd.GetTemporaryRT(bloomSourceDepthId, depthDesc, FilterMode.Point);
|
|
cmd.SetGlobalTexture(bloomSourceDepthRT, bloomSourceDepthId);
|
|
if (BeautifySettings.anamorphicFlaresExcludeMask == BeautifySettings.bloomExcludeMask) {
|
|
cmd.SetGlobalTexture(BeautifyAnamorphicFlaresLumMaskPass.afSourceDepthRT, bloomSourceDepthId);
|
|
}
|
|
ConfigureTarget(maskRT, depthRT);
|
|
ConfigureClear(ClearFlag.Color, Color.black);
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
SortingCriteria sortingCriteria = SortingCriteria.None;
|
|
var drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
|
|
var filter = new FilteringSettings(RenderQueueRange.all) { layerMask = BeautifySettings.bloomExcludeMask };
|
|
#if UNITY_2023_1_OR_NEWER
|
|
CommandBuffer cmd = CommandBufferPool.Get("Beautify Luma Mask");
|
|
RendererListParams listParams = new RendererListParams(renderingData.cullResults, drawingSettings, filter);
|
|
RendererList list = context.CreateRendererList(ref listParams);
|
|
cmd.DrawRendererList(list);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
#else
|
|
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filter);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
partial class BeautifyAnamorphicFlaresLumMaskPass {
|
|
|
|
#if UNITY_2022_1_OR_NEWER
|
|
public void SetupRenderTargets(ScriptableRenderer renderer) {
|
|
#if UNITY_2022_2_OR_NEWER
|
|
#pragma warning disable CS0618
|
|
depthRT = renderer.cameraDepthTargetHandle;
|
|
#pragma warning restore CS0618
|
|
#else
|
|
depthRT = renderer.cameraDepthTarget;
|
|
#endif
|
|
}
|
|
#else
|
|
public override void OnCameraSetup (CommandBuffer cmd, ref RenderingData renderingData) {
|
|
depthRT = renderingData.cameraData.renderer.cameraDepthTarget;
|
|
}
|
|
#endif
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
RenderTextureDescriptor depthDesc = cameraTextureDescriptor;
|
|
depthDesc.colorFormat = RenderTextureFormat.ARGB32;
|
|
depthDesc.depthBufferBits = 0;
|
|
cmd.GetTemporaryRT(afSourceDepthId, depthDesc, FilterMode.Point);
|
|
cmd.SetGlobalTexture(afSourceDepthRT, afSourceDepthId);
|
|
ConfigureTarget(maskRT, depthRT);
|
|
ConfigureClear(ClearFlag.Color, Color.black);
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
SortingCriteria sortingCriteria = SortingCriteria.None;
|
|
var drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
|
|
var filter = new FilteringSettings(RenderQueueRange.all) { layerMask = BeautifySettings.anamorphicFlaresExcludeMask };
|
|
#if UNITY_2023_1_OR_NEWER
|
|
CommandBuffer cmd = CommandBufferPool.Get("AF Luma Mask");
|
|
RendererListParams listParams = new RendererListParams(renderingData.cullResults, drawingSettings, filter);
|
|
RendererList list = context.CreateRendererList(ref listParams);
|
|
cmd.DrawRendererList(list);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
#else
|
|
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filter);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
internal partial class BeautifyDoFTransparentMaskPass {
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
RenderTextureDescriptor depthDesc = cameraTextureDescriptor;
|
|
depthDesc.colorFormat = RenderTextureFormat.Depth;
|
|
depthDesc.depthBufferBits = 24;
|
|
depthDesc.msaaSamples = 1;
|
|
cmd.GetTemporaryRT(dofTransparentDepthId, depthDesc, FilterMode.Point);
|
|
cmd.SetGlobalTexture(dofTransparentDepthRT, dofTransparentDepthId);
|
|
ConfigureTarget(m_Depth);
|
|
ConfigureClear(ClearFlag.All, Color.black);
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
|
|
cmd.Clear();
|
|
|
|
if (BeautifySettings.dofAlphaTestSupport) {
|
|
if (BeautifySettings.dofAlphaTestLayerMask != 0) {
|
|
if (BeautifySettings.dofAlphaTestLayerMask != currentAlphaCutoutLayerMask || BeautifySettings._refreshAlphaClipRenderers) {
|
|
FindAlphaClippingRenderers();
|
|
}
|
|
if (depthOnlyMaterialCutOff == null) {
|
|
Shader depthOnlyCutOff = Shader.Find(m_DepthOnlyShader);
|
|
depthOnlyMaterialCutOff = new Material(depthOnlyCutOff);
|
|
}
|
|
int renderersCount = cutOutRenderers.Count;
|
|
if (depthOverrideMaterials == null || depthOverrideMaterials.Length < renderersCount) {
|
|
depthOverrideMaterials = new Material[renderersCount];
|
|
}
|
|
for (int k = 0; k < renderersCount; k++) {
|
|
Renderer renderer = cutOutRenderers[k];
|
|
if (renderer != null && renderer.isVisible) {
|
|
Material mat = renderer.sharedMaterial;
|
|
if (mat != null) {
|
|
if (depthOverrideMaterials[k] == null) {
|
|
depthOverrideMaterials[k] = Instantiate(depthOnlyMaterialCutOff);
|
|
depthOverrideMaterials[k].EnableKeyword(ShaderParams.SKW_CUSTOM_DEPTH_ALPHA_TEST);
|
|
}
|
|
Material overrideMaterial = depthOverrideMaterials[k];
|
|
|
|
if (mat.HasProperty(ShaderParams.CustomDepthAlphaCutoff)) {
|
|
overrideMaterial.SetFloat(ShaderParams.CustomDepthAlphaCutoff, mat.GetFloat(ShaderParams.CustomDepthAlphaCutoff));
|
|
}
|
|
else {
|
|
overrideMaterial.SetFloat(ShaderParams.CustomDepthAlphaCutoff, 0.5f);
|
|
}
|
|
if (mat.HasProperty(ShaderParams.CustomDepthBaseMap)) {
|
|
overrideMaterial.SetTexture(ShaderParams.CustomDepthBaseMap, mat.GetTexture(ShaderParams.CustomDepthBaseMap));
|
|
}
|
|
else if (mat.HasProperty(ShaderParams.mainTex)) {
|
|
overrideMaterial.SetTexture(ShaderParams.CustomDepthBaseMap, mat.GetTexture(ShaderParams.mainTex));
|
|
}
|
|
overrideMaterial.SetInt(m_CullPropertyId, BeautifySettings.dofAlphaTestDoubleSided ? (int)CullMode.Off : (int)CullMode.Back);
|
|
|
|
cmd.DrawRenderer(renderer, overrideMaterial);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// Render transparent objects
|
|
if (BeautifySettings.dofTransparentSupport) {
|
|
if (depthOnlyMaterial == null) {
|
|
depthOnlyMaterial = new Material(Shader.Find(m_DepthOnlyShader));
|
|
}
|
|
depthOnlyMaterial.SetInt(m_CullPropertyId, BeautifySettings.dofTransparentDoubleSided ? (int)CullMode.Off : (int)CullMode.Back);
|
|
|
|
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
|
|
var drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
|
|
drawingSettings.perObjectData = PerObjectData.None;
|
|
drawingSettings.overrideMaterial = depthOnlyMaterial;
|
|
var filter = new FilteringSettings(RenderQueueRange.transparent) { layerMask = BeautifySettings.dofTransparentLayerMask };
|
|
#if UNITY_2023_1_OR_NEWER
|
|
RendererListParams listParams = new RendererListParams(renderingData.cullResults, drawingSettings, filter);
|
|
RendererList list = context.CreateRendererList(ref listParams);
|
|
cmd.DrawRendererList(list);
|
|
#else
|
|
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filter);
|
|
#endif
|
|
}
|
|
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
}
|
|
|
|
partial class BeautifyOutlineDepthPrepass {
|
|
|
|
public override void Configure (CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor) {
|
|
RenderTextureDescriptor depthDesc = cameraTextureDescriptor;
|
|
depthDesc.colorFormat = BeautifySettings.outlineUseObjectId ? RenderTextureFormat.RFloat : RenderTextureFormat.Depth;
|
|
depthDesc.depthBufferBits = 24;
|
|
depthDesc.msaaSamples = 1;
|
|
cmd.GetTemporaryRT(outlineDepthId, depthDesc, FilterMode.Point);
|
|
if (BeautifySettings.outlineUseObjectId) {
|
|
cmd.SetGlobalTexture(outlineObjectIdRT, outlineDepthId, RenderTextureSubElement.Color);
|
|
cmd.SetGlobalTexture(outlineDepthRT, outlineDepthId, RenderTextureSubElement.Depth);
|
|
}
|
|
else {
|
|
cmd.SetGlobalTexture(outlineDepthRT, outlineDepthId);
|
|
}
|
|
#if UNITY_2022_2_OR_NEWER
|
|
ConfigureTarget(outlineDepthHandle);
|
|
#else
|
|
RenderTargetIdentifier rti = new RenderTargetIdentifier(outlineDepthId, 0, CubemapFace.Unknown, -1);
|
|
ConfigureTarget(rti);
|
|
#endif
|
|
if (BeautifySettings.outlineUseObjectId) {
|
|
ConfigureClear(ClearFlag.Depth | ClearFlag.Color, Color.black);
|
|
}
|
|
else {
|
|
ConfigureClear(ClearFlag.Depth, Color.black);
|
|
}
|
|
}
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
if (!BeautifySettings.outlineDepthPrepass) return;
|
|
|
|
SortingCriteria sortingCriteria = renderingData.cameraData.defaultOpaqueSortFlags;
|
|
var drawingSettings = CreateDrawingSettings(m_ShaderTagIdList, ref renderingData, sortingCriteria);
|
|
drawingSettings.perObjectData = PerObjectData.None;
|
|
|
|
if (BeautifySettings.outlineDepthPrepassUseOptimizedShader) {
|
|
#if UNITY_2022_3_OR_NEWER
|
|
if (BeautifySettings.outlineLayerCutOff > 0) {
|
|
Shader alphaTestShader = null;
|
|
if (BeautifySettings.outlineUseObjectId) {
|
|
if (depthOnlyShaderWithAlphaTestObjectId == null) {
|
|
depthOnlyShaderWithAlphaTestObjectId = Shader.Find(m_DepthOnlyWithObjectIdAlphaTestShader);
|
|
}
|
|
alphaTestShader = depthOnlyShaderWithAlphaTestObjectId;
|
|
} else {
|
|
if (depthOnlyShaderWithAlphaTest == null) {
|
|
depthOnlyShaderWithAlphaTest = Shader.Find(m_DepthOnlyAlphaTestShader);
|
|
}
|
|
alphaTestShader = depthOnlyShaderWithAlphaTest;
|
|
}
|
|
drawingSettings.overrideShader = alphaTestShader;
|
|
Shader.SetGlobalFloat(ShaderParams.CustomDepthAlphaTestCutoff, BeautifySettings.outlineLayerCutOff);
|
|
} else
|
|
#endif
|
|
{
|
|
Material depthMaterial = null;
|
|
if (BeautifySettings.outlineUseObjectId) {
|
|
if (depthOnlyMaterialWithObjectId == null) {
|
|
depthOnlyMaterialWithObjectId = new Material(Shader.Find(m_DepthOnlyWithObjectIdShader));
|
|
}
|
|
depthMaterial = depthOnlyMaterialWithObjectId;
|
|
}
|
|
else {
|
|
if (depthOnlyMaterial == null) {
|
|
depthOnlyMaterial = new Material(Shader.Find(m_DepthOnlyShader));
|
|
}
|
|
depthMaterial = depthOnlyMaterial;
|
|
}
|
|
depthMaterial.SetInt(m_CullPropertyId, (int)CullMode.Back);
|
|
depthMaterial.DisableKeyword(ShaderParams.SKW_CUSTOM_DEPTH_ALPHA_TEST);
|
|
drawingSettings.overrideMaterial = depthMaterial;
|
|
}
|
|
}
|
|
|
|
var filter = new FilteringSettings(RenderQueueRange.opaque) { layerMask = BeautifySettings.outlineLayerMask };
|
|
#if UNITY_2023_1_OR_NEWER
|
|
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
|
|
cmd.Clear();
|
|
RendererListParams listParams = new RendererListParams(renderingData.cullResults, drawingSettings, filter);
|
|
RendererList list = context.CreateRendererList(ref listParams);
|
|
cmd.DrawRendererList(list);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
#else
|
|
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filter);
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
partial class BeautifyClearColorTarget {
|
|
|
|
public override void Execute (ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
|
|
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
|
|
cmd.ClearRenderTarget(false, true, new Color(0, 0, 0, 0));
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
}
|
|
|
|
partial class BeautifyOutlineEffectPass {
|
|
|
|
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData) {
|
|
if (!BeautifyRenderPass.CanExecuteOutlineBeforeTransparents) return;
|
|
|
|
CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);
|
|
BeautifyRenderPass.ExecuteOutlineBeforeTransparents(cmd);
|
|
context.ExecuteCommandBuffer(cmd);
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|