void ToneMapping(CommandBuffer cb, RenderTargetIdentifier sourceId, RenderTargetIdentifier destinationId)
{
cb.BeginSample("Tone Mapping");
cb.SetGlobalFloat("_ReinhardModifier", 1f / (toneMappingRange * toneMappingRange));
Blit(cb, sourceId, destinationId, Pass.ToneMapping);
cb.EndSample("Tone Mapping");
}
void RenderDirectionalShadows()
{
int atlasSize = (int)settings.directional.atlasSize;
buffer.GetTemporaryRT(dirShadowAtlasId, atlasSize, atlasSize, 32, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
buffer.SetRenderTarget(dirShadowAtlasId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
buffer.ClearRenderTarget(true, false, Color.clear);
buffer.BeginSample(bufferName);
ExecuteBuffer();
int tiles = ShadowedDirectionalLightCount * settings.directional.cascadeCount;
int split = tiles <= 1 ? 1 : tiles <= 4 ? 2 : 4;
int tileSize = atlasSize / split;
for (int i = 0; i < ShadowedDirectionalLightCount; i++)
{
RenderDirectionalShadows(i, split, tileSize);
}
// constants
buffer.SetGlobalInt(cascadeCountId, settings.directional.cascadeCount);
buffer.SetGlobalVectorArray(cascadeCullingSpheresId, cascadeCullingSpheres);
buffer.SetGlobalVectorArray(cascadeDataId, cascadeData);
buffer.SetGlobalMatrixArray(dirShadowMatricesId, dirShadowMatrices);
float f = 1f - settings.directional.cascadeFade;
buffer.SetGlobalVector(shadowDistanceFadeId, new Vector4(
1f / settings.maxDistance, 1f / settings.distanceFade,
1f / (1f - f * f)));
SetKeywords(directionalFilterKeywords, (int)settings.directional.filter - 1);
SetKeywords(cascadeBlendKeywords, (int)settings.directional.cascadeBlend - 1);
buffer.SetGlobalVector(shadowAtlasSizeId, new Vector4(atlasSize, 1f / atlasSize));
buffer.EndSample(bufferName);
ExecuteBuffer();
}
public int CaptureScreen(int id)
{
if (commandBuffer == null)
{
commandBuffer = new CommandBuffer();
commandBuffer.name = "ScreenCapture";
}
commandBuffer.Clear();
for (int i = 0; i < FRAME_NUM; ++i)
{
if (!IsAvailable(i))
{
continue;
}
frames[i].id = id;
this.WriteToTagInfo(id, 0);
this.WriteToTagInfoShort(Screen.width, 8);
this.WriteToTagInfoShort(Screen.height, 10);
Profiler.EmitFrameMetaData(ScreenShotToProfiler.MetadataGuid, ScreenShotToProfiler.InfoTag, tagInfo);
var rt = RenderTexture.GetTemporary(Screen.width, Screen.height, 0, RenderTextureFormat.ARGB32);
ScreenCapture.CaptureScreenshotIntoRenderTexture(rt);
commandBuffer.BeginSample(CAPTURE_CMD_SAMPLE);
commandBuffer.Blit(rt, frames[i].renderTexture);
commandBuffer.EndSample(CAPTURE_CMD_SAMPLE);
Graphics.ExecuteCommandBuffer(commandBuffer);
RenderTexture.ReleaseTemporary(rt);
commandBuffer.Clear();
return(i);
}
return(-1);
}
static public void RenderLightVolumes(Camera camera, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTarget, RenderTargetIdentifier depthTarget, uint blendStylesUsed)
{
for (int i = 0; i < s_BlendStyles.Length; ++i)
{
if ((blendStylesUsed & (uint)(1 << i)) == 0)
{
continue;
}
string sampleName = s_BlendStyles[i].name;
cmdBuffer.BeginSample(sampleName);
RenderLightVolumeSet(
camera,
i,
cmdBuffer,
layerToRender,
renderTarget,
depthTarget,
Light2D.GetLightsByBlendStyle(i)
);
cmdBuffer.EndSample(sampleName);
}
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
TimeX += Time.deltaTime;
if (TimeX > 100)
{
TimeX = 0;
}
sheet.properties.SetVector(ShaderIDs.Params, new Vector3(TimeX * settings.Speed, settings.Amount, settings.Fade));
sheet.properties.SetVector(ShaderIDs.Params2, new Vector4(settings.BlockLayer1_U, settings.BlockLayer1_V, settings.BlockLayer2_U, settings.BlockLayer2_V));
sheet.properties.SetVector(ShaderIDs.Params3, new Vector3(settings.RGBSplitIndensity, settings.BlockLayer1_Indensity, settings.BlockLayer2_Indensity));
if (settings.BlockVisualizeDebug)
{
//debug
cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, 1);
}
else
{
cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
}
cmd.EndSample(PROFILER_TAG);
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
UpdateNoiseTexture(settings.frequncy, settings.noiseTextureWidth, settings.noiseTextureHeight, settings.stripeLength);
sheet.properties.SetFloat(ShaderIDs.indensity, settings.intensity);
if (_noiseTexture != null)
{
sheet.properties.SetTexture(ShaderIDs.noiseTex, _noiseTexture);
}
if (settings.needStripColorAdjust == true)
{
sheet.EnableKeyword("NEED_TRASH_FRAME");
sheet.properties.SetColor(ShaderIDs.StripColorAdjustColor, settings.StripColorAdjustColor);
sheet.properties.SetFloat(ShaderIDs.StripColorAdjustIndensity, settings.StripColorAdjustIndensity);
}
else
{
sheet.DisableKeyword("NEED_TRASH_FRAME");
}
context.command.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
cmd.EndSample(PROFILER_TAG);
}
void DrawOpaque(ref ScriptableRenderContext context, Camera camera, ref CullingResults cullingResults)
{
buffer.BeginSample("Opaque");
var sortingSettings = new SortingSettings(camera);
sortingSettings.criteria = SortingCriteria.CommonOpaque;
var drawSettings = new DrawingSettings(ShaderPassTags.Forward, sortingSettings)
{
enableDynamicBatching = true,
enableInstancing = true,
perObjectData = PerObjectData.Lightmaps | PerObjectData.LightProbe
};
var filterSettings = FilteringSettings.defaultValue;
filterSettings.renderQueueRange = RenderQueueRange.opaque;
filterSettings.layerMask = ~0;
RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Nothing);
context.DrawRenderers(cullingResults, ref drawSettings, ref filterSettings);
buffer.EndSample("Opaque");
context.ExecuteCommandBuffer(buffer);
buffer.Clear();
}
void Blur(CommandBuffer cb, int cameraColorId, int width, int height)
{
cb.BeginSample("Blur");
if (blurStrength == 1)
{
Blit(
cb, cameraColorId, BuiltinRenderTextureType.CameraTarget, Pass.Blur
);
cb.EndSample("Blur");
return;
}
cb.GetTemporaryRT(tempTexId, width, height, 0, FilterMode.Bilinear);
int passesLeft;
for (passesLeft = blurStrength; passesLeft > 2; passesLeft -= 2)
{
Blit(cb, cameraColorId, tempTexId, Pass.Blur);
Blit(cb, tempTexId, cameraColorId, Pass.Blur);
}
if (passesLeft > 1)
{
Blit(cb, cameraColorId, tempTexId, Pass.Blur);
Blit(cb, tempTexId, BuiltinRenderTextureType.CameraTarget, Pass.Blur);
}
else
{
Blit(
cb, cameraColorId, BuiltinRenderTextureType.CameraTarget, Pass.Blur
);
}
cb.ReleaseTemporaryRT(tempTexId);
cb.EndSample("Blur");
}
void RenderDirectionalShadows()
{
int atlasSize = (int)shadowSettings.directional.atlasSize;
///First is the amount of bits for the depth buffer. We want this to be as high as possible, so let's use 32.
///Second is the filter mode, for which we use the default bilinear filtering.
///Third is the render texture type, which has to be RenderTextureFormat.Shadowmap.
///This gives us a texture suitable for rendering shadow maps, though the exact format depends on the target platform.
buffer.GetTemporaryRT(dirShadowAtlasId, atlasSize, atlasSize, 32, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
///We don't care about its initial state as we'll immediately clear it, so we'll use RenderBufferLoadAction.DontCare.
///And the purpose of the texture is to contain the shadow data, so we'll need to use RenderBufferStoreAction.Store as the third argument.
buffer.SetRenderTarget(dirShadowAtlasId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
buffer.ClearRenderTarget(true, false, Color.clear);
buffer.BeginSample(bufferName);
ExecuteBuffer();
for (int i = 0; i < ShadowedDirectionalLightCount; i++)
{
RenderDirectionalShadows(i, atlasSize);
}
buffer.EndSample(bufferName);
ExecuteBuffer();
}
public void RenderDirectionalShadows()
{
int atlasSize = (int)shadowParams.settings.directional.atlasSize;
//申请渲染纹理缓冲
buffer.GetTemporaryRT(dirShadowAtlasId, atlasSize, atlasSize, 32, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
//设置_DirectionalShadowAtlas纹理为相机渲染目标
buffer.SetRenderTarget(dirShadowAtlasId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
//此时相机渲染的或许是shadowmap，为保证后续渲染真实的世界需要clear depth buffer,但是color缓冲会被后续的渲染清空，所以此处不必清空
buffer.ClearRenderTarget(true, false, Color.clear);
buffer.BeginSample(bufferName);
ExecuteBuffer();
int tiles = ShadowDirectionalLightCount * shadowParams.settings.directional.cascadeCount;
int split = tiles <= 1 ? 1 : tiles <= 4 ? 2 : 4;//在x，y方向各切分了split个块
int tileSize = atlasSize / split;
for (int i = 0; i < ShadowDirectionalLightCount; ++i)
{
RenderDirectionalShadows(i, split, tileSize);
}
//(1-d/m)/f,d->深度depth,m->最大距离maxDistance,f->distanceFade
float f = 1f - shadowParams.settings.directional.cascadeFade;
buffer.SetGlobalVector(shadowDistanceFadeId, new Vector4(1f / shadowParams.settings.maxDistance, 1f / shadowParams.settings.distanceFade, 1f / (1f - f * f)));
buffer.SetGlobalInt(cascadeCountId, shadowParams.settings.directional.cascadeCount);
buffer.SetGlobalVectorArray(
cascadeCullingSpheresId, cascadeCullingSpheres
);
buffer.SetGlobalMatrixArray(dirShadowMatricesId, dirShadowMatrices);
buffer.EndSample(bufferName);
ExecuteBuffer();
}
void Setup()
{
context.SetupCameraProperties(camera);
buffer.ClearRenderTarget(true, true, Color.clear);
buffer.BeginSample(bufferName);
ExecuteBuffer();
}
void Setup(ScriptableRenderContext context, Camera camera)
{
buffer.ClearRenderTarget(true, true, Color.clear);
buffer.BeginSample("Render");
ExecuteBuffer(context, camera);
context.SetupCameraProperties(camera);
}
public void Render()
{
if (ShadowedDirectionalLightCount > 0)
{
RenderDirectionalShadows();
}
else
{
buffer.GetTemporaryRT(dirShadowAtlasId, 1, 1, 32, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
}
buffer.BeginSample(bufferName);
SetKeywords(shadowMaskKeywords, useShadowMask ? QualitySettings.shadowmaskMode == ShadowmaskMode.Shadowmask ? 0 : 1 : -1);
buffer.EndSample(bufferName);
ExecuteBuffer();
}
public void Initialization(Texture statisticsTexture, Color statisticsColor, int singleVertGridSize = 3, int sampleIgnoreNum = 4, int sampleIgnoreNumMask = 2)
{
mSingleVertGridSize = singleVertGridSize;
mStatisticsTexture = statisticsTexture;
mMat = new Material(Shader.Find("Hidden/RealtimeImageStatisticsShader"));
mMat.SetTexture("_Image", mStatisticsTexture);
var loopImageSize = new Vector4(mStatisticsTexture.width / (float)mSingleVertGridSize, mStatisticsTexture.height / (float)mSingleVertGridSize);
mMat.SetVector("_LoopImageSize", loopImageSize);
mMat.SetColor("_Rec_Color", statisticsColor);
mMat.SetVector("_SampleFilter", new Vector4(singleVertGridSize, singleVertGridSize, sampleIgnoreNum, sampleIgnoreNumMask));
mMat.SetVector("_GainValue", new Vector4(mRecGainValue, 0, 0, 0));
mTempRT = RenderTexture.GetTemporary(16, 16, 0);
mCommandBuffer = new CommandBuffer();
mCommandBuffer.BeginSample("---Rec Test---");
mCommandBuffer.SetRenderTarget(mTempRT);
mCommandBuffer.ClearRenderTarget(true, true, Color.clear);
var pointsCount = Mathf.CeilToInt(loopImageSize.x * loopImageSize.y);
mCommandBuffer.SetProjectionMatrix(Matrix4x4.Perspective(60f, 1f, 0.0001f, 1f));
mCommandBuffer.DrawProcedural(Matrix4x4.TRS(Vector3.zero, Quaternion.identity, Vector3.one), mMat, 0, MeshTopology.Points, pointsCount, 1);
mCommandBuffer.EndSample("---Rec Test---");
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
TimeX += (Time.deltaTime * settings.gridentSpeed);
if (TimeX > 100)
{
TimeX = 0;
}
if (settings.FromGradientColor.value != null)
{
sheet.properties.SetColor(ShaderIDs.FromColor, settings.FromGradientColor.value.Evaluate(TimeX * 0.01f));
}
if (settings.ToGradientColor.value != null)
{
sheet.properties.SetColor(ShaderIDs.ToColor, settings.ToGradientColor.value.Evaluate(TimeX * 0.01f));
}
sheet.properties.SetFloat(ShaderIDs.Range, settings.Range);
sheet.properties.SetFloat(ShaderIDs.Fuzziness, settings.Fuzziness);
cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
cmd.EndSample(PROFILER_TAG);
}
internal void RenderMonitors(PostProcessRenderContext context)
{
bool flag = false;
bool flag2 = false;
foreach (KeyValuePair <MonitorType, Monitor> monitor in m_Monitors)
{
bool flag3 = monitor.Value.IsRequestedAndSupported(context);
flag |= flag3;
flag2 |= (flag3 && monitor.Value.NeedsHalfRes());
}
if (flag)
{
CommandBuffer command = context.command;
command.BeginSample("Monitors");
if (flag2)
{
command.GetTemporaryRT(ShaderIDs.HalfResFinalCopy, context.width / 2, context.height / 2, 0, FilterMode.Bilinear, context.sourceFormat);
command.Blit(context.destination, ShaderIDs.HalfResFinalCopy);
}
foreach (KeyValuePair <MonitorType, Monitor> monitor2 in m_Monitors)
{
Monitor value = monitor2.Value;
if (value.requested)
{
value.Render(context);
}
}
if (flag2)
{
command.ReleaseTemporaryRT(ShaderIDs.HalfResFinalCopy);
}
command.EndSample("Monitors");
}
}
public void RenderMipmap(ScriptableRenderContext renderContext, Camera camera, VXGI vxgi)
{
var transform = Matrix4x4.TRS(vxgi.origin, Quaternion.identity, Vector3.one * vxgi.bound);
_command.BeginSample(_command.name);
if (vxgi.mipmapSampler == MipmapSampler.Point)
{
_command.EnableShaderKeyword("RADIANCE_POINT_SAMPLER");
}
else
{
_command.DisableShaderKeyword("RADIANCE_POINT_SAMPLER");
}
_command.SetGlobalFloat("MipmapLevel", Mathf.Min(vxgi.level, vxgi.radiances.Length));
_command.SetGlobalFloat("TracingStep", vxgi.step);
_command.DrawProcedural(transform, VisualizationShader.material, (int)VisualizationShader.Pass.Mipmap, MeshTopology.Quads, 24, 1);
_command.EndSample(_command.name);
renderContext.ExecuteCommandBuffer(_command);
_command.Clear();
}
private void RenderFire()
{
// Graphics.DrawMeshInstanced(mesh, 0, material, matrices, meshCount, materialPropertyBlock,
// ShadowCastingMode.On, true, 0, null, llpv ? LightProbeUsage.UseProxyVolume : LightProbeUsage.CustomProvided, llpv);
List <Transform> fireList = new List <Transform>();
for (int i = 0; i < fireRoot.childCount; ++i)
{
fireList.Add(fireRoot.GetChild(i));
}
Matrix4x4[] matrices = new Matrix4x4[fireList.Count];
for (int i = 0; i < matrices.Length; ++i)
{
Transform fireAreaTransform = fireList[i];
matrices[i] = Matrix4x4.TRS(fireAreaTransform.position,
Quaternion.Euler(90, 0, 0),
Vector3.one);
}
commandBuffer.BeginSample("Area");
commandBuffer.GetTemporaryRT(areaPropertyID, 256, 256, 0, FilterMode.Bilinear, RenderTextureFormat.Default);
commandBuffer.SetRenderTarget(areaPropertyID, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
commandBuffer.DrawMeshInstanced(areaMesh, 0, fireAreaMaterial, 0, matrices);
commandBuffer.EndSample("Area");
}
private void InitCommandBuffer()
{
AudioSource ass;
cb = new CommandBuffer {
name = "AfterEverything"
};
cb.BeginSample("MyCommandBuffer");
int id = Shader.PropertyToID("CopyRT");
int id1 = Shader.PropertyToID("CopyRT1");
cb.GetTemporaryRT(id, Screen.width, Screen.height, 0, FilterMode.Bilinear);
cb.GetTemporaryRT(id1, Screen.width, Screen.height, 0, FilterMode.Bilinear);
//先把 CurrentActive 渲染出来 到id 不然是null 纯黑色
cb.Blit(BuiltinRenderTextureType.CurrentActive, id);
cb.Blit(id, id1, effectMaterial, 0);
cb.Blit(id1, BuiltinRenderTextureType.CameraTarget, effectMaterial, 1);
cb.ReleaseTemporaryRT(id);
cb.ReleaseTemporaryRT(id1);
cb.EndSample("MyCommandBuffer");
}
void RenderShadows(ScriptableRenderContext context)
{
shadowBuffer.GetTemporaryRT(shadowMapId, 512, 512, 16, FilterMode.Bilinear, RenderTextureFormat.Depth);
shadowMap = RenderTexture.GetTemporary(512, 512, 16, RenderTextureFormat.Shadowmap);
shadowMap.filterMode = FilterMode.Bilinear;
shadowMap.wrapMode = TextureWrapMode.Clamp;
CoreUtils.SetRenderTarget(shadowBuffer, shadowMap, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, ClearFlag.Depth);
shadowBuffer.BeginSample("Render Shadows");
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
Matrix4x4 viewMatrix, projectMatrix;
ShadowSplitData splitData;
cullingResults.ComputeSpotShadowMatricesAndCullingPrimitives(0, out viewMatrix, out projectMatrix, out splitData);
shadowBuffer.SetViewProjectionMatrices(viewMatrix, projectMatrix);
context.ExecuteCommandBuffer(shadowBuffer);
// draw shadow
var shadowSettings = new ShadowDrawingSettings(cullingResults, 0);
context.DrawShadows(ref shadowSettings);
shadowBuffer.EndSample("Render Shadows");
context.ExecuteCommandBuffer(shadowBuffer);
shadowBuffer.Clear();
}
private void Render()
{
_CommandBuffer = new CommandBuffer();
_CommandBuffer.name = "AdvancedRTR";
// get rt
_CommandBuffer.GetTemporaryRT(ShaderConstants._SourceRT, _Camera.pixelWidth, _Camera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
_CommandBuffer.GetTemporaryRT(ShaderConstants._EdgeRT, _Camera.pixelWidth, _Camera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
_CommandBuffer.GetTemporaryRT(ShaderConstants._BlendWeightRT, _Camera.pixelWidth, _Camera.pixelHeight, 0, FilterMode.Bilinear, RenderTextureFormat.ARGBHalf);
// copy
RuntimeUtilities.BuiltinBlit(_CommandBuffer, BuiltinRenderTextureType.CameraTarget, ShaderConstants._SourceRT);
// MLAA
_CommandBuffer.BeginSample("MLAA");
// edge
RuntimeUtilities.BlitFullscreenTriangle(_CommandBuffer, ShaderConstants._SourceRT, ShaderConstants._EdgeRT, _MLAAMat, 0);
// weight
RuntimeUtilities.BlitFullscreenTriangle(_CommandBuffer, ShaderConstants._EdgeRT, ShaderConstants._BlendWeightRT, _MLAAMat, 1);
// blend
_CommandBuffer.SetGlobalTexture("_BlendWeightTex", ShaderConstants._BlendWeightRT);
RuntimeUtilities.BlitFullscreenTriangle(_CommandBuffer, ShaderConstants._SourceRT, BuiltinRenderTextureType.CameraTarget, _MLAAMat, 2);
// release rt
_CommandBuffer.ReleaseTemporaryRT(ShaderConstants._SourceRT);
_CommandBuffer.ReleaseTemporaryRT(ShaderConstants._EdgeRT);
_CommandBuffer.ReleaseTemporaryRT(ShaderConstants._BlendWeightRT);
_CommandBuffer.EndSample("MLAA");
_Camera.AddCommandBuffer(CameraEvent.BeforeImageEffects, _CommandBuffer);
}
void Process(CommandBuffer cmd)
{
var outputDimension = rtSettings.GetTextureDimension(graph);
if (!supportedDimensions.Contains((OutputDimension)outputDimension))
{
// AddMessage($"Dimension {outputDimension} is not supported by this node", NodeMessageType.Error);
return;
}
else
{
// TODO: simplify this with the node graph processor remove badges with matching words feature
// RemoveMessage($"Dimension {TextureDimension.Tex2D} is not supported by this node");
// RemoveMessage($"Dimension {TextureDimension.Tex3D} is not supported by this node");
// RemoveMessage($"Dimension {TextureDimension.Cube} is not supported by this node");
}
beforeProcessSetup?.Invoke();
// Avoid adding markers if it's CRT processing (CRT already have one)
// Or loops as it will bloat the debug markers
bool loopNode = this is ILoopStart || this is ILoopEnd;
if (this is IUseCustomRenderTextureProcessing || loopNode)
{
ProcessNode(cmd);
}
else
{
cmd.BeginSample(sampler);
ProcessNode(cmd);
cmd.EndSample(sampler);
}
afterProcessCleanup?.Invoke();
}
void TriggerCameraEvent(ScriptableRenderContext renderContext, Camera camera, CameraEvent cameraEvent, VXGI vxgi)
{
#if UNITY_EDITOR
camera = camera.cameraType == CameraType.SceneView ? vxgi.Camera : camera;
#endif
var commands = camera.GetCommandBuffers(cameraEvent);
if (commands.Length == 0)
{
return;
}
_eventCommand.name = _sampleCameraEvent + cameraEvent.ToString();
_eventCommand.BeginSample(_eventCommand.name);
_eventCommand.SetRenderTarget(ShaderIDs.FrameBuffer);
renderContext.ExecuteCommandBuffer(_eventCommand);
_eventCommand.Clear();
foreach (var command in commands)
{
renderContext.ExecuteCommandBuffer(command);
}
_eventCommand.EndSample(_eventCommand.name);
renderContext.ExecuteCommandBuffer(_eventCommand);
_eventCommand.Clear();
}
public ProfilingSample(string _name, CommandBuffer _cmd)
{
cmd = _cmd;
disposed = false;
name = _name;
cmd.BeginSample(name);
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
float size = (1.01f - settings.pixelSize) * 300f;
float ratio = settings.pixelRatio;
if (settings.useAutoScreenRatio)
{
ratio = (float)(context.width / (float)context.height);
if (ratio == 0)
{
ratio = 1f;
}
}
sheet.properties.SetVector(ShaderIDs.Params, new Vector4(size, ratio, settings.ledRadius));
sheet.properties.SetColor(ShaderIDs.BackgroundColor, settings.BackgroundColor);
cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
cmd.EndSample(PROFILER_TAG);
}
void FilterCubemapCommon(CommandBuffer cmd,
Texture source, RenderTexture target, int mipCount,
Matrix4x4[] worldToViewMatrices)
{
// Solid angle associated with a texel of the cubemap.
float invOmegaP = (6.0f * source.width * source.width) / (4.0f * Mathf.PI);
m_GgxConvolveMaterial.SetTexture("_MainTex", source);
m_GgxConvolveMaterial.SetTexture("_GgxIblSamples", m_GgxIblSampleData);
m_GgxConvolveMaterial.SetFloat("_LastLevel", mipCount - 1);
m_GgxConvolveMaterial.SetFloat("_InvOmegaP", invOmegaP);
for (int mip = 1; mip < ((int)EnvConstants.SpecCubeLodStep + 1); ++mip)
{
string sampleName = String.Format("Filter Cubemap Mip {0}", mip);
cmd.BeginSample(sampleName);
for (int face = 0; face < 6; ++face)
{
Vector4 faceSize = new Vector4(source.width >> mip, source.height >> mip, 1.0f / (source.width >> mip), 1.0f / (source.height >> mip));
Matrix4x4 transform = SkyManager.ComputePixelCoordToWorldSpaceViewDirectionMatrix(0.5f * Mathf.PI, faceSize, worldToViewMatrices[face], true);
MaterialPropertyBlock props = new MaterialPropertyBlock();
props.SetFloat("_Level", mip);
props.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, transform);
Utilities.SetRenderTarget(cmd, target, ClearFlag.ClearNone, mip, (CubemapFace)face);
Utilities.DrawFullScreen(cmd, m_GgxConvolveMaterial, props);
}
cmd.EndSample(sampleName);
}
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
if (settings.RTDownScaling > 1)
{
int RTWidth = (int)(context.screenWidth / settings.RTDownScaling);
int RTHeight = (int)(context.screenHeight / settings.RTDownScaling);
cmd.GetTemporaryRT(ShaderIDs.BufferRT, RTWidth, RTHeight, 0, FilterMode.Bilinear);
// downsample screen copy into smaller RT
context.command.BlitFullscreenTriangle(context.source, ShaderIDs.BufferRT);
}
sheet.properties.SetVector(ShaderIDs.Params, new Vector2(settings.BlurRadius / context.height, settings.Iteration));
if (settings.RTDownScaling > 1)
{
cmd.BlitFullscreenTriangle(ShaderIDs.BufferRT, context.destination, sheet, 0);
}
else
{
cmd.BlitFullscreenTriangle(context.source, context.destination, sheet, 0);
}
cmd.ReleaseTemporaryRT(ShaderIDs.BufferRT);
cmd.EndSample(PROFILER_TAG);
}
public void Render(ref RenderingData context)
{
cmd.BeginSample("Shadow");
cmd.Clear();
ShadowDrawingSettings drawSetting = new ShadowDrawingSettings(context.cullResult, 0);
Matrix4x4 view;
Matrix4x4 proj;
ShadowSplitData splitData;
context.cullResult.ComputeDirectionalShadowMatricesAndCullingPrimitives(0, 0, 1, Vector3.zero, (int)context.asset.ShadowSetting.directional.altasSize, 0f, out view, out proj, out splitData);
drawSetting.splitData = splitData;
cmd.SetViewProjectionMatrices(view, proj);
int texSize = (int)context.asset.ShadowSetting.directional.altasSize;
var ren = new RenderTargetIdentifier(BuiltinRenderTextureType.CameraTarget);
cmd.GetTemporaryRT(dirShadowAtlasId, texSize, texSize, 24, FilterMode.Bilinear, RenderTextureFormat.Shadowmap);
cmd.SetRenderTarget(dirShadowAtlasId, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
cmd.ClearRenderTarget(true, false, Color.clear);
context.context.ExecuteCommandBuffer(cmd);
cmd.Clear();
context.context.DrawShadows(ref drawSetting);
// cmd.SetRenderTarget(ren);
// context.context.ExecuteCommandBuffer(cmd);
cmd.EndSample("Shadow");
}
public override void Render(PostProcessRenderContext context)
{
CommandBuffer cmd = context.command;
PropertySheet sheet = context.propertySheets.Get(shader);
cmd.BeginSample(PROFILER_TAG);
int tw = (int)(context.screenWidth / settings.RTDownScaling);
int th = (int)(context.screenHeight / settings.RTDownScaling);
sheet.properties.SetFloat(ShaderIDs.BlurOffset, settings.BlurRadius);
// Downsample
RenderTargetIdentifier lastDown = context.source;
for (int i = 0; i < settings.Iteration; i++)
{
int mipDown = m_Pyramid[i].down;
int mipUp = m_Pyramid[i].up;
context.GetScreenSpaceTemporaryRT(cmd, mipDown, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw, th);
context.GetScreenSpaceTemporaryRT(cmd, mipUp, 0, context.sourceFormat, RenderTextureReadWrite.Default, FilterMode.Bilinear, tw, th);
cmd.BlitFullscreenTriangle(lastDown, mipDown, sheet, 0);
lastDown = mipDown;
tw = Mathf.Max(tw / 2, 1);
th = Mathf.Max(th / 2, 1);
}
// Upsample
int lastUp = m_Pyramid[settings.Iteration - 1].down;
for (int i = settings.Iteration - 2; i >= 0; i--)
{
int mipUp = m_Pyramid[i].up;
cmd.BlitFullscreenTriangle(lastUp, mipUp, sheet, 1);
lastUp = mipUp;
}
// Render blurred texture in blend pass
cmd.BlitFullscreenTriangle(lastUp, context.destination, sheet, 1);
// Cleanup
for (int i = 0; i < settings.Iteration; i++)
{
if (m_Pyramid[i].down != lastUp)
{
cmd.ReleaseTemporaryRT(m_Pyramid[i].down);
}
if (m_Pyramid[i].up != lastUp)
{
cmd.ReleaseTemporaryRT(m_Pyramid[i].up);
}
}
cmd.EndSample(PROFILER_TAG);
}
private void Setup()
{
context.SetupCameraProperties(camera);
var flags = camera.clearFlags;
if (postFXStack.IsActive)
{
if (flags > CameraClearFlags.Color)
{
flags = CameraClearFlags.Color;
}
buffer.GetTemporaryRT(
frameBufferId, camera.pixelWidth, camera.pixelHeight,
32, FilterMode.Bilinear, RenderTextureFormat.Default
);
buffer.SetRenderTarget(
frameBufferId,
RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store
);
}
buffer.ClearRenderTarget(
flags != CameraClearFlags.Nothing,
flags != CameraClearFlags.Nothing && flags != CameraClearFlags.Depth,
camera.backgroundColor.linear);
buffer.BeginSample(bufferName);
ExecuteBuffer();
}