private void OnWillRenderObject()
{
if (isRending || data == null)
{
return;
}
var camera = Camera.current;
if (camera == null)
{
return;
}
OceanCameraTask oceanCamera;
if (RenderHelper.TryGetOceanCamera(camera, out oceanCamera))
{
isRending = true;
requestCamera = camera;
requestOceanCamera = oceanCamera;
oceanCamera.AddWillRenderOcean(this);
oceanCamera.AddUnderOceanMarkDrawer(this);
}
}
public void OnPreReflectionRender(OceanCameraTask oceanCamera)
{
if (IsHasUnderOceanEffect)
{
underOceanEffectDisposer = new UnderOceanModeOptions.DisableUnderOceanEffectScope();
}
}
public override PreparedContent OnPreOceanRender(OceanCameraTask oceanCamera, OceanVolume ocean)
{
Matrix4x4 worldToLightMatrix;
if (materialData.ModeObject.Mode.Cookie > 0 && oceanCamera.Data.SunLight != null)
{
var sunLightTransform = oceanCamera.Data.SunLight.transform;
worldToLightMatrix = Matrix4x4.TRS(sunLightTransform.position, sunLightTransform.rotation, materialData.Data.Cookie.Scale).inverse;
}
else
{
worldToLightMatrix = Matrix4x4.identity;
}
Shader.SetGlobalMatrix(UnderCookieOptions.WorldToCookieMatrixShaderID, worldToLightMatrix);
UnderOceanModeOptions.UpdateKeywords(materialData.ModeObject.Mode);
if (!UnderMaterialOptions.UpdateShaderFields(materialData.Data))
{
if (materialData.Data.Cookie.Texture != null)
{
Shader.SetGlobalTexture(UnderCookieOptions.TextureShaderFieldID, materialData.Data.Cookie.Texture.GetCurrentTexture());
}
}
if (ProjectSettings.Current.RenderQueue == OceanRenderQueue.Transparent)
{
UnderOceanModeOptions.DisableUnderOceanFogEffect();
}
Shader.SetGlobalVector(UnderMaterialOptions.UnderOceanPositionShaderID, new Vector4(0, ocean.Height, 0, 0));
return(PreparedContent.UnderOceanMarkTexture);
}
public void SetValueToShader(OceanCameraTask oceanCamera, CameraTaskRippleData rippleData)
{
ClearFinalRipples();
RippleFilter.Filter(oceanCamera, rippleData, observers, FinalRipples);
SetValue(FinalRipples, FinalRippleOptions);
RippleOptions.Accessor.SetGlobalValues(FinalRippleOptions);
}
internal void InternalRenderColorAndDepth(Camera camera, OceanCameraTask oceanCamera, DepthEffecttProjectSettings setting, PreparedContent renderContents)
{
var textureSize = RenderHelper.GetTextureSize(camera, setting.TextureScale);
var colorRenderTexture = RenderTexture.GetTemporary(textureSize.x, textureSize.y);
var depthRenderTexture = RenderTexture.GetTemporary(textureSize.x, textureSize.y, 24, RenderTextureFormat.Depth);
renderCamera.clearFlags = CameraClearFlags.Skybox;
renderCamera.renderingPath = setting.CameraRenderingPath;
RenderHelper.CopyCameraOptions(camera, renderCamera);
RenderHelper.SetLayerWithoutWater(renderCamera, setting.CullingMask & camera.cullingMask);
RenderHelper.CopySkyBox(oceanCamera, skybox);
renderCamera.transform.position = camera.transform.position;
renderCamera.transform.rotation = camera.transform.rotation;
using (new RenderHelper.PointLightsScope(setting.EnablePointLights))
{
oceanCamera.TaskController.OnPreRefractionRender(oceanCamera);
renderCamera.SetTargetBuffers(colorRenderTexture.colorBuffer, depthRenderTexture.depthBuffer);
renderCamera.Render();
renderCamera.targetTexture = null;
oceanCamera.TaskController.OnPostRefractionRender(oceanCamera);
}
RefractionTexture = colorRenderTexture;
RefractionDepthTexture = depthRenderTexture;
}
public static bool TryGetOceanCamera(Camera camera, out OceanCameraTask oceanCamera)
{
oceanCamera = camera.GetComponent <OceanCameraTask>();
if (oceanCamera == null)
{
oceanCamera = camera.gameObject.AddComponent <OceanCameraTask>();
}
return(true);
//oceanCamera = camera.GetComponent<OceanCameraTask>();
//if (oceanCamera != null)
//{
// return true;
//}
//else
//{
// if ((camera.hideFlags & HideFlags.HideAndDontSave) == 0)
// {
// oceanCamera = camera.gameObject.AddComponent<OceanCameraTask>();
// return true;
// }
// return false;
//}
}
public void OnPostReflectionRender(OceanCameraTask oceanCamera)
{
if (underOceanEffectDisposer != null)
{
underOceanEffectDisposer.Dispose();
underOceanEffectDisposer = null;
}
}
public DepthTextureMode RenderDepthOnlyWhenOpaque(Camera camera, OceanCameraTask data, DepthEffecttProjectSettings setting, PreparedContent renderContents)
{
RemoveCommandBufferColor(camera);
OceanIsOpaque();
InternalRenderDepthOnly(camera, data, setting, renderContents);
SetValuesToShader();
return(DepthTextureMode.None);
}
private void OnRenderObject()
{
if (Camera.current == requestCamera)
{
isRending = false;
requestCamera = null;
requestOceanCamera = null;
}
}
protected virtual void CollectOceanInfos(OceanCameraTask oceanCamera)
{
for (int i = 0; i < oceanCamera.WillRenderOceans.Count; i++)
{
var ocean = oceanCamera.WillRenderOceans[i];
var current = ocean.GetRenderContents(oceanCamera);
PreparedContents |= current;
}
}
public DepthTextureMode Render(Camera camera, OceanCameraTask oceanCamera, ICameraTaskData data)
{
var quality = oceanCamera.projectSetting.Reflection;
if ((data.PreparedContents & PreparedContent.ReflectionTexture) != 0)
{
InternalRender(camera, oceanCamera, quality, data);
}
return(DepthTextureMode.None);
}
internal void InternalRender(Camera camera, OceanCameraTask oceanCamera, ReflectionProjectSetting setting, ICameraTaskData data)
{
if (camera.orthographic)
{
return;
}
var textureSize = RenderHelper.GetTextureSize(camera, setting.TextureScale);
var reflectionRenderTexture = RenderTexture.GetTemporary(textureSize.x, textureSize.y);
renderCamera.renderingPath = setting.RenderingPath;
RenderHelper.CopyCameraOptions(camera, renderCamera);
RenderHelper.SetLayerWithoutWater(renderCamera, setting.CullingMask);
RenderHelper.CopySkyBox(oceanCamera, skybox);
{
Vector3 pos = new Vector3(0, data.Height, 0);
Vector3 normal = data.Normal;
// Reflect camera around reflection plane
float d = -Vector3.Dot(normal, pos) - clipPlaneOffset;
Vector4 reflectionPlane = new Vector4(normal.x, normal.y, normal.z, d);
Matrix4x4 reflection = Matrix4x4.zero;
CalculateReflectionMatrix(ref reflection, reflectionPlane);
renderCamera.transform.position = reflection.MultiplyPoint(camera.transform.position);
renderCamera.worldToCameraMatrix = camera.worldToCameraMatrix * reflection;
// Setup oblique projection matrix so that near plane is our reflection
// plane. This way we clip everything below/above it for free.
Vector4 clipPlane = CameraSpacePlane(renderCamera, pos, normal, 1.0f);
renderCamera.projectionMatrix = camera.CalculateObliqueMatrix(clipPlane);
//// Set custom culling matrix from the current camera
renderCamera.cullingMatrix = camera.projectionMatrix * camera.worldToCameraMatrix;
Vector3 euler = camera.transform.eulerAngles;
renderCamera.transform.eulerAngles = new Vector3(-euler.x, euler.y, euler.z);
}
using (new RenderHelper.InvertCullingScope())
{
using (new RenderHelper.PointLightsScope(setting.EnablePointLights))
{
oceanCamera.TaskController.OnPreReflectionRender(oceanCamera);
renderCamera.targetTexture = reflectionRenderTexture;
renderCamera.Render();
renderCamera.targetTexture = null;
oceanCamera.TaskController.OnPostReflectionRender(oceanCamera);
}
}
ReflectionTexture = reflectionRenderTexture;
SetValuesToShader();
}
public static bool TryGet(OceanCameraTask oceanCamera, out OceanVolume result)
{
if (activated.Count != 0)
{
result = activated[0];
return(true);
}
result = default;
return(false);
}
protected virtual void CollectUnderOceanInfos(OceanCameraTask oceanCamera, OceanVolume ocean)
{
if (oceanCamera.EnableUnderOceanEffect)
{
if (ocean.EnableUnderOcean && ocean.UnderOceanData != null)
{
PreparedContents |= ocean.UnderOceanData.OnPreOceanRender(oceanCamera, ocean);
IsHasUnderOceanEffect = true;
return;
}
}
UnderOceanModeOptions.DisableUnderOceanEffectAll();
}
public void SetValueToShader(OceanCameraTask oceanCamera, FoamCameraData data, PreparedContent preparedContent)
{
if (ProjectSettings.Current.Foam.EnabledFoamShpereCulling)
{
if ((preparedContent & PreparedContent.Foam16) != 0)
{
SetValueToShader(oceanCamera, data, 16, 4);
}
else if ((preparedContent & PreparedContent.Foam8) != 0)
{
SetValueToShader(oceanCamera, data, 8, 2);
}
}
}
public static void CopySkyBox(OceanCameraTask source, Skybox skybox)
{
if (source.ThisCamera.clearFlags == CameraClearFlags.Skybox)
{
Skybox sourceSkyBox = source.Skybox;
if (sourceSkyBox != null && sourceSkyBox.material != null)
{
skybox.enabled = true;
skybox.material = sourceSkyBox.material;
return;
}
}
skybox.enabled = false;
}
internal void AddCommandBufferColor(Camera camera, OceanCameraTask data)
{
if (!isAddCameraColor)
{
if (colorCommandBuffer == null)
{
colorCommandBuffer = new CommandBuffer();
colorCommandBuffer.name = "Refraction ocean color";
int screenCopy = Shader.PropertyToID("ScreenCopy");
colorCommandBuffer.GetTemporaryRT(screenCopy, -1, -1, 0, FilterMode.Bilinear);
colorCommandBuffer.Blit(BuiltinRenderTextureType.CurrentActive, screenCopy);
colorCommandBuffer.SetGlobalTexture(RefractionTextureShaderID, screenCopy);
}
isAddCameraColor = true;
camera.AddCommandBuffer(colorCameraEvent, colorCommandBuffer);
}
}
public virtual void OnPreOceanRender(OceanCameraTask oceanCamera)
{
SunLight = GetSunlight();
CollectOceanInfos(oceanCamera);
OceanVolume ocean;
if (OceanVolume.TryGet(oceanCamera, out ocean))
{
Height = ocean.Height;
Normal = ocean.Normal;
CollectUnderOceanInfos(oceanCamera, ocean);
}
else
{
Height = 0;
Normal = Vector3.up;
UnderOceanModeOptions.DisableUnderOceanEffectAll();
}
Shader.SetGlobalFloat(OceanShaderOptions.TimeShaderID, OceanTime);
if ((PreparedContents & PreparedContent.SunLight) != 0 && SunLight != null)
{
Vector4 pos = SunLight.transform.eulerAngles;
pos.w = Vector3.Dot(new Vector3(0, -1, 0), SunLight.transform.forward);
Shader.SetGlobalVector(OceanShaderOptions.SunLightShaderID, pos);
Shader.SetGlobalColor(OceanShaderOptions.SunLightColorShaderID, SunLight.color);
}
if ((PreparedContents & PreparedContent.Ripple) != 0)
{
RippleSystem.Current.SetValueToShader(oceanCamera, new CameraTaskRippleData()
{
OceanHeight = Height
});
}
FoamShpereSystem.Current.SetValueToShader(oceanCamera, FoamData, PreparedContents);
FoamAreaSystem.Current.SetValueToShader(oceanCamera, PreparedContents);
}
private void OnWillRenderObject()
{
var camera = Camera.current;
if (camera == null)
{
return;
}
OceanCameraTask oceanCamera = camera.GetComponent <OceanCameraTask>();
if (oceanCamera != null)
{
if (markMaterial == null)
{
Debug.LogError(new ArgumentNullException(nameof(markMaterial)), this);
return;
}
UpdateMarkPosition(camera.transform);
oceanCamera.AddUnderOceanMarkDrawer(this);
}
}
public DepthTextureMode Render(Camera camera, OceanCameraTask oceanCamera, PreparedContent renderContents)
{
try
{
if (((renderContents & PreparedContent.UnderOceanMarkTexture) == 0) || (underOceanMarkDrawers.Count == 0 && underOceanMarkObservers.Count == 0))
{
Shader.SetGlobalTexture(UnderOceanMarkTextureShaderID, BlackTexture.Value);
Shader.SetGlobalTexture(UnderOceanMarkDepthTextureShaderID, BlackTexture.Value);
return(DepthTextureMode.None);
}
CameraTaskEvent eventValue = new CameraTaskEvent(renderCamera, oceanCamera, oceanCamera.projectSetting.MarkLayer);
NotifyObservers(underOceanMarkDrawers, eventValue);
NotifyObservers(underOceanMarkObservers, eventValue);
var textureSize = RenderHelper.GetTextureSize(camera, oceanCamera.projectSetting.UnderOceanMark.TextureScale);
UnderOceanMarkTexture = RenderTexture.GetTemporary(textureSize.x, textureSize.y);
UnderOceanMarkDepthTexture = RenderTexture.GetTemporary(textureSize.x, textureSize.y, 24, RenderTextureFormat.Depth);
RenderHelper.CopyCameraOptions(camera, renderCamera);
renderCamera.cullingMask = oceanCamera.projectSetting.MarkCullingMask;
renderCamera.transform.position = camera.transform.position;
renderCamera.transform.rotation = camera.transform.rotation;
renderCamera.SetTargetBuffers(UnderOceanMarkTexture.colorBuffer, UnderOceanMarkDepthTexture.depthBuffer);
renderCamera.Render();
renderCamera.targetTexture = null;
SetValuesToShader();
return(DepthTextureMode.None);
}
finally
{
underOceanMarkDrawers.Clear();
}
}
public DepthTextureMode Render(Camera camera, OceanCameraTask data, PreparedContent renderContents)
{
var quality = data.projectSetting.DepthEffect;
if ((renderContents & PreparedContent.RefractionTexture) != 0)
{
switch (quality.RenderMode)
{
case DepthEffectRenderMode.Camera:
return(RenderWhenOpaque(camera, data, quality, renderContents));
case DepthEffectRenderMode.Buffer:
return(RenderWhenTransparent(camera, data));
default:
Debug.LogError(new ArgumentOutOfRangeException(nameof(quality.RenderMode), quality.RenderMode, "Unkonw value"), camera);
return(DepthTextureMode.None);
}
}
else if ((renderContents & PreparedContent.RefractionDepthTexture) != 0)
{
switch (quality.RenderMode)
{
case DepthEffectRenderMode.Buffer:
return(RenderDepthOnlyWhenTransparent(camera, data));
case DepthEffectRenderMode.Camera:
return(RenderDepthOnlyWhenOpaque(camera, data, quality, renderContents));
default:
Debug.LogError(new ArgumentOutOfRangeException(nameof(quality.RenderMode), quality.RenderMode, "Unkonw value"), camera);
return(DepthTextureMode.None);
}
}
return(DepthTextureMode.None);
}
public void SetValueToShader(OceanCameraTask oceanCamera, PreparedContent preparedContent)
{
if ((preparedContent & PreparedContent.FoamArea1) != 0)
{
if (observers.Count == 0)
{
ResetShader();
return;
}
else if (observers.Count == 1)
{
SetValueToShader(observers[0]);
}
else
{
Vector3 cameraPos = oceanCamera.transform.position;
IFoamArea min = observers[0];
float minDis = Vector3.Distance(cameraPos, min.Position);
for (int i = 1; i < observers.Count; i++)
{
var current = observers[i];
var currentDis = Vector3.Distance(cameraPos, current.Position);
if (currentDis < minDis)
{
min = current;
minDis = currentDis;
}
}
SetValueToShader(min);
}
}
}
public abstract void OnPostOceanRender(OceanCameraTask oceanCamera);
public abstract PreparedContent OnPreOceanRender(OceanCameraTask oceanCamera, OceanVolume ocean);
private void OnEnable()
{
unsubscriber = OceanCameraTask.SubscribeClipMarkDraw(this);
}
void IRippleData.OnSelecte(OceanCameraTask camera)
{
Texture = frameAnimation.GetCurrentTexture();
}
bool IRippleData.OnEnter(OceanCameraTask camera)
{
return(frameAnimation != null);
}
public abstract PreparedContent GetRenderContents(OceanCameraTask oceanCamera);
public DepthTextureMode RenderDepthOnlyWhenTransparent(Camera camera, OceanCameraTask data)
{
RemoveCommandBufferColor(camera);
OceanIsTransparent();
return(DepthTextureMode.Depth);
}
public override PreparedContent GetRenderContents(OceanCameraTask oceanCamera)
{
PreparedContent preparedContents = Data.GetRenderContents(lodLevel);
return(preparedContents);
}