protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
CoreUtils.SetRenderTarget(cmd, bloomDistortionBuffer, ClearFlag.Color);
var resultOpaque = new RendererListDesc(new ShaderTagId("BloomDistortion"), cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.opaque,
sortingCriteria = SortingCriteria.CommonOpaque,
excludeObjectMotionVectors = false,
overrideMaterialPassIndex = 0,
// layerMask = layer,
};
var resultTransparent = new RendererListDesc(new ShaderTagId("BloomDistortion"), cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.transparent,
sortingCriteria = SortingCriteria.CommonTransparent,
excludeObjectMotionVectors = false,
overrideMaterialPassIndex = 0,
// layerMask = layer,
};
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(resultOpaque));
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(resultTransparent));
// SetCameraRenderTarget(cmd);
// HDUtils.BlitTexture(cmd, bloomDistortionBuffer, new Vector4(1, 1, 0, 0), 0, false);
}
public override string ToHtmlString()
{
if (_inputModel == null)
{
return(null);
}
string result = string.Empty;
switch (_inputType)
{
case BootstrapInputType._NotSet:
return(null);
case BootstrapInputType.CheckBoxList:
case BootstrapInputType.RadioList:
{
var input = RendererList <TModel, TSource, SValue, SText>
.RenderInputList(html, (BootstrapInputListModel <TModel, TSource, SValue, SText>) _inputModel);
var label = Renderer.RenderLabel(html, _labelModel);
result = label + input;
break;
}
}
return(result);
}
// This function is called from the custom post process at the before post process injection point, just after TAA
public void RenderVideoObjects(CommandBuffer cmd)
{
// Fix depth buffer jittering
if (fixDepthBufferJittering)
{
using (new ProfilingScope(cmd, new ProfilingSampler("Render Depth Buffer without jittering")))
{
// We need to re-render everything to get the non-jittered depth buffer :/
CoreUtils.SetRenderTarget(cmd, videoDepthBuffer);
CoreUtils.ClearRenderTarget(cmd, ClearFlag.Depth, Color.black);
var tags = new ShaderTagId[] { new ShaderTagId("DepthForwardOnly"), new ShaderTagId("DepthOnly") };
var result = new RendererListDesc(tags, context.cullingResults, context.hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.CommonOpaque,
excludeObjectMotionVectors = false,
layerMask = fixDepthBufferJitteringMask,
// stateBlock = overrideRenderState,
};
CoreUtils.DrawRendererList(context.renderContext, context.cmd, RendererList.Create(result));
}
}
// TODO: add an option to render the "frame" objects in the unjittered depth-buffer to avoid flickering
CoreUtils.SetRenderTarget(cmd, videoColorBuffer, fixDepthBufferJittering ? videoDepthBuffer : context.cameraDepthBuffer, ClearFlag.Color);
var renderState = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(false, CompareFunction.LessEqual)
};
CustomPassUtils.DrawRenderers(context, videoObjectMask, overrideRenderState: renderState);
}
void RenderOpaqueDepth(Camera RenderCamera, FCullingData CullingData, CullingResults CullingResult)
{
//Request Resource
RendererList RenderList = RendererList.Create(CreateRendererListDesc(CullingResult, RenderCamera, InfinityPassIDs.OpaqueDepth, new RenderQueueRange(2450, 2999)));
RDGTextureDesc DepthDesc = new RDGTextureDesc(Screen.width, Screen.height)
{
clearBuffer = true, dimension = TextureDimension.Tex2D, enableMSAA = false, bindTextureMS = false, name = "DepthTexture", depthBufferBits = EDepthBits.Depth32
};
RDGTextureRef DepthTexture = GraphBuilder.ScopeTexture(InfinityShaderIDs.DepthBuffer, DepthDesc);
//Add OpaqueDepthPass
GraphBuilder.AddPass <FOpaqueDepthData>("OpaqueDepth", ProfilingSampler.Get(CustomSamplerId.OpaqueDepth),
(ref FOpaqueDepthData PassData, ref RDGPassBuilder PassBuilder) =>
{
PassData.RendererList = RenderList;
PassData.DepthBuffer = PassBuilder.UseDepthBuffer(DepthTexture, EDepthAccess.ReadWrite);
DepthPassMeshProcessor.DispatchGather(CullingData, new FMeshPassDesctiption(2450, 2999));
},
(ref FOpaqueDepthData PassData, RDGContext GraphContext) =>
{
RendererList DepthRenderList = PassData.RendererList;
DepthRenderList.drawSettings.sortingSettings = new SortingSettings(RenderCamera)
{
criteria = SortingCriteria.QuantizedFrontToBack
};
DepthRenderList.drawSettings.enableInstancing = RenderPipelineAsset.EnableInstanceBatch;
DepthRenderList.drawSettings.enableDynamicBatching = RenderPipelineAsset.EnableDynamicBatch;
DepthRenderList.filteringSettings.renderQueueRange = new RenderQueueRange(2450, 2999);
GraphContext.RenderContext.DrawRenderers(DepthRenderList.cullingResult, ref DepthRenderList.drawSettings, ref DepthRenderList.filteringSettings);
//MeshDrawPipeline
DepthPassMeshProcessor.DispatchDraw(GraphContext, 1);
});
}
void RenderObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, Material overrideMaterial, int passIndex, CompareFunction depthCompare, CullingResults cullingResult, HDCamera hdCamera, StencilState?overrideStencil = null)
{
// Render the objects in the layer blur mask into a mask buffer with their materials so we keep the alpha-clip and transparency if there is any.
var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
overrideMaterial = overrideMaterial,
overrideMaterialPassIndex = passIndex,
layerMask = seeThroughLayer,
stateBlock = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(true, depthCompare)
},
};
if (overrideStencil != null)
{
var block = result.stateBlock.Value;
block.mask |= RenderStateMask.Stencil;
block.stencilState = overrideStencil.Value;
result.stateBlock = block;
}
CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
protected override void Execute(CustomPassContext ctx)
{
if (!ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.ObjectMotionVectors) ||
!ctx.hdCamera.frameSettings.IsEnabled(FrameSettingsField.OpaqueObjects))
{
Debug.Log("Motion Vectors are disabled on the camera!");
return;
}
SyncRenderTextureAspect(motionVectorTexture, ctx.hdCamera.camera);
var tags = new ShaderTagId("MotionVectors");
var motionVectorRendererListDesc = new RendererListDesc(tags, ctx.cullingResults, ctx.hdCamera.camera)
{
rendererConfiguration = PerObjectData.MotionVectors,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = renderingMask
};
if (ctx.hdCamera.msaaSamples != MSAASamples.None)
{
CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] { dummy.colorBuffer, motionVectorTexture }, dummy.depthBuffer, ClearFlag.All);
}
else
{
CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] { motionVectorTexture }, motionVectorTexture.depthBuffer, ClearFlag.All);
}
RendererList motionVectorsRendererList = RendererList.Create(motionVectorRendererListDesc);
CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, motionVectorsRendererList);
}
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
if (blurMaterial == null)
{
Debug.LogError("Failed to load Liquid Pass Shaders");
return;
}
var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = layerMask.value,
};
// Render objects into the custom buffer:
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
// Blur the custom buffer:
BlurCustomBuffer(cmd, hdCamera);
// Composite the result into the camera color buffer
SetCameraRenderTarget(cmd);
int pass = transparentFullscreenShader.FindPass("Forward");
if (pass == -1)
{
pass = transparentFullscreenShader.FindPass("ForwardOnly");
}
CoreUtils.DrawFullScreen(cmd, blurMaterial, pass);
}
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult)
{
var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1);
cmd.ClearRenderTarget(true, true, Color.clear);
DrawRendererList(renderContext, cmd, RendererList.Create(renderList));
}
protected static void DrawRendererList(
ScriptableRenderContext renderContext, CommandBuffer cmd, RendererList rendererList)
{
if (!rendererList.isValid)
{
throw new ArgumentException("Invalid renderer list provided to DrawRendererList");
}
// This is done here because DrawRenderers API lives outside command buffers so we need to call this before
// doing any DrawRenders or things will be executed out of order
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
if (rendererList.stateBlock == null)
{
renderContext.DrawRenderers(
rendererList.cullingResult, ref rendererList.drawSettings, ref rendererList.filteringSettings);
}
else
{
var renderStateBlock = rendererList.stateBlock.Value;
renderContext.DrawRenderers(
rendererList.cullingResult,
ref rendererList.drawSettings,
ref rendererList.filteringSettings,
ref renderStateBlock);
}
}
public override void Begin()
{
base.Begin();
// add on-screen elements like GameLoader/OverworldLoader
Add(new HudRenderer());
Add(snow);
RendererList.UpdateLists();
// register the routine
Entity entity = new Entity();
entity.Add(new Coroutine(Routine()));
Add(entity);
// run the update check task asynchronously
new Task(() => {
// display "checking for updates" message, in case the async task is not done yet.
modUpdatingMessage = Dialog.Clean("AUTOUPDATECHECKER_CHECKING");
SortedDictionary <ModUpdateInfo, EverestModuleMetadata> updateList = ModUpdaterHelper.GetAsyncLoadedModUpdates();
if (updateList == null || updateList.Count == 0)
{
// no mod update, clear message and continue right away.
modUpdatingMessage = null;
shouldContinue = true;
}
else
{
// install mod updates
autoUpdate(updateList);
}
}).Start();
}
public IEnumerator TransitioningSprite(Sprite sprite, float speed, bool smooth)
{
for (int i = 0; i < RendererList.Count; i++)
{
Image image = RendererList[i];
if (image.sprite == sprite)
{
RenderLayer.CurrentRenderer = image;
break;
}
}
if (!IsCurrent(sprite))
{
Image image = Object
.Instantiate(RenderLayer.CurrentRenderer.gameObject, RenderLayer.CurrentRenderer.transform.parent)
.GetComponent <Image>();
RendererList.Add(image);
RenderLayer.CurrentRenderer = image;
image.color = GraphicHelpers.SetAlpha(image.color, 0f);
image.sprite = sprite;
}
while (TransitionImages(speed, smooth))
{
yield return(new WaitForEndOfFrame());
}
EndTransition();
}
public bool TransitionImages(float speed, bool smooth)
{
bool anyValueChanged = false;
speed *= Time.deltaTime;
for (int i = RendererList.Count - 1; i >= 0; i--)
{
Image image = RendererList[i];
bool isActiveImage = IsCurrent(image);
float targetOpacity = isActiveImage ? 1f : 0f;
float alphaValue = smooth ? Mathf.Lerp(image.color.a, targetOpacity, speed)
: Mathf.MoveTowards(image.color.a, targetOpacity, speed);
image.color = GraphicHelpers.SetAlpha(image.color, alphaValue);
anyValueChanged = true;
if (!isActiveImage && image.color.a <= 0.01f)
{
RendererList.RemoveAt(i);
Object.DestroyImmediate(image.gameObject);
}
}
if (RendererList.Count == 1 && RenderLayer.CurrentRenderer.color.a == 1f)
{
return(false);
}
return(anyValueChanged);
}
void DrawObjectToFurify(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
overrideMaterial = scatterFurPointsMaterial,
overrideMaterialPassIndex = 0,
layerMask = furMask,
};
scatterFurPointsMaterial.SetBuffer("furData", furData);
// CoreUtils.SetRenderTarget(cmd, furMask, maskDepthBuffer, ClearFlag.All);
CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
if (furMesh != null && furMaterial != null)
{
//Update draw arguments:
drawArgs[0] = furMesh.GetIndexCount(0);
drawArgs[1] = 100; // this is filled by the geometry shader
drawArgs[2] = furMesh.GetIndexStart(0);
drawArgs[3] = furMesh.GetBaseVertex(0);
drawFurBuffer.SetData(drawArgs);
furMaterial.SetBuffer("furData", furData);
cmd.DrawMeshInstancedIndirect(furMesh, 0, furMaterial, 0, drawFurBuffer);
}
}
/// <summary>
/// Execute the DrawRenderers with parameters setup from the editor
/// </summary>
/// <param name="renderContext"></param>
/// <param name="cmd"></param>
/// <param name="camera"></param>
/// <param name="cullingResult"></param>
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
ShaderTagId[] shaderPasses = new ShaderTagId[hdrpShaderTags.Count + ((overrideMaterial != null) ? 1 : 0)];
System.Array.Copy(hdrpShaderTags.ToArray(), shaderPasses, hdrpShaderTags.Count);
if (overrideMaterial != null)
{
shaderPasses[hdrpShaderTags.Count] = new ShaderTagId(overrideMaterial.GetPassName(overrideMaterialPassIndex));
}
if (shaderPasses.Length == 0)
{
Debug.LogWarning("Attempt to call DrawRenderers with an empty shader passes. Skipping the call to avoid errors");
return;
}
var result = new RendererListDesc(shaderPasses, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = GetRenderQueueRange(renderQueueType),
sortingCriteria = sortingCriteria,
excludeObjectMotionVectors = true,
overrideMaterial = overrideMaterial,
overrideMaterialPassIndex = overrideMaterialPassIndex,
layerMask = layerMask,
};
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
/// <summary>
/// Execute the DrawRenderers with parameters setup from the editor
/// </summary>
/// <param name="renderContext"></param>
/// <param name="cmd"></param>
/// <param name="camera"></param>
/// <param name="cullingResult"></param>
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
ShaderTagId[] shaderPasses = new ShaderTagId[hdrpShaderTags.Count + ((overrideMaterial != null) ? 1 : 0)];
System.Array.Copy(hdrpShaderTags.ToArray(), shaderPasses, hdrpShaderTags.Count);
if (overrideMaterial != null)
{
shaderPasses[hdrpShaderTags.Count] = new ShaderTagId(overrideMaterial.GetPassName(overrideMaterialPassIndex));
overrideMaterial.SetFloat(fadeValueId, fadeValue);
}
if (shaderPasses.Length == 0)
{
Debug.LogWarning("Attempt to call DrawRenderers with an empty shader passes. Skipping the call to avoid errors");
return;
}
var stateBlock = new RenderStateBlock(overrideDepthState ? RenderStateMask.Depth : 0)
{
depthState = new DepthState(depthWrite, depthCompareFunction),
};
var result = new RendererListDesc(shaderPasses, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = GetRenderQueueRange(renderQueueType),
sortingCriteria = sortingCriteria,
excludeObjectMotionVectors = false,
overrideMaterial = (overrideMaterial != null) ? overrideMaterial : defaultOverrideMaterial,
overrideMaterialPassIndex = (overrideMaterial != null) ? overrideMaterialPassIndex : 0,
stateBlock = stateBlock,
layerMask = layerMask,
};
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
protected override void Execute(CustomPassContext ctx)
{
// Executed every frame for all the camera inside the pass volume.
// The context contains the command buffer to use to enqueue graphics commands.
CommandBuffer cmd = ctx.cmd;
Camera shadowCamera = ctx.hdCamera.camera;
cmd.SetGlobalTexture("_SelfShadowTexture", m_MainLightShadowmapTexture);
CoreUtils.SetRenderTarget(cmd, m_MainLightShadowmapTexture, ClearFlag.All, Color.black);
var renstateBlock = new RenderStateBlock(RenderStateMask.Depth)
{
depthState = new DepthState(true, CompareFunction.LessEqual),
stencilState = new StencilState(false),
};
var hairResult = new RendererListDesc(new ShaderTagId("DepthOnly"), ctx.cullingResults, shadowCamera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all, // to change
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
overrideMaterial = shadowMaterial,
overrideMaterialPassIndex = (shadowMaterial != null) ? shadowMaterial.FindPass("DepthOnly") : 0,
stateBlock = renstateBlock,
layerMask = hairLayerMask,
};
CoreUtils.DrawRendererList(ctx.renderContext, cmd, RendererList.Create(hairResult));
}
protected override void OnActivate()
{
this.toolCursor = new Cursor(PdnResources.GetResourceStream("Cursors.GenericToolCursor.cur"));
this.toolMouseDownCursor = new Cursor(PdnResources.GetResourceStream("Cursors.GenericToolCursorMouseDown.cur"));
this.Cursor = this.toolCursor;
this.toolIcon = this.Image;
this.startNub = new MoveNubRenderer(RendererList);
this.startNub.Visible = false;
this.startNub.Shape = MoveNubShape.Circle;
RendererList.Add(this.startNub, false);
this.endNub = new MoveNubRenderer(RendererList);
this.endNub.Visible = false;
this.endNub.Shape = MoveNubShape.Circle;
RendererList.Add(this.endNub, false);
this.moveNubs =
new MoveNubRenderer[]
{
this.startNub,
this.endNub
};
AppEnvironment.PrimaryColorChanged += new EventHandler(RenderBecauseOfEvent);
AppEnvironment.SecondaryColorChanged += new EventHandler(RenderBecauseOfEvent);
AppEnvironment.GradientInfoChanged += new EventHandler(RenderBecauseOfEvent);
AppEnvironment.AlphaBlendingChanged += new EventHandler(RenderBecauseOfEvent);
AppWorkspace.UnitsChanged += new EventHandler(RenderBecauseOfEvent);
base.OnActivate();
}
public override void End()
{
orig_End();
Remove(Snow);
RendererList.UpdateLists();
Snow = null;
}
protected override void Execute(CustomPassContext ctx)
{
#region Draw Vertex Color
// use MRT to render JTRP Shader after Opaque / Sky
// CoreUtils.SetRenderTarget(ctx.cmd, _customBuffer);
// CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.white);
//
// CoreUtils.SetRenderTarget(ctx.cmd, new RenderTargetIdentifier[] {ctx.cameraColorBuffer, _customBuffer},
// ctx.cameraDepthBuffer);
#endregion
// render PP to tempBuffer and zhen copy back to cameraColor
if (enablePPOutline)
{
SetupPPTempBuffer(ctx);
CoreUtils.SetRenderTarget(ctx.cmd, _postProcessTempBuffer, ctx.cameraDepthBuffer);
CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Color, Color.blue);
DoPPOutline(ctx);
BlitToCameraColorTexture(ctx, _postProcessTempBuffer);
}
// draw opaque
var resultJTRPOpaque =
new RendererListDesc(new ShaderTagId("JTRPLitToon"), ctx.cullingResults, ctx.hdCamera.camera)
{
rendererConfiguration = (PerObjectData) 2047, // all
renderQueueRange = RenderQueueRange.opaque,
sortingCriteria = SortingCriteria.CommonOpaque
};
SetRenderTargetAuto(ctx.cmd);
CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(resultJTRPOpaque));
// Procedural Geometry Outline
if (enableGeometryOutline)
{
if (enable3XDepth)
{
Setup3XDepthBuffer();
CoreUtils.SetRenderTarget(ctx.cmd, _depthBuffer, _depthBuffer);
CoreUtils.ClearRenderTarget(ctx.cmd, ClearFlag.Depth, Color.black);
var resultOpaqueDepthOnly =
new RendererListDesc(new ShaderTagId("DepthOnly"), ctx.cullingResults, ctx.hdCamera.camera)
{
rendererConfiguration = (PerObjectData) 2047, // all
renderQueueRange = RenderQueueRange.opaque,
sortingCriteria = SortingCriteria.CommonOpaque
};
CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, RendererList.Create(resultOpaqueDepthOnly));
SetRenderTargetAuto(ctx.cmd);
Shader.SetGlobalTexture(_camera3XDepthTexture, _depthBuffer);
}
DoGeometryOutline(ctx);
}
}
protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
if (injectionPoint != CustomPassInjectionPoint.AfterPostProcess)
{
Debug.LogError("CustomPassInjectionPoint shouild be set on AfterPostProcess");
return;
}
if (render && hdCamera.camera != bakeCamera && hdCamera.camera.cameraType != CameraType.SceneView)
{
bakeCamera.TryGetCullingParameters(out var cullingParams);
cullingParams.cullingOptions = CullingOptions.ShadowCasters;
cullingResult = renderContext.Cull(ref cullingParams);
var result = new RendererListDesc(shaderTags, cullingResult, bakeCamera)
{
rendererConfiguration = PerObjectData.None,
//renderQueueRange = RenderQueueRange.all,
renderQueueRange = GetRenderQueueRange(RenderQueueType.AllOpaque),
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = -1,
overrideMaterial = depthMaterial,
overrideMaterialPassIndex = depthMaterial.FindPass("ForwardOnly"),
};
//renderContext.StereoEndRender(hdCamera.camera);
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
renderContext.StopMultiEye(hdCamera.camera);
var p = GL.GetGPUProjectionMatrix(bakeCamera.projectionMatrix, true);
Matrix4x4 scaleMatrix = Matrix4x4.identity;
scaleMatrix.m22 = -1.0f;
var v = scaleMatrix * bakeCamera.transform.localToWorldMatrix.inverse;
var vp = p * v;
cmd.SetGlobalMatrix("_ViewMatrix", v);
cmd.SetGlobalMatrix("_InvViewMatrix", v.inverse);
cmd.SetGlobalMatrix("_ProjMatrix", p);
cmd.SetGlobalMatrix("_InvProjMatrix", p.inverse);
cmd.SetGlobalMatrix("_ViewProjMatrix", vp);
cmd.SetGlobalMatrix("_InvViewProjMatrix", vp.inverse);
cmd.SetGlobalMatrix("_CameraViewProjMatrix", vp);
cmd.SetGlobalVector("_WorldSpaceCameraPos", Vector3.zero);
cmd.SetGlobalVector("_ShadowClipPlanes", Vector3.zero);
CoreUtils.SetRenderTarget(cmd, depthFromCam, ClearFlag.All);
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
renderContext.StartMultiEye(hdCamera.camera);
renderContext.ExecuteCommandBuffer(cmd);
cmd.Clear();
}
}
//Render all objects to our target RenderTexture using `overrideMaterial` to use our shader
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult)
{
using (s_ExecuteMarker.Auto())
{
cmd.ClearRenderTarget(true, true, Color.black);
var result = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, layerMask);
DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
}
public FactoryIntroVignette(Session session, HiresSnow snow = null)
{
this.session = session;
areaMusic = session.Audio.Music.Event;
session.Audio.Music.Event = null;
session.Audio.Apply(forceSixteenthNoteHack: false);
Add(hud = new HudRenderer());
RendererList.UpdateLists();
textbox = new Textbox("KaydenFox_FactoryMod_1_Factory_A_Intro");
textCoroutine = new Coroutine(TextSequence());
}
public override void End()
{
orig_End();
if (!EnteringPico8)
{
Remove(Snow);
RendererList.UpdateLists();
Snow = null;
}
}
public static void DrawRendererList(ScriptableRenderContext RenderContext, RendererList RendererList)
{
if (RendererList.stateBlock == null)
{
RenderContext.DrawRenderers(RendererList.cullingResult, ref RendererList.drawSettings, ref RendererList.filteringSettings);
}
else
{
var RenderStateBlock = RendererList.stateBlock.Value;
RenderContext.DrawRenderers(RendererList.cullingResult, ref RendererList.drawSettings, ref RendererList.filteringSettings, ref RenderStateBlock);
}
}
public Emulator(Scene returnTo, int levelX = 0, int levelY = 0)
{
ReturnTo = returnTo;
bootLevel = new Point(levelX, levelY);
buffer = VirtualContent.CreateRenderTarget("pico-8", 128, 128);
// sprites
var atlas = GFX.Game["pico8/atlas"];
sprites = new MTexture[(atlas.Width / 8) * (atlas.Height / 8)];
for (int ty = 0; ty < atlas.Height / 8; ty++)
{
for (int tx = 0; tx < atlas.Width / 8; tx++)
{
sprites[tx + ty * (atlas.Width / 8)] = atlas.GetSubtexture(tx * 8, ty * 8, 8, 8);
}
}
// tilemap
var tiledata = MapData;
tiledata = Regex.Replace(tiledata, @"\s+", "");
tilemap = new byte[tiledata.Length / 2];
for (int i = 0, len = tiledata.Length, hlen = len / 2; i < len; i += 2)
{
var a = tiledata[i];
var b = tiledata[i + 1];
var str = (i < hlen ? (a.ToString() + b.ToString()) : (b.ToString() + a.ToString()));
tilemap[i / 2] = (byte)int.Parse(str, System.Globalization.NumberStyles.HexNumber);
}
// font
var fontatlas = GFX.Game["pico8/font"];
font = new MTexture[(fontatlas.Width / 4) * (fontatlas.Height / 6)];
for (var ty = 0; ty < fontatlas.Height / 6; ty++)
{
for (var tx = 0; tx < fontatlas.Width / 4; tx++)
{
font[tx + ty * (fontatlas.Width / 4)] = fontatlas.GetSubtexture(tx * 4, ty * 6, 4, 6);
}
}
// boot stuff
picoBootLogo = GFX.Game["pico8/logo"];
ResetScreen();
Audio.SetMusic(null);
Audio.SetAmbience(null);
new FadeWipe(this, true);
RendererList.UpdateLists();
}
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult)
{
if (s_LastFrameExecuted == Time.frameCount)
{
return;
}
s_LastFrameExecuted = Time.frameCount;
var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1);
cmd.ClearRenderTarget(true, true, Color.black);
DrawRendererList(renderContext, cmd, RendererList.Create(renderList));
}
public override string ToHtmlString()
{
if (string.IsNullOrEmpty(_inputModel.htmlFieldName))
{
return(null);
}
string input = RendererList <TModel, TSource, SValue, SText> .RenderInputList(html, _inputModel);
string label = Renderer.RenderLabel(html, _labelModel);
return(new BootstrapFormGroup(input, label, FormGroupType.textboxLike).ToHtmlString());
}
protected override void ExecutePass(ScriptableRenderContext renderContext, CommandBuffer cmd, Camera camera, CullingResults cullingResult)
{
if (s_LastFrameExecuted == Time.frameCount)
{
Debug.LogError("Semantic segmentation was run twice in the same frame. Multiple semantic segmentations are not currently supported.");
}
s_LastFrameExecuted = Time.frameCount;
var renderList = CreateRendererListDesc(camera, cullingResult, "FirstPass", 0, m_OverrideMaterial, -1);
cmd.ClearRenderTarget(true, true, Color.black);
DrawRendererList(renderContext, cmd, RendererList.Create(renderList));
}
void DrawOutlineMeshes(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
{
// We need the lighting render configuration to support rendering lit objects
rendererConfiguration = PerObjectData.LightProbe | PerObjectData.LightProbeProxyVolume | PerObjectData.Lightmaps,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = outlineLayer,
};
CoreUtils.SetRenderTarget(cmd, outlineBuffer, ClearFlag.Color);
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
void DrawMaskObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
{
// Render the objects in the layer blur mask into a mask buffer with their materials so we keep the alpha-clip and transparency if there is any.
var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
{
rendererConfiguration = PerObjectData.None,
renderQueueRange = RenderQueueRange.all,
sortingCriteria = SortingCriteria.BackToFront,
excludeObjectMotionVectors = false,
layerMask = maskLayer,
};
CoreUtils.SetRenderTarget(cmd, maskBuffer, maskDepthBuffer, ClearFlag.All);
HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}
