void OnEndCameraRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera cam)
{
if (cam == m_cam && null != m_rtCamera.targetTexture)
{
//This seems to work only if we have setup PostProcessing Stack V2
Graphics.Blit(m_rtCamera.targetTexture, (RenderTexture)null);
}
}
void OnBeginCameraRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera camera)
#endif
{
if (BeginCameraRendering != null)
{
BeginCameraRendering(camera);
}
}
void OnBeginFrameRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera[] cameras)
#endif
{
if (BeginFrameRendering != null)
{
BeginFrameRendering(cameras);
}
}
//----------------------------------------------------------------------------------------------------------------------
void OnEndFrameRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera[] cams)
{
if (null == GetSrcTexture())
{
return;
}
//only blit for specified camera type
foreach (Camera cam in cams)
{
if (cam.cameraType != m_targetCameraType)
{
return;
}
}
BlitToDest(null);
}
private void OnEndFrameRendering(UnityEngine.Rendering.ScriptableRenderContext arg1, Camera[] arg2)
{
UnityEngine.Rendering.RenderPipelineManager.endFrameRendering -= OnEndFrameRendering;
//LWRP OR HDRP;
bool wasActive = m_graphicsLayerCamera.gameObject.activeSelf;
m_graphicsLayerCamera.gameObject.SetActive(false);
m_renderTextureCamera = m_graphicsLayerCamera.gameObject.AddComponent <RenderTextureCamera>();
//m_renderTextureCamera.Fullscreen = false;
IRTE rte = IOC.Resolve <IRTE>();
RuntimeWindow sceneWindow = rte.GetWindow(RuntimeWindowType.Scene);
m_renderTextureCamera.OutputRoot = (RectTransform)sceneWindow.transform;
m_renderTextureCamera.OverlayMaterial = new Material(Shader.Find("Battlehub/RTCommon/RenderTextureOverlay"));
m_graphicsLayerCamera.clearFlags = CameraClearFlags.SolidColor;
m_graphicsLayerCamera.backgroundColor = new Color(0, 0, 0, 0);
m_graphicsLayerCamera.gameObject.SetActive(wasActive);
}
internal override void Render(RenderingCameraInformation renderingCameraInformation)
#endif
{
var materialModule = _materialModule as WaterMaterialModule;
bool renderRefraction = materialModule.IsRefractionEnabled;
bool renderReflection = materialModule.IsReflectionEnabled;
var mainModule = _mainModule as WaterMainModule;
var largeWaterAreaManager = mainModule.LargeWaterAreaManager;
bool isConnectedToLargeWaterArea = largeWaterAreaManager != null;
ComputeVisibleAreas(!isConnectedToLargeWaterArea ? _meshModule.Bounds : largeWaterAreaManager.GetWaterObjectsBoundsRelativeToSpecifiedWaterObject(mainModule));
#if !GAME_2D_WATER_KIT_LWRP && !GAME_2D_WATER_KIT_URP
int pixelLightCount = QualitySettings.pixelLightCount;
if (!_renderPixelLights)
{
QualitySettings.pixelLightCount = 0;
}
#endif
_meshModule.SetRendererActive(false);
Color backgroundColor = renderingCameraInformation.CurrentCamera.backgroundColor;
backgroundColor.a = 1f;
bool isUsingOpaqueRenderQueue = _materialModule.RenderQueue == 2000;
if (renderRefraction && !isUsingOpaqueRenderQueue)
{
SetupRefractionMask();
}
#if GAME_2D_WATER_KIT_LWRP || GAME_2D_WATER_KIT_URP
_renderingContext = context;
#endif
if (!materialModule.IsFakePerspectiveEnabled)
{
if (renderRefraction)
{
if (!isUsingOpaqueRenderQueue)
{
SetRefractionMaskLayer(Refraction.GetValidRefractionMaskLayer());
}
ExecuteRendering(Refraction, _g2dwCamera, _wholeWaterVisibleArea, backgroundColor, _allowHDR, _allowMSAA);
materialModule.SetRefractionRenderTexture(Refraction.RenderTexture);
}
if (renderReflection)
{
_refractionMask.SetActive(false);
ExecuteRendering(Reflection, _g2dwCamera, _wholeWaterVisibleArea, _clearColor, _allowHDR, _allowMSAA);
materialModule.SetReflectionRenderTexture(Reflection.RenderTexture);
}
}
else
{
if (renderRefraction)
{
int extraLayersToIgnoreMask = RefractionPartiallySubmergedObjects.CullingMask;
if (!isUsingOpaqueRenderQueue)
{
SetRefractionMaskLayer(Refraction.GetValidRefractionMaskLayer(extraLayersToIgnoreMask));
}
ExecuteRendering(Refraction, _g2dwCamera, _wholeWaterVisibleArea, backgroundColor, _allowHDR, _allowMSAA, extraLayersToIgnoreMask);
materialModule.SetRefractionRenderTexture(Refraction.RenderTexture);
if (!isUsingOpaqueRenderQueue)
{
SetRefractionMaskLayer(RefractionPartiallySubmergedObjects.GetValidRefractionMaskLayer());
}
ExecuteRendering(RefractionPartiallySubmergedObjects, _g2dwCamera, _wholeWaterVisibleArea, _clearColor, _allowHDR, _allowMSAA);
materialModule.SetRefractionPartiallySubmergedObjectsRenderTexture(RefractionPartiallySubmergedObjects.RenderTexture);
}
if (renderReflection)
{
_refractionMask.SetActive(false);
ExecuteRendering(Reflection, _g2dwCamera, _surfaceVisibleArea, _clearColor, _allowHDR, _allowMSAA, ReflectionPartiallySubmergedObjects.CullingMask);
materialModule.SetReflectionRenderTexture(Reflection.RenderTexture);
ExecuteRendering(ReflectionPartiallySubmergedObjects, _g2dwCamera, _surfaceBelowSubmergeLevelVisibleArea, _clearColor, _allowHDR, _allowMSAA);
materialModule.SetReflectionPartiallySubmergedObjectsRenderTexture(ReflectionPartiallySubmergedObjects.RenderTexture);
}
}
_refractionMask.SetActive(false);
#if !GAME_2D_WATER_KIT_LWRP && !GAME_2D_WATER_KIT_URP
QualitySettings.pixelLightCount = pixelLightCount;
#endif
_meshModule.SetRendererActive(true);
var worldToVisibleAreaMatrix = Matrix4x4.TRS(_wholeWaterVisibleArea.RefractionProperties.Position, _wholeWaterVisibleArea.RefractionProperties.Rotation, new Vector3(1f, 1f, -1f)).inverse;
var projectionMatrix = _wholeWaterVisibleArea.RefractionProperties.ProjectionMatrix;
materialModule.SetWaterMatrix(projectionMatrix * worldToVisibleAreaMatrix * _mainModule.LocalToWorldMatrix);
materialModule.SetReflectionLowerLimit(_mainModule.Height * 0.5f);
materialModule.ValidateMaterialPropertyBlock();
if (isConnectedToLargeWaterArea)
{
SetCurrentFrameRenderInformationToLargeWaterAreaManager(largeWaterAreaManager, renderRefraction, renderReflection, projectionMatrix, worldToVisibleAreaMatrix, renderingCameraInformation.CurrentCamera);
}
}
internal override void Render(UnityEngine.Rendering.ScriptableRenderContext context, RenderingCameraInformation renderingCameraInformation)
internal void Render(UnityEngine.Rendering.ScriptableRenderContext context, Camera camera, WaterRenderingVisibleArea visibleArea, Color backgroundColor, bool hdr, bool msaa, int extraLayersToIgnoreMask = 0)
//----------------------------------------------------------------------------------------------------------------------
void OnEndCameraRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera cam) {
if (cam == GetCamera() && null != GetSrcTexture()) {
BlitToDest(null);
}
}
internal abstract void Render(UnityEngine.Rendering.ScriptableRenderContext context, RenderingCameraInformation renderingCameraInformation);
private void OnCameraRenderSRP(UnityEngine.Rendering.ScriptableRenderContext context, Camera cam)
{
OnCameraRender(cam);
}
private static void OnBeginFrameRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera[] cameras)
{
UnityEngine.Rendering.RenderPipelineManager.beginCameraRendering += _renderObjectsDelegate;
}
private void RenderPipelineOnBeginFrameRendering2(UnityEngine.Rendering.ScriptableRenderContext context, Camera[] obj)
{
_renderStartTime = _stopwatch.Elapsed.TotalSeconds;
}
void OnSrpCameraPreRender(UnityEngine.Rendering.ScriptableRenderContext context, Camera givenCamera)
{
//UpdateAction();
}
private void onBeginRendering(UnityEngine.Rendering.ScriptableRenderContext scriptableRenderContext, Camera camera)
{
OnCameraPreRender(camera);
}
private static void OnEndFrameRendering(UnityEngine.Rendering.ScriptableRenderContext context, Camera[] cameras)
{
UnityEngine.Rendering.RenderPipelineManager.beginCameraRendering -= RenderObjects;
}
private static void RenderObjects(UnityEngine.Rendering.ScriptableRenderContext context, Camera currentCamera)
void OnBeginCameraRenderingSRP(UnityEngine.Rendering.ScriptableRenderContext context, Camera cam)
public void BlitRenderStreamingRT(UnityEngine.Rendering.ScriptableRenderContext context, HDCamera cam)
{
Graphics.Blit(m_rtCamera.targetTexture, (RenderTexture)null);
}
