public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
CommandBuffer cmd = CommandBufferPool.Get(k_CopyColorTag);
Downsampling downsampling = renderingData.cameraData.opaqueTextureDownsampling;
float opaqueScaler = m_OpaqueScalerValues[(int)downsampling];
RenderTextureDescriptor opaqueDesc = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData, opaqueScaler);
RenderTargetIdentifier colorRT = source.Identifier();
RenderTargetIdentifier opaqueColorRT = destination.Identifier();
cmd.GetTemporaryRT(destination.id, opaqueDesc, renderingData.cameraData.opaqueTextureDownsampling == Downsampling.None ? FilterMode.Point : FilterMode.Bilinear);
switch (downsampling)
{
case Downsampling.None:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._2xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._4xBox:
Material samplingMaterial = renderer.GetMaterial(MaterialHandles.Sampling);
samplingMaterial.SetFloat(m_SampleOffsetShaderHandle, 2);
cmd.Blit(colorRT, opaqueColorRT, samplingMaterial, 0);
break;
case Downsampling._4xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
Material material = renderingData.cameraData.isStereoEnabled ? null : renderer.GetMaterial(MaterialHandles.Blit);
RenderTargetIdentifier sourceRT = colorAttachmentHandle.Identifier();
CommandBuffer cmd = CommandBufferPool.Get(k_FinalBlitTag);
cmd.SetGlobalTexture("_BlitTex", sourceRT);
// We need to handle viewport on a RT. We do it by rendering a fullscreen quad + viewport
if (!renderingData.cameraData.isDefaultViewport)
{
SetRenderTarget(
cmd,
BuiltinRenderTextureType.CameraTarget,
RenderBufferLoadAction.DontCare,
RenderBufferStoreAction.Store,
ClearFlag.None,
Color.black,
descriptor.dimension);
cmd.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
cmd.SetViewport(renderingData.cameraData.camera.pixelRect);
ScriptableRenderer.RenderFullscreenQuad(cmd, material);
}
else
{
cmd.Blit(colorAttachmentHandle.Identifier(), BuiltinRenderTextureType.CameraTarget, material);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
// Restore Render target for additional editor rendering.
// Note: Scene view camera always perform depth prepass
CommandBuffer cmd = CommandBufferPool.Get(k_CopyDepthToCameraTag);
CoreUtils.SetRenderTarget(cmd, BuiltinRenderTextureType.CameraTarget);
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
cmd.EnableShaderKeyword(LightweightKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(LightweightKeywordStrings.DepthMsaa4);
cmd.Blit(source.Identifier(), BuiltinRenderTextureType.CameraTarget, renderer.GetMaterial(MaterialHandles.DepthCopy));
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_DepthCopyTag);
RenderTargetIdentifier depthSurface = source.Identifier();
RenderTargetIdentifier copyDepthSurface = destination.Identifier();
Material depthCopyMaterial = renderer.GetMaterial(MaterialHandle.CopyDepth);
RenderTextureDescriptor descriptor = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
descriptor.colorFormat = RenderTextureFormat.Depth;
descriptor.depthBufferBits = 32; //TODO: fix this ;
descriptor.msaaSamples = 1;
descriptor.bindMS = false;
cmd.GetTemporaryRT(destination.id, descriptor, FilterMode.Point);
cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());
cmd.SetGlobalTexture("_CameraDepthTexture", source.Identifier());
if (renderingData.cameraData.msaaSamples > 1)
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
if (renderingData.cameraData.msaaSamples == 4)
{
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
}
else
{
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
}
cmd.Blit(depthSurface, copyDepthSurface, depthCopyMaterial);
}
else
{
cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthNoMsaa);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
ScriptableRenderer.CopyTexture(cmd, depthSurface, copyDepthSurface, depthCopyMaterial);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(k_Tag);
Downsampling downsampling = renderingData.cameraData.opaqueTextureDownsampling;
float opaqueScaler = m_OpaqueScalerValues[(int)downsampling];
RenderTextureDescriptor opaqueDesc = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData, opaqueScaler);
RenderTargetIdentifier colorRT = source.Identifier();
RenderTargetIdentifier opaqueColorRT = destination.Identifier();
cmd.GetTemporaryRT(destination.id, opaqueDesc, renderingData.cameraData.opaqueTextureDownsampling == Downsampling.None ? FilterMode.Point : FilterMode.Bilinear);
switch (downsampling)
{
case Downsampling.None:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._2xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
case Downsampling._4xBox:
Material samplingMaterial = renderer.GetMaterial(MaterialHandle.Sampling);
samplingMaterial.SetFloat(m_SampleOffsetShaderHandle, 2);
cmd.Blit(colorRT, opaqueColorRT, samplingMaterial, 0);
break;
case Downsampling._4xBilinear:
cmd.Blit(colorRT, opaqueColorRT);
break;
}
//resume render target
RenderBufferLoadAction loadOp = RenderBufferLoadAction.Load;
RenderBufferStoreAction storeOp = RenderBufferStoreAction.Store;
SetRenderTarget(cmd, source.Identifier(), loadOp, storeOp,
depth.Identifier(), loadOp, storeOp, ClearFlag.None, Color.black, baseDescriptor.dimension);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
protected void RenderObjectsWithError(ScriptableRenderer renderer, ref ScriptableRenderContext context, ref CullResults cullResults, Camera camera, FilterRenderersSettings filterSettings, SortFlags sortFlags)
{
Material errorMaterial = renderer.GetMaterial(MaterialHandles.Error);
if (errorMaterial != null)
{
DrawRendererSettings errorSettings = new DrawRendererSettings(camera, m_LegacyShaderPassNames[0]);
for (int i = 1; i < m_LegacyShaderPassNames.Count; ++i)
{
errorSettings.SetShaderPassName(i, m_LegacyShaderPassNames[i]);
}
errorSettings.sorting.flags = sortFlags;
errorSettings.rendererConfiguration = RendererConfiguration.None;
errorSettings.SetOverrideMaterial(errorMaterial, 0);
context.DrawRenderers(cullResults.visibleRenderers, ref errorSettings, filterSettings);
}
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (renderingData.lightData.mainLightIndex == -1)
{
return;
}
CommandBuffer cmd = CommandBufferPool.Get(k_CollectShadowsTag);
cmd.GetTemporaryRT(colorAttachmentHandle.id, descriptor, FilterMode.Bilinear);
VisibleLight shadowLight = renderingData.lightData.visibleLights[renderingData.lightData.mainLightIndex];
SetShadowCollectPassKeywords(cmd, ref shadowLight, ref renderingData.shadowData);
// Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
// doesn't like null sources when trying to determine a stereo-ized blit. So for proper
// stereo functionality, we use the screen-space shadow map as the source (until we have
// a better solution).
// An alternative would be DrawProcedural, but that would require further changes in the shader.
RenderTargetIdentifier screenSpaceOcclusionTexture = colorAttachmentHandle.Identifier();
SetRenderTarget(cmd, screenSpaceOcclusionTexture, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.white, descriptor.dimension);
cmd.Blit(screenSpaceOcclusionTexture, screenSpaceOcclusionTexture, renderer.GetMaterial(MaterialHandle.ScreenSpaceShadow));
if (renderingData.cameraData.isStereoEnabled)
{
Camera camera = renderingData.cameraData.camera;
context.StartMultiEye(camera);
context.ExecuteCommandBuffer(cmd);
context.StopMultiEye(camera);
}
else
{
context.ExecuteCommandBuffer(cmd);
}
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
var cmd = CommandBufferPool.Get(k_Tag);
var colorRT = source.Identifier();
var opaqueColorRT = destination.Identifier();
var inter = intermediate.Identifier();
if (SystemInfo.graphicsUVStartsAtTop)
{
var colorDescriptor = descriptor;
colorDescriptor.depthBufferBits = 0;
colorDescriptor.msaaSamples = (int)sampleCount;
cmd.GetTemporaryRT(intermediate.id, colorDescriptor, FilterMode.Point);
cmd.SetGlobalVector(UVTransformID, new Vector4(1.0f, -1.0f, 0.0f, 1.0f));
var mat = renderer.GetMaterial(MaterialHandle.BlitFlip);
cmd.Blit(colorRT, inter);
cmd.SetGlobalTexture("_MainTex", inter);
cmd.Blit(inter, opaqueColorRT, mat);
if (Status.Valid)
{
Status.CodePath = "Flip";
cmd.Blit(colorRT, Status.Blit0.texture);
cmd.Blit(inter, Status.Blit1.texture);
cmd.Blit(opaqueColorRT, Status.Blit2.texture);
}
}
else
{
if (sampleCount == SampleCount.One)
{
cmd.Blit(colorRT, opaqueColorRT);
if (Status.Valid)
{
Status.CodePath = "Direct";
cmd.Blit(colorRT, Status.Blit0.texture);
cmd.Blit(opaqueColorRT, Status.Blit2.texture);
}
}
else
{
var colorDescriptor = descriptor;
colorDescriptor.depthBufferBits = 0;
colorDescriptor.msaaSamples = 1;
cmd.GetTemporaryRT(intermediate.id, colorDescriptor, FilterMode.Point);
cmd.Blit(colorRT, inter);
cmd.SetGlobalTexture("_MainTex", inter);
cmd.Blit(inter, opaqueColorRT);
if (Status.Valid)
{
Status.CodePath = "MSAA";
cmd.Blit(colorRT, Status.Blit0.texture);
cmd.Blit(inter, Status.Blit1.texture);
cmd.Blit(opaqueColorRT, Status.Blit2.texture);
}
}
}
cmd.ReleaseTemporaryRT(intermediate.id);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(_kRenderOITTag);
using (new ProfilingSample(cmd, _kRenderOITTag))
{
cmd.GetTemporaryRT(_AccumColorHandle.id, _DescriptorAC);
cmd.GetTemporaryRT(_AccumGIHandle.id, _DescriptorAC);
cmd.GetTemporaryRT(_AccumAlphaHandle.id, _DescriptorAA);
cmd.SetRenderTarget(_AccumBinding);
cmd.ClearRenderTarget(false, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Camera camera = renderingData.cameraData.camera;
var drawSettings = CreateDrawRendererSettings(camera, SortFlags.None, _RendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
//cmd.SetGlobalTexture("_AccumColor", _AccumColorHandle.Identifier());
//cmd.SetGlobalTexture("_AccumAlpha", _AccumAlphaHandle.Identifier());
RenderBufferLoadAction loadOp = RenderBufferLoadAction.Load;
RenderBufferStoreAction storeOp = RenderBufferStoreAction.Store;
SetRenderTarget(cmd, _ColorAttachmentHandle.Identifier(), loadOp, storeOp,
_DepthAttachmentHandle.Identifier(), loadOp, storeOp, ClearFlag.None, Color.black, _Descriptor.dimension);
cmd.Blit(_ColorAttachmentHandle.Identifier(), _ColorAttachmentHandle.Identifier(), renderer.GetMaterial(MaterialHandle.OITComposite));
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
CommandBuffer cmd = CommandBufferPool.Get(_kRenderOITTag);
using (new ProfilingSample(cmd, _kRenderOITTag))
{
cmd.GetTemporaryRT(_B0Handle.id, _DescriptorFloat);
cmd.GetTemporaryRT(_B1Handle.id, _DescriptorFloat4);
if (MomentsCount._8 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat4);
}
else if (MomentsCount._6 == _MomentsCount)
{
cmd.GetTemporaryRT(_B2Handle.id, _DescriptorFloat2);
}
CoreUtils.SetKeyword(cmd, "_MOMENT6", MomentsCount._6 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT8", MomentsCount._8 == _MomentsCount);
CoreUtils.SetKeyword(cmd, "_MOMENT_HALF_PRECISION", FloatPrecision._Half == _MomentsPrecision);
CoreUtils.SetKeyword(cmd, "_TRIGONOMETRIC", _Trigonometric);
cmd.SetRenderTarget(_GMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
Vector2 logViewDepthMinDelta = new Vector2(Mathf.Log(_ViewDepthMinMax.x), Mathf.Log(_ViewDepthMinMax.y));
logViewDepthMinDelta.y = logViewDepthMinDelta.y - logViewDepthMinDelta.x;
cmd.SetGlobalVector("_LogViewDepthMinDelta", logViewDepthMinDelta);
//cmd.SetGlobalFloat("_Overestimation", 0.25f);
//cmd.SetGlobalFloat("_MomentBias", 0);
if (_Trigonometric)
{
Vector4 _WrappingZoneParameters = new Vector4();
_WrappingZoneParameters.x = 3.14f;
_WrappingZoneParameters.y = 3.14f - 0.5f * _WrappingZoneParameters.x;
float a = _WrappingZoneParameters.y * 2;
float x = Mathf.Cos(a);
float y = Mathf.Sin(a);
float r = Mathf.Abs(y) - Mathf.Abs(x);
r = (x < 0) ? (2.0f - r) : r;
r = (y < 0) ? (6.0f - r) : r;
_WrappingZoneParameters.z = 1 / (7 - r);
_WrappingZoneParameters.w = 1 - 7 * _WrappingZoneParameters.z;
cmd.SetGlobalVector("_WrappingZoneParameters", _WrappingZoneParameters);
}
Camera camera = renderingData.cameraData.camera;
var drawSettings = CreateDrawRendererSettings(camera, SortFlags.None, _RendererConfiguration, renderingData.supportsDynamicBatching);
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.GetTemporaryRT(_MOITHandle.id, _Descriptor);
if (renderingData.shadowData.supportsDeepShadowMaps)
{
cmd.GetTemporaryRT(_GIALHandle.id, _Descriptor);
cmd.SetRenderTarget(_RMBinding);
cmd.ClearRenderTarget(false, true, Color.black);
}
else
{
CoreUtils.SetRenderTarget(cmd,
_MOITHandle.Identifier(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
_DepthAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.DontCare,
ClearFlag.Color, Color.black);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalTexture("_b0", _B0Handle.id);
cmd.SetGlobalTexture("_b1", _B1Handle.id);
if (MomentsCount._4 != _MomentsCount)
{
cmd.SetGlobalTexture("_b2", _B2Handle.id);
}
drawSettings.SetShaderPassName(0, new ShaderPassName("ResolveMoments"));
context.DrawRenderers(renderingData.cullResults.visibleRenderers, ref drawSettings, _OITFilterSettings);
// Render objects that did not match any shader pass with error shader
renderer.RenderObjectsWithError(context, ref renderingData.cullResults, camera, _OITFilterSettings, SortFlags.None);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CoreUtils.SetRenderTarget(cmd,
_ColorAttachmentHandle.Identifier(), RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
ClearFlag.None);
cmd.Blit(_ColorAttachmentHandle.Identifier(), _ColorAttachmentHandle.Identifier(), renderer.GetMaterial(MaterialHandle.MomentOITComposite));
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
/// <inheritdoc/>
public override void Execute(ScriptableRenderer renderer, ScriptableRenderContext context, ref RenderingData renderingData)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (!renderingData.shadowData.supportsDeepShadowMaps)
{
return;
}
LightData lightData = renderingData.lightData;
int shadowLightIndex = lightData.mainLightIndex;
if (shadowLightIndex == -1)
{
return;
}
VisibleLight shadowLight = lightData.visibleLights[shadowLightIndex];
ShadowData shadowData = renderingData.shadowData;
RenderTargetIdentifier result;
CommandBuffer cmd = CommandBufferPool.Get(k_RenderScreenSpaceDeepShadowMaps);
using (new ProfilingSample(cmd, k_RenderScreenSpaceDeepShadowMaps))
{
#if UNITY_EDITOR
var testDescriptor = _Descriptor;
testDescriptor.enableRandomWrite = true;
testDescriptor.colorFormat = RenderTextureFormat.ARGB32;
cmd.GetTemporaryRT(_DeepShadowTest.id, testDescriptor);
var _ResetCompute = renderer.GetCompute(ComputeHandle.ResetDeepShadowDataCompute);
int KernelTestDeepShadowMap = _ResetCompute.FindKernel("KernelTestDeepShadowMap");
cmd.SetRenderTarget(_DeepShadowTest.Identifier());
cmd.SetComputeBufferParam(_ResetCompute, KernelTestDeepShadowMap, "_CountBuffer", _CountBuffer);
cmd.SetComputeBufferParam(_ResetCompute, KernelTestDeepShadowMap, "_DataBuffer", _DataBuffer);
cmd.SetComputeTextureParam(_ResetCompute, KernelTestDeepShadowMap, "_TestRt", _DeepShadowTest.Identifier());
cmd.DispatchCompute(_ResetCompute, KernelTestDeepShadowMap, shadowData.deepShadowMapsSize / 8, shadowData.deepShadowMapsSize / 8, 1);
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
#endif
// Resolve
Material ssdsm = renderer.GetMaterial(MaterialHandle.ScreenSpaceDeepShadowMaps);
ssdsm.SetBuffer(Shader.PropertyToID("_CountBuffer"), _CountBuffer);
ssdsm.SetBuffer(Shader.PropertyToID("_DataBuffer"), _DataBuffer);
cmd.GetTemporaryRT(_DeepShadowLut.id, _Descriptor);
RenderTargetIdentifier lutId = _DeepShadowLut.Identifier();
SetRenderTarget(cmd, lutId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.black, _Descriptor.dimension);
cmd.Blit(lutId, lutId, ssdsm);
result = lutId;
// Blur
int blurOffset = shadowData.deepShadowMapsBlurOffset;
if (blurOffset > 0)
{
Material pom = renderer.GetMaterial(MaterialHandle.GaussianBlur);
cmd.GetTemporaryRT(_DeepShadowTmp.id, _Descriptor);
RenderTargetIdentifier src = lutId;
RenderTargetIdentifier dst = _DeepShadowTmp.Identifier();
while (blurOffset > 0)
{
pom.SetFloat("_SampleOffset", blurOffset);
SetRenderTarget(cmd, dst, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
ClearFlag.Color | ClearFlag.Depth, Color.black, _Descriptor.dimension);
cmd.Blit(src, dst, pom);
result = dst;
dst = src;
src = result;
blurOffset >>= 1;
}
}
//TODO : for stereo
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
cmd.SetGlobalTexture(_Destination.id, result);
cmd.ReleaseTemporaryRT(_DeepShadowTest.id);
}
//SetKeyword
CoreUtils.SetKeyword(cmd, ShaderKeywordStrings.DeepShadowMaps, true);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
