Esempio n. 1
0
        /// <summary>
        /// Render the reflections.
        /// </summary>
        void RenderReflectionFor(Camera cam, Camera reflectCamera, OceanCameraSettings settings)
        {
            //UpdateSkyBox(cam, reflectCamera);

            Vector3 eulerA = cam.transform.eulerAngles;

            reflectCamera.transform.eulerAngles = new Vector3(-eulerA.x, eulerA.y, eulerA.z);
            reflectCamera.transform.position    = cam.transform.position;

            float level = m_ocean.level;

            Vector3 pos    = new Vector3(0, level, 0);
            Vector3 normal = Vector3.up;

            float   d = -Vector3.Dot(normal, pos) - clipPlaneOffset;
            Vector4 reflectionPlane = new Vector4(normal.x, normal.y, normal.z, d);

            Matrix4x4 reflection = Matrix4x4.zero;

            reflection = CalculateReflectionMatrix(reflection, reflectionPlane);
            Vector3 oldPos = cam.transform.position;
            Vector3 newpos = reflection.MultiplyPoint(oldPos);

            reflectCamera.worldToCameraMatrix = cam.worldToCameraMatrix * reflection;

            Vector4 clipPlane = CameraSpacePlane(reflectCamera, pos, normal, 1.0f);

            Matrix4x4 projection = cam.projectionMatrix;

            projection = CalculateObliqueMatrix(projection, clipPlane);
            reflectCamera.projectionMatrix = projection;

            reflectCamera.transform.position = newpos;
            Vector3 euler = cam.transform.eulerAngles;

            reflectCamera.transform.eulerAngles = new Vector3(-euler.x, euler.y, euler.z);

            reflectCamera.cullingMask = GetReflectionLayermask(settings);
            reflectCamera.cullingMask = OceanUtility.HideLayer(reflectCamera.cullingMask, Ocean.OCEAN_LAYER);

            int oldPixelLightCount = QualitySettings.pixelLightCount;

            if (!pixelLightsInReflection)
            {
                QualitySettings.pixelLightCount = 0;
            }

            bool oldCulling = GL.invertCulling;

            GL.invertCulling = !oldCulling;

            reflectCamera.Render();

            QualitySettings.pixelLightCount = oldPixelLightCount;
            GL.invertCulling = oldCulling;
        }
Esempio n. 2
0
        private void RenderReflectionFor(Camera cam, Camera reflectCamera, OceanCameraSettings settings)
        {
            Vector3 eulerAngles = cam.transform.eulerAngles;

            reflectCamera.transform.eulerAngles = new Vector3(-eulerAngles.x, eulerAngles.y, eulerAngles.z);
            reflectCamera.transform.position    = cam.transform.position;
            float     level    = this.m_ocean.level;
            Vector3   vector   = new Vector3(0f, level, 0f);
            Vector3   up       = Vector3.up;
            float     w        = -Vector3.Dot(up, vector) - this.clipPlaneOffset;
            Vector4   plane    = new Vector4(up.x, up.y, up.z, w);
            Matrix4x4 matrix4x = Matrix4x4.zero;

            matrix4x = this.CalculateReflectionMatrix(matrix4x, plane);
            Vector3 position  = cam.transform.position;
            Vector3 position2 = matrix4x.MultiplyPoint(position);

            reflectCamera.worldToCameraMatrix = cam.worldToCameraMatrix * matrix4x;
            Vector4   clipPlane = this.CameraSpacePlane(reflectCamera, vector, up, 1f);
            Matrix4x4 matrix4x2 = cam.projectionMatrix;

            matrix4x2 = this.CalculateObliqueMatrix(matrix4x2, clipPlane);
            reflectCamera.projectionMatrix   = matrix4x2;
            reflectCamera.transform.position = position2;
            Vector3 eulerAngles2 = cam.transform.eulerAngles;

            reflectCamera.transform.eulerAngles = new Vector3(-eulerAngles2.x, eulerAngles2.y, eulerAngles2.z);
            reflectCamera.cullingMask           = this.GetReflectionLayermask(settings);
            reflectCamera.cullingMask           = OceanUtility.HideLayer(reflectCamera.cullingMask, Ocean.OCEAN_LAYER);
            int pixelLightCount = QualitySettings.pixelLightCount;

            if (!this.pixelLightsInReflection)
            {
                QualitySettings.pixelLightCount = 0;
            }
            bool invertCulling = GL.invertCulling;

            GL.invertCulling = !invertCulling;
            if (ForestVR.Enabled)
            {
            }
            reflectCamera.Render();
            QualitySettings.pixelLightCount = pixelLightCount;
            GL.invertCulling = invertCulling;
        }
Esempio n. 3
0
        /// <summary>
        /// Render the reflections.
        /// </summary>
        void RenderReflection(Camera reflectionCam, RenderTexture target, Vector3 position, Quaternion rotation, Matrix4x4 projection, OceanCameraSettings settings)
        {
            // Copy camera position/rotation/projection data into the reflectionCamera
            reflectionCam.ResetWorldToCameraMatrix();
            reflectionCam.transform.position = position;
            reflectionCam.transform.rotation = rotation;
            reflectionCam.projectionMatrix   = projection;
            reflectionCam.targetTexture      = target;

            float level = m_ocean.level;
            // find out the reflection plane: position and normal in world space
            Vector3 pos    = new Vector3(0, level, 0);
            Vector3 normal = Vector3.up;

            // Reflect camera around reflection plane
            Vector4 worldSpaceClipPlane = Plane(pos, normal);

            reflectionCam.worldToCameraMatrix *= CalculateReflectionMatrix(worldSpaceClipPlane);

            // Setup oblique projection matrix so that near plane is our reflection
            // plane. This way we clip everything behind it for free.
            Vector4 cameraSpaceClipPlane = CameraSpacePlane(reflectionCam, pos, normal);

            reflectionCam.projectionMatrix = reflectionCam.CalculateObliqueMatrix(cameraSpaceClipPlane);

            reflectionCam.cullingMask = GetReflectionLayermask(settings);
            reflectionCam.cullingMask = OceanUtility.HideLayer(reflectionCam.cullingMask, Ocean.OCEAN_LAYER);

            bool oldCulling = GL.invertCulling;

            GL.invertCulling = !oldCulling;

            NotifyOnEvent.Disable = true;
            reflectionCam.Render();
            NotifyOnEvent.Disable = false;

            GL.invertCulling = oldCulling;

            reflectionCam.targetTexture = null;
        }
Esempio n. 4
0
 public override void RenderOceanDepth(GameObject go)
 {
     try
     {
         if (base.enabled)
         {
             Camera current = Camera.current;
             if (!(current == null))
             {
                 CameraData cameraData = this.m_ocean.FindCameraData(current);
                 if (cameraData.depth == null)
                 {
                     cameraData.depth = new DepthData();
                 }
                 if (!cameraData.depth.updated)
                 {
                     if (this.GetDisableUnderwater(cameraData.settings))
                     {
                         Shader.DisableKeyword("CETO_UNDERWATER_ON");
                         cameraData.depth.updated = true;
                     }
                     else
                     {
                         Shader.EnableKeyword("CETO_UNDERWATER_ON");
                         if (SystemInfo.graphicsShaderLevel < 30)
                         {
                             Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME, Texture2D.whiteTexture);
                             Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
                             Shader.SetGlobalTexture(Ocean.NORMAL_FADE_TEXTURE_NAME, Texture2D.blackTexture);
                             Shader.SetGlobalMatrix("Ceto_Camera_IVP", (current.projectionMatrix * current.worldToCameraMatrix).inverse);
                             cameraData.depth.updated = true;
                         }
                         else if (this.depthMode == DEPTH_MODE.USE_DEPTH_BUFFER)
                         {
                             Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME, Texture2D.whiteTexture);
                             current.depthTextureMode |= DepthTextureMode.Depth;
                             current.depthTextureMode |= DepthTextureMode.DepthNormals;
                             Shader.SetGlobalMatrix("Ceto_Camera_IVP", (current.projectionMatrix * current.worldToCameraMatrix).inverse);
                             this.CreateRefractionCommand(current, cameraData.depth);
                             cameraData.depth.updated = true;
                         }
                         else if (this.depthMode == DEPTH_MODE.USE_OCEAN_DEPTH_PASS)
                         {
                             Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
                             Shader.SetGlobalTexture(Ocean.NORMAL_FADE_TEXTURE_NAME, Texture2D.blackTexture);
                             this.CreateDepthCameraFor(current, cameraData.depth);
                             this.CreateRefractionCommand(current, cameraData.depth);
                             cameraData.depth.cam.cullingMask = this.GetOceanDepthsLayermask(cameraData.settings);
                             cameraData.depth.cam.cullingMask = OceanUtility.HideLayer(cameraData.depth.cam.cullingMask, Ocean.OCEAN_LAYER);
                             NotifyOnEvent.Disable            = true;
                             cameraData.depth.cam.RenderWithShader(this.oceanDepthSdr, "RenderType");
                             NotifyOnEvent.Disable = false;
                             Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME, cameraData.depth.cam.targetTexture);
                             cameraData.depth.updated = true;
                         }
                     }
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
Esempio n. 5
0
        /// <summary>
        /// Render depth information about a object using a replacement shader.
        /// If the ocean renders into the depth buffer then the shader can not get
        /// depth info about what has been rendered under it as Unity will have already
        /// written the ocean mesh into depth buffer by then.
        /// Will also create the refraction grab if needed.
        /// </summary>
        public void RenderOceanDepth(GameObject go)
        {
            try
            {
                if (!enabled)
                {
                    return;
                }

                Camera cam = Camera.current;
                if (cam == null)
                {
                    return;
                }

                CameraData data = m_ocean.FindCameraData(cam);

                if (data.depth == null)
                {
                    data.depth = new DepthData();
                }

                if (data.depth.IsViewUpdated(cam))
                {
                    return;
                }

                //If this camera has disable the underwater turn it off in the shader and return.
                if (GetDisableUnderwater(data.settings))
                {
                    Shader.DisableKeyword("CETO_UNDERWATER_ON");
                    data.depth.SetViewAsUpdated(cam);
                    return;
                }
                else
                {
                    Shader.EnableKeyword("CETO_UNDERWATER_ON");
                }

                if (/*cam.name == "SceneCamera" ||*/ SystemInfo.graphicsShaderLevel < 30)
                {
                    //These texture will not be generated so zero to some that will not cause a issue if sampled.
                    Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME0, Texture2D.whiteTexture);
                    Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME1, Texture2D.whiteTexture);
                    Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
                    Shader.SetGlobalTexture(Ocean.NORMAL_FADE_TEXTURE_NAME, Texture2D.blackTexture);

                    //If not using the ocean depths all thats needed is the IVP
                    //to extract the world pos from the depth buffer.
                    BindIVPMatrix(cam.projectionMatrix, cam.worldToCameraMatrix);

                    data.depth.SetViewAsUpdated(cam);
                }
                else if (depthMode == DEPTH_MODE.USE_DEPTH_BUFFER)
                {
                    //These texture will not be generated so zero to some that will not cause a issue if sampled.
                    Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME0, Texture2D.whiteTexture);
                    Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME1, Texture2D.whiteTexture);

                    //Cam must have depth mode enabled to use depth buffer.
                    cam.depthTextureMode |= DepthTextureMode.Depth;
                    cam.depthTextureMode |= DepthTextureMode.DepthNormals;

                    CreateRefractionCommand(cam, data.depth);

                    //If not using the ocean depths all thats needed is the IVP
                    //to extract the world pos from the depth buffer.
                    BindIVPMatrix(cam.projectionMatrix, cam.worldToCameraMatrix);

                    data.depth.SetViewAsUpdated(cam);
                }
                else if (depthMode == DEPTH_MODE.USE_OCEAN_DEPTH_PASS)
                {
                    //These texture will not be generated so zero to some that will not cause a issue if sampled.
                    Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
                    Shader.SetGlobalTexture(Ocean.NORMAL_FADE_TEXTURE_NAME, Texture2D.blackTexture);

                    CreateDepthCameraFor(cam, data.depth);
                    CreateRefractionCommand(cam, data.depth);

                    data.depth.cam.cullingMask = GetOceanDepthsLayermask(data.settings);
                    data.depth.cam.cullingMask = OceanUtility.HideLayer(data.depth.cam.cullingMask, Ocean.OCEAN_LAYER);

                    if (cam.stereoEnabled)
                    {
                        RenderSteroOceanDepth(data.depth, cam);
                    }
                    else
                    {
                        Shader.DisableKeyword("CETO_STERO_CAMERA");
                        RenderOceanDepth(data.depth, data.depth.target0, cam.transform.position, cam.transform.rotation, cam.projectionMatrix);
                        Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME0, data.depth.target0);
                    }

                    data.depth.SetViewAsUpdated(cam);
                }
            }
            catch (Exception e)
            {
                Ocean.LogError(e.ToString());
                WasError = true;
                enabled  = false;
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Render depth information about a object using a replacement shader.
        /// If the ocean renders into the depth buffer then the shader can not get
        /// depth info about what has been rendered under it as Unity will have already
        /// written the ocean mesh into depth buffer by then.
        /// Will also create the refraction grab if needed.
        /// </summary>
        public override void RenderOceanDepth(GameObject go)
        {
            try
            {
                if (!enabled)
                {
                    return;
                }

                Camera cam = Camera.current;
                if (cam == null)
                {
                    return;
                }

                CameraData data = m_ocean.FindCameraData(cam);

                if (data.depth == null)
                {
                    data.depth = new DepthData();
                }

                if (data.depth.updated)
                {
                    return;
                }

                //zero the texture so if there is a issue the underwater effect will not screw up the rest of the rendering.
                Shader.SetGlobalTexture(Ocean.REFRACTION_GRAB_TEXTURE_NAME, Texture2D.blackTexture);
                Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
                Shader.SetGlobalTexture("Ceto_OceanDepth", Texture2D.whiteTexture);

                //If this camera has disable the underwater turn it off in the shader and return.
                if (GetDisableUnderwater(data.settings))
                {
                    Shader.DisableKeyword("CETO_UNDERWATER_ON");
                    data.depth.updated = true;
                    return;
                }
                else
                {
                    Shader.EnableKeyword("CETO_UNDERWATER_ON");
                }

                if (cam.name == "SceneCamera" || SystemInfo.graphicsShaderLevel < 30)
                {
                    //Adding command to scene camera is causing some problems and may as
                    //well not use the ocean depth pass so its consistent between modes
                    //so just bind something that wont cause a issue.

                    //If not using the ocean depths all thats needed is the IVP
                    //to extract the world pos from the depth buffer.
                    Matrix4x4 ivp = cam.projectionMatrix * cam.worldToCameraMatrix;
                    Shader.SetGlobalMatrix("Ceto_Camera_IVP", ivp.inverse);

                    data.depth.updated = true;
                }
                else if (depthMode == DEPTH_MODE.USE_DEPTH_BUFFER)
                {
                    //Cam must have depth mode enabled to use depth buffer.
                    cam.depthTextureMode |= DepthTextureMode.Depth;

                    //If not using the ocean depths all thats needed is the IVP
                    //to extract the world pos from the depth buffer.
                    Matrix4x4 ivp = cam.projectionMatrix * cam.worldToCameraMatrix;
                    Shader.SetGlobalMatrix("Ceto_Camera_IVP", ivp.inverse);

                    //Add the command to camera.
                    //The default implementation will just grab the depth and the screen.
                    CreateRefractionGrab(cam, data.depth);

                    data.depth.updated = true;
                }
                else if (depthMode == DEPTH_MODE.USE_OCEAN_DEPTH_PASS)
                {
                    CreateDepthCameraFor(cam, data.depth);
                    CreateRefractionGrab(cam, data.depth);

                    data.depth.cam.cullingMask = GetOceanDepthsLayermask(data.settings);
                    data.depth.cam.cullingMask = OceanUtility.HideLayer(data.depth.cam.cullingMask, Ocean.OCEAN_LAYER);

                    NotifyOnEvent.Disable = true;
                    data.depth.cam.RenderWithShader(oceanDepthSdr, "RenderType");
                    NotifyOnEvent.Disable = false;

                    Shader.SetGlobalTexture("Ceto_OceanDepth", data.depth.cam.targetTexture);

                    data.depth.updated = true;
                }
            }
            catch (Exception e)
            {
                Ocean.LogError(e.ToString());
                WasError = true;
                enabled  = false;
            }
        }