コード例 #1
0
 private void ApplyProjection(GameObject go)
 {
     try
     {
         if (base.enabled)
         {
             Camera current = Camera.current;
             if (!(current == null))
             {
                 CameraData cameraData = this.m_ocean.FindCameraData(current);
                 if (cameraData.projection == null)
                 {
                     cameraData.projection = new ProjectionData();
                 }
                 if (!cameraData.projection.updated)
                 {
                     this.m_ocean.Projection.UpdateProjection(current, cameraData, this.m_ocean.ProjectSceneView);
                     Shader.SetGlobalMatrix("Ceto_Interpolation", cameraData.projection.interpolation);
                     Shader.SetGlobalMatrix("Ceto_ProjectorVP", cameraData.projection.projectorVP);
                 }
                 if (!cameraData.projection.checkedForFlipping)
                 {
                     int num  = 2;
                     int num2 = 1;
                     if (!Ocean.DISABLE_PROJECTION_FLIPPING)
                     {
                         bool isFlipped = this.m_ocean.Projection.IsFlipped;
                         if (this.oceanTopSideMat != null)
                         {
                             this.oceanTopSideMat.SetInt("_CullFace", (!isFlipped) ? num : num2);
                         }
                         if (this.oceanUnderSideMat != null)
                         {
                             this.oceanUnderSideMat.SetInt("_CullFace", (!isFlipped) ? num2 : num);
                         }
                     }
                     else
                     {
                         if (this.oceanTopSideMat != null)
                         {
                             this.oceanTopSideMat.SetInt("_CullFace", num);
                         }
                         if (this.oceanUnderSideMat != null)
                         {
                             this.oceanUnderSideMat.SetInt("_CullFace", num2);
                         }
                     }
                     cameraData.projection.checkedForFlipping = true;
                 }
                 this.UpdateBounds(go, current);
             }
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #2
0
        void Start()
        {
            try
            {
                //Needs at least SM3 for vertex texture fetches.
                if (SystemInfo.graphicsShaderLevel < 30)
                {
                    throw new InvalidOperationException("The projected grids needs at least SM3 to render.");
                }

                if (oceanTopSideMat == null)
                {
                    Ocean.LogWarning("Top side material is null. There will be no top ocean mesh rendered");
                }

                if (oceanUnderSideMat == null)
                {
                    Ocean.LogWarning("Under side material is null. There will be no under ocean mesh rendered");
                }
            }
            catch (Exception e)
            {
                Ocean.LogError(e.ToString());
                WasError = true;
                enabled  = false;
            }
        }
コード例 #3
0
ファイル: Ocean.cs プロジェクト: DevZhav/The-Forest
 private void Awake()
 {
     try
     {
         if (Ocean.Instance != null)
         {
             throw new InvalidOperationException("There can only be one ocean instance.");
         }
         Ocean.Instance     = this;
         this.WindDirVector = this.CalculateWindDirVector();
         if (this.doublePrecisionProjection)
         {
             this.Projection = new Projection3d(this);
         }
         else
         {
             this.Projection = new Projection3f(this);
         }
         this.OceanTime        = new OceanTime();
         this.m_waveOverlayMat = new Material(this.waveOverlaySdr);
         this.OverlayManager   = new OverlayManager(this.m_waveOverlayMat);
         this.m_scheduler      = new Scheduler();
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.DisableOcean();
     }
 }
コード例 #4
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
 private void Start()
 {
     try
     {
         Shader.SetGlobalTexture("Ceto_SlopeMap0", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_SlopeMap1", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap0", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap1", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap2", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap3", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_FoamMap0", Texture2D.blackTexture);
         this.m_slopeCopyMat        = new Material(this.slopeCopySdr);
         this.m_displacementCopyMat = new Material(this.displacementCopySdr);
         this.m_foamCopyMat         = new Material(this.foamCopySdr);
         this.m_slopeInitMat        = new Material(this.initSlopeSdr);
         this.m_displacementInitMat = new Material(this.initDisplacementSdr);
         this.m_foamInitMat         = new Material(this.initJacobianSdr);
         this.m_conditionCache      = new DictionaryQueue <WaveSpectrumConditionKey, WaveSpectrumCondition>();
         this.m_scheduler           = new Scheduler();
         this.CreateBuffers();
         this.CreateRenderTextures();
         this.CreateConditions();
         this.UpdateQueryScaling();
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #5
0
        protected override void OnEnable()
        {
            base.OnEnable();

            if (WasError)
            {
                return;
            }

            try
            {
                // If enabled activate all meshes.
                var e = m_grids.GetEnumerator();
                while (e.MoveNext())
                {
                    Grid grid = e.Current.Value;
                    Activate(grid.top, true);
                    Activate(grid.under, true);
                }
            }
            catch (Exception e)
            {
                Ocean.LogError(e.ToString());
                WasError = true;
                enabled  = false;
            }
        }
コード例 #6
0
 private void Start()
 {
     try
     {
         Mesh mesh = this.CreateBottomMesh(32, 512);
         this.m_bottomMask = new GameObject("Ceto Bottom Mask Gameobject");
         MeshFilter         meshFilter         = this.m_bottomMask.AddComponent <MeshFilter>();
         MeshRenderer       meshRenderer       = this.m_bottomMask.AddComponent <MeshRenderer>();
         NotifyOnWillRender notifyOnWillRender = this.m_bottomMask.AddComponent <NotifyOnWillRender>();
         meshFilter.sharedMesh             = mesh;
         meshRenderer.receiveShadows       = false;
         meshRenderer.shadowCastingMode    = ShadowCastingMode.Off;
         meshRenderer.reflectionProbeUsage = ReflectionProbeUsage.Off;
         meshRenderer.material             = new Material(this.oceanBottomSdr);
         notifyOnWillRender.AddAction(new Action <GameObject>(this.m_ocean.RenderWaveOverlays));
         notifyOnWillRender.AddAction(new Action <GameObject>(this.m_ocean.RenderOceanMask));
         notifyOnWillRender.AddAction(new Action <GameObject>(this.m_ocean.RenderOceanDepth));
         this.m_bottomMask.layer     = LayerMask.NameToLayer(Ocean.OCEAN_LAYER);
         this.m_bottomMask.hideFlags = HideFlags.HideAndDontSave;
         this.UpdateBottomBounds();
         UnityEngine.Object.Destroy(mesh);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #7
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
 protected override void OnDestroy()
 {
     base.OnDestroy();
     try
     {
         if (this.m_scheduler != null)
         {
             this.m_scheduler.ShutingDown = true;
             this.m_scheduler.CancelAllTasks();
         }
         if (this.m_conditionCache != null)
         {
             foreach (WaveSpectrumCondition current in this.m_conditionCache)
             {
                 current.Release();
             }
             this.m_conditionCache.Clear();
             this.m_conditionCache = null;
         }
         this.Release();
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #8
0
 protected override void OnEnable()
 {
     base.OnEnable();
     if (base.WasError)
     {
         return;
     }
     try
     {
         Dictionary <MESH_RESOLUTION, ProjectedGrid.Grid> .Enumerator enumerator = this.m_grids.GetEnumerator();
         while (enumerator.MoveNext())
         {
             KeyValuePair <MESH_RESOLUTION, ProjectedGrid.Grid> current = enumerator.Current;
             ProjectedGrid.Grid value = current.Value;
             this.Activate(value.top, true);
             this.Activate(value.under, true);
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #9
0
ファイル: Ocean.cs プロジェクト: DevZhav/The-Forest
 private void OnDestroy()
 {
     try
     {
         Ocean.Instance = null;
         if (this.OverlayManager != null)
         {
             this.OverlayManager.Release();
         }
         if (this.m_scheduler != null)
         {
             this.m_scheduler.ShutingDown = true;
             this.m_scheduler.CancelAllTasks();
         }
         List <Camera> list = new List <Camera>(this.m_cameraData.Keys);
         foreach (Camera cam in list)
         {
             this.RemoveCameraData(cam);
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.DisableOcean();
     }
 }
コード例 #10
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
        public void CreateAndCacheCondition(int fourierSize, float windSpeed, float windDir, float waveAge)
        {
            if (this.m_conditionCache == null)
            {
                return;
            }
            if (this.m_conditionCache.Count >= this.m_maxConditionCacheSize)
            {
                Ocean.LogWarning("Condition cache full. Condition not cached.");
                return;
            }
            if (!Mathf.IsPowerOfTwo(fourierSize) || fourierSize < 32 || fourierSize > 512)
            {
                Ocean.LogWarning("Fourier size must be a pow2 number from 32 to 512. Condition not cached.");
                return;
            }
            WaveSpectrumCondition waveSpectrumCondition = this.NewSpectrumCondition(fourierSize, windSpeed, windDir, waveAge);

            if (this.m_conditionCache.ContainsKey(waveSpectrumCondition.Key))
            {
                return;
            }
            IThreadedTask createSpectrumConditionTask = waveSpectrumCondition.GetCreateSpectrumConditionTask();

            createSpectrumConditionTask.Start();
            createSpectrumConditionTask.Run();
            createSpectrumConditionTask.End();
            this.m_conditionCache.AddFirst(waveSpectrumCondition.Key, waveSpectrumCondition);
        }
コード例 #11
0
        /// <summary>
        /// For textures that require their contents to be
        /// sampled check to see if read/write is enabled.
        /// </summary>
        protected void CheckCanSampleTex(Texture tex, string name)
        {
            if (tex == null)
            {
                return;
            }

            if (!(tex is Texture2D))//OYM:  新技巧get
            {
                Ocean.LogWarning("Can not query overlays " + name + " if texture is not Texture2D");
                return;
            }

            Texture2D t = tex as Texture2D;

            //Is there a better way to do this?
            try
            {
                Color c = t.GetPixel(0, 0);
            }
            catch
            {
                Ocean.LogWarning("Can not query overlays " + name + " if read/write is not enabled");
            }
        }
コード例 #12
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
        private void GetFourierSize(out int size, out bool isCpu)
        {
            switch (this.fourierSize)
            {
            case FOURIER_SIZE.LOW_32_CPU:
                size  = 32;
                isCpu = true;
                break;

            case FOURIER_SIZE.LOW_32_GPU:
                size  = 32;
                isCpu = false;
                break;

            case FOURIER_SIZE.MEDIUM_64_CPU:
                size  = 64;
                isCpu = true;
                break;

            case FOURIER_SIZE.MEDIUM_64_GPU:
                size  = 64;
                isCpu = false;
                break;

            case FOURIER_SIZE.HIGH_128_CPU:
                size  = 128;
                isCpu = true;
                break;

            case FOURIER_SIZE.HIGH_128_GPU:
                size  = 128;
                isCpu = false;
                break;

            case FOURIER_SIZE.ULTRA_256_GPU:
                size  = 256;
                isCpu = false;
                break;

            case FOURIER_SIZE.EXTREME_512_GPU:
                size  = 512;
                isCpu = false;
                break;

            default:
                size  = 64;
                isCpu = true;
                break;
            }
            bool flag = SystemInfo.graphicsShaderLevel >= 50 && SystemInfo.supportsComputeShaders;

            if (!isCpu && !this.disableReadBack && !flag)
            {
                Ocean.LogWarning("You card does not support dx11. Fourier can not be GPU. Changing to CPU. Disable read backs to use GPU but with no height querys.");
                this.fourierSize = FOURIER_SIZE.MEDIUM_64_CPU;
                size             = 64;
                isCpu            = true;
            }
        }
コード例 #13
0
        void ExportMask(float[] data, int size, int resolution, string name, DateTime stamp, float spread, bool isClip, bool isReadable)
        {
            //Create interpolated array from data so the mask resolution does not need to match the terrain height map size.
            InterpolatedArray2f heightMap = new InterpolatedArray2f(data, size, size, 1, false);

            //Create the path name to save mask.
            string fileName = string.Format("{0}-{1:yyyyMMdd-HHmmss}.png", name, stamp);
            string path     = System.IO.Path.Combine(Application.dataPath, fileName);

            path = path.Replace('\\', '/');

            Texture2D mask = null;

            //Create the mask texture. Clip masks are created slightly different.
            if (isClip)
            {
                mask = ShoreMaskGenerator.CreateClipMask(heightMap, resolution, resolution, m_oceanLevel + spread, TextureFormat.ARGB32);
            }
            else
            {
                mask = ShoreMaskGenerator.CreateMask(heightMap, resolution, resolution, m_oceanLevel, spread, TextureFormat.ARGB32);
            }

            //Save the texture.
            byte[] bytes = mask.EncodeToPNG();
            System.IO.File.WriteAllBytes(path, bytes);

            DestroyImmediate(mask);

            string relativePath = "Assets/" + fileName;

            //Update asset data base with new mask texture.
            AssetDatabase.ImportAsset(relativePath, ImportAssetOptions.ForceUpdate);

            //Create a importer from the texture so some of its settings can be changed.
            AssetImporter   tmp      = TextureImporter.GetAtPath(relativePath);
            TextureImporter importer = tmp as TextureImporter;

            if (importer != null)
            {
                //Change some of the settings of textures.
                //Should always be bilinear clamped with no mipmaps.
                //Height and clip masks should also be readable.
                importer.wrapMode      = TextureWrapMode.Clamp;
                importer.filterMode    = FilterMode.Bilinear;
                importer.textureType   = TextureImporterType.Default;
                importer.mipmapEnabled = false;
                importer.isReadable    = isReadable;

                AssetDatabase.ImportAsset(relativePath, ImportAssetOptions.ForceUpdate);
            }
            else
            {
                string msg = string.Format("{0:MM/dd/yy H:mm:ss zzz} - Failed to modify texture settings after creation. You will need to manually adjust texture settings.", DateTime.Now);
                Ocean.LogInfo(msg);
            }
        }
コード例 #14
0
ファイル: Ocean.cs プロジェクト: DevZhav/The-Forest
 public void RenderWaveOverlays(GameObject go)
 {
     try
     {
         if (base.enabled)
         {
             Camera current = Camera.current;
             if (!this.m_cameraData.ContainsKey(current))
             {
                 this.m_cameraData.Add(current, new CameraData());
             }
             CameraData cameraData = this.m_cameraData[current];
             if (cameraData.overlay == null)
             {
                 cameraData.overlay = new WaveOverlayData();
             }
             if (cameraData.projection == null)
             {
                 cameraData.projection = new ProjectionData();
             }
             if (!cameraData.overlay.updated)
             {
                 if (!cameraData.projection.updated)
                 {
                     this.Projection.UpdateProjection(current, cameraData, this.ProjectSceneView);
                     Shader.SetGlobalMatrix("Ceto_Interpolation", cameraData.projection.interpolation);
                     Shader.SetGlobalMatrix("Ceto_ProjectorVP", cameraData.projection.projectorVP);
                 }
                 if (this.GetDisableAllOverlays(cameraData.settings))
                 {
                     this.OverlayManager.DestroyBuffers(cameraData.overlay);
                     Shader.SetGlobalTexture("Ceto_Overlay_NormalMap", Texture2D.blackTexture);
                     Shader.SetGlobalTexture("Ceto_Overlay_HeightMap", Texture2D.blackTexture);
                     Shader.SetGlobalTexture("Ceto_Overlay_FoamMap", Texture2D.blackTexture);
                     Shader.SetGlobalTexture("Ceto_Overlay_ClipMap", Texture2D.blackTexture);
                 }
                 else
                 {
                     OVERLAY_MAP_SIZE overlay_MAP_SIZE  = (!(cameraData.settings != null)) ? this.normalOverlaySize : cameraData.settings.normalOverlaySize;
                     OVERLAY_MAP_SIZE overlay_MAP_SIZE2 = (!(cameraData.settings != null)) ? this.heightOverlaySize : cameraData.settings.heightOverlaySize;
                     OVERLAY_MAP_SIZE overlay_MAP_SIZE3 = (!(cameraData.settings != null)) ? this.foamOverlaySize : cameraData.settings.foamOverlaySize;
                     OVERLAY_MAP_SIZE overlay_MAP_SIZE4 = (!(cameraData.settings != null)) ? this.clipOverlaySize : cameraData.settings.clipOverlaySize;
                     this.OverlayManager.CreateOverlays(current, cameraData.overlay, overlay_MAP_SIZE, overlay_MAP_SIZE2, overlay_MAP_SIZE3, overlay_MAP_SIZE4);
                     this.OverlayManager.HeightOverlayBlendMode = this.heightBlendMode;
                     this.OverlayManager.FoamOverlayBlendMode   = this.foamBlendMode;
                     this.OverlayManager.RenderWaveOverlays(current, cameraData.overlay);
                 }
                 cameraData.overlay.updated = true;
             }
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.DisableOcean();
     }
 }
コード例 #15
0
 public override void RenderOceanMask(GameObject go)
 {
     try
     {
         if (base.enabled)
         {
             if (!(this.oceanMaskSdr == null))
             {
                 if (this.underwaterMode != UNDERWATER_MODE.ABOVE_ONLY)
                 {
                     Camera current = Camera.current;
                     if (!(current == null))
                     {
                         CameraData cameraData = this.m_ocean.FindCameraData(current);
                         if (cameraData.mask == null)
                         {
                             cameraData.mask = new MaskData();
                         }
                         if (!cameraData.mask.updated)
                         {
                             if (current.name == "SceneCamera" || current.GetComponent <UnderWaterPostEffect>() == null || SystemInfo.graphicsShaderLevel < 30 || this.GetDisableUnderwater(cameraData.settings))
                             {
                                 Shader.SetGlobalTexture(Ocean.OCEAN_MASK_TEXTURE_NAME, Texture2D.blackTexture);
                                 cameraData.mask.updated          = true;
                                 cameraData.mask.updatedLastFrame = true;
                             }
                             else
                             {
                                 this.CreateMaskCameraFor(current, cameraData.mask);
                                 this.FitBottomToCamera();
                                 NotifyOnEvent.Disable = true;
                                 if (this.m_ocean.Projection.IsFlipped)
                                 {
                                     cameraData.mask.cam.RenderWithShader(this.oceanMaskFlippedSdr, "OceanMask");
                                 }
                                 else
                                 {
                                     cameraData.mask.cam.RenderWithShader(this.oceanMaskSdr, "OceanMask");
                                 }
                                 NotifyOnEvent.Disable = false;
                                 Shader.SetGlobalTexture(Ocean.OCEAN_MASK_TEXTURE_NAME, cameraData.mask.cam.targetTexture);
                                 cameraData.mask.updated          = true;
                                 cameraData.mask.updatedLastFrame = true;
                             }
                         }
                     }
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #16
0
ファイル: Projection3f.cs プロジェクト: DevZhav/The-Forest
 public Projection3f(Ocean ocean)
 {
     this.m_ocean          = ocean;
     this.m_projectorP     = default(Matrix4x4);
     this.m_projectorV     = default(Matrix4x4);
     this.m_projectorR     = Matrix4x4.identity;
     this.m_projectorI     = default(Matrix4x4);
     this.m_pointList      = new List <Vector3>(12);
     this.m_frustumCorners = new Vector3[8];
 }
コード例 #17
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
        private void GenerateFoam(float time)
        {
            Vector4 vector = this.Choppyness;

            if (!this.disableFoam && SystemInfo.graphicsShaderLevel < 30)
            {
                Ocean.LogWarning("Spectrum foam needs at least SM3 to run. Disabling foam.");
                this.disableFoam = true;
            }
            float sqrMagnitude = vector.sqrMagnitude;

            this.m_jacobianBuffer.EnableBuffer(-1);
            if (this.disableFoam || this.foamAmount == 0f || sqrMagnitude == 0f || !this.m_conditions[0].SupportsJacobians)
            {
                this.m_jacobianBuffer.DisableBuffer(-1);
            }
            if (this.m_jacobianBuffer.EnabledBuffers() == 0)
            {
                Shader.SetGlobalTexture("Ceto_FoamMap0", Texture2D.blackTexture);
            }
            else
            {
                int numGrids = this.m_conditions[0].Key.NumGrids;
                if (numGrids == 1)
                {
                    this.m_jacobianBuffer.DisableBuffer(1);
                    this.m_jacobianBuffer.DisableBuffer(2);
                }
                else if (numGrids == 2)
                {
                    this.m_jacobianBuffer.DisableBuffer(2);
                }
                if (!this.m_jacobianBuffer.HasRun || this.m_jacobianBuffer.TimeValue != time)
                {
                    this.m_foamInitMat.SetFloat("Ceto_FoamAmount", this.foamAmount);
                    this.m_jacobianBuffer.InitMaterial = this.m_foamInitMat;
                    this.m_jacobianBuffer.InitPass     = numGrids - 1;
                    this.m_jacobianBuffer.Run(this.m_conditions[0], time);
                }
                if (!this.m_jacobianBuffer.BeenSampled)
                {
                    this.m_jacobianBuffer.EnableSampling();
                    this.m_foamCopyMat.SetTexture("Ceto_JacobianBuffer0", this.m_jacobianBuffer.GetTexture(0));
                    this.m_foamCopyMat.SetTexture("Ceto_JacobianBuffer1", this.m_jacobianBuffer.GetTexture(1));
                    this.m_foamCopyMat.SetTexture("Ceto_JacobianBuffer2", this.m_jacobianBuffer.GetTexture(2));
                    this.m_foamCopyMat.SetTexture("Ceto_HeightBuffer", this.m_displacementBuffer.GetTexture(0));
                    this.m_foamCopyMat.SetVector("Ceto_FoamChoppyness", vector);
                    this.m_foamCopyMat.SetFloat("Ceto_FoamCoverage", this.foamCoverage);
                    Graphics.Blit(null, this.m_foamMaps[0], this.m_foamCopyMat, numGrids - 1);
                    Shader.SetGlobalTexture("Ceto_FoamMap0", this.m_foamMaps[0]);
                    this.m_jacobianBuffer.DisableSampling();
                    this.m_jacobianBuffer.BeenSampled = true;
                }
            }
        }
コード例 #18
0
 private void Update()
 {
     if (!LocalPlayer.Transform)
     {
         return;
     }
     if (Time.frameCount % 2 == 0 && (!LocalPlayer.Buoyancy.InWater || !LocalPlayer.Buoyancy.IsOcean))
     {
         return;
     }
     try
     {
         this.gridScale      = Mathf.Clamp(this.gridScale, 0.1f, 1f);
         this.windSpeed      = Mathf.Clamp(this.windSpeed, 0f, 30f);
         this.waveAge        = Mathf.Clamp(this.waveAge, 0.5f, 1f);
         this.waveSpeed      = Mathf.Clamp(this.waveSpeed, 0f, 10f);
         this.foamAmount     = Mathf.Clamp(this.foamAmount, 0f, 6f);
         this.foamCoverage   = Mathf.Clamp(this.foamCoverage, 0f, 0.5f);
         this.waveSmoothing  = Mathf.Clamp(this.waveSmoothing, 1f, 6f);
         this.slopeSmoothing = Mathf.Clamp(this.slopeSmoothing, 1f, 6f);
         this.foamSmoothing  = Mathf.Clamp(this.foamSmoothing, 1f, 6f);
         float time = this.m_ocean.OceanTime.Now * this.waveSpeed;
         this.CreateBuffers();
         this.CreateRenderTextures();
         this.CreateConditions();
         int numGrids = this.m_conditions[0].Key.NumGrids;
         if (numGrids > 2)
         {
             Shader.EnableKeyword("CETO_USE_4_SPECTRUM_GRIDS");
         }
         else
         {
             Shader.DisableKeyword("CETO_USE_4_SPECTRUM_GRIDS");
         }
         this.UpdateQueryScaling();
         Shader.SetGlobalVector("Ceto_GridSizes", this.GridSizes);
         Shader.SetGlobalVector("Ceto_GridScale", new Vector2(this.GridScale, this.GridScale));
         Shader.SetGlobalVector("Ceto_Choppyness", this.Choppyness);
         Shader.SetGlobalFloat("Ceto_MapSize", (float)this.m_bufferSettings.size);
         Shader.SetGlobalFloat("Ceto_WaveSmoothing", this.waveSmoothing);
         Shader.SetGlobalFloat("Ceto_SlopeSmoothing", this.slopeSmoothing);
         Shader.SetGlobalFloat("Ceto_FoamSmoothing", this.foamSmoothing);
         Shader.SetGlobalFloat("Ceto_TextureWaveFoam", (!this.textureFoam) ? 0f : 1f);
         this.UpdateSpectrumScheduler();
         this.GenerateDisplacement(time);
         this.GenerateSlopes(time);
         this.GenerateFoam(time);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #19
0
ファイル: Ocean.cs プロジェクト: DevZhav/The-Forest
 private void Start()
 {
     try
     {
         Matrix4x4 identity = Matrix4x4.identity;
         identity.m00 = 2f;
         identity.m03 = -1f;
         identity.m11 = 2f;
         identity.m13 = -1f;
         for (int i = 0; i < 4; i++)
         {
             identity[1, i] = -identity[1, i];
         }
         Shader.SetGlobalMatrix("Ceto_T2S", identity);
         Shader.SetGlobalTexture("Ceto_Overlay_NormalMap", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_Overlay_HeightMap", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_Overlay_FoamMap", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_Overlay_ClipMap", Texture2D.blackTexture);
         Shader.SetGlobalTexture(Ocean.REFRACTION_GRAB_TEXTURE_NAME, Texture2D.blackTexture);
         Shader.SetGlobalTexture(Ocean.DEPTH_GRAB_TEXTURE_NAME, Texture2D.whiteTexture);
         Shader.SetGlobalTexture(Ocean.OCEAN_MASK_TEXTURE_NAME, Texture2D.blackTexture);
         Shader.SetGlobalTexture(Ocean.OCEAN_DEPTH_TEXTURE_NAME, Texture2D.blackTexture);
         Shader.SetGlobalTexture(Ocean.NORMAL_FADE_TEXTURE_NAME, Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_SlopeMap0", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_SlopeMap1", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap0", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap1", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap2", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_DisplacementMap3", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_FoamMap0", Texture2D.blackTexture);
         Shader.SetGlobalTexture("Ceto_FoamMap1", Texture2D.blackTexture);
         Shader.SetGlobalVector("Ceto_GridSizes", Vector4.one);
         Shader.SetGlobalVector("Ceto_GridScale", Vector4.one);
         Shader.SetGlobalVector("Ceto_Choppyness", Vector4.one);
         Shader.SetGlobalFloat("Ceto_MapSize", 1f);
         Shader.SetGlobalColor("Ceto_FoamTint", Color.white);
         Shader.SetGlobalTexture("Ceto_FoamTexture0", Texture2D.whiteTexture);
         Shader.SetGlobalTexture("Ceto_FoamTexture1", Texture2D.whiteTexture);
         Shader.SetGlobalVector("Ceto_FoamTextureScale0", Vector4.one);
         Shader.SetGlobalVector("Ceto_FoamTextureScale1", Vector4.one);
         Shader.SetGlobalFloat("Ceto_MaxWaveHeight", 40f);
         Shader.SetGlobalVector("Ceto_PosOffset", Vector3.zero);
         Shader.SetGlobalTexture("Ceto_CausticTexture", Texture2D.blackTexture);
         Shader.SetGlobalVector("Ceto_CausticTextureScale", new Vector4(1f, 1f, 0f, 0f));
         Shader.SetGlobalColor("Ceto_CausticTint", Color.white);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.DisableOcean();
     }
 }
コード例 #20
0
 protected virtual void OnDestroy()
 {
     try
     {
         m_ocean.Deregister(this);
     }
     catch (Exception e)
     {
         Ocean.LogError(e.ToString());
         WasError = true;
         enabled  = false;
     }
 }
コード例 #21
0
ファイル: PlanarReflection.cs プロジェクト: K07H/The-Forest
 private void Start()
 {
     try
     {
         this.m_imageBlur = new ImageBlur(this.blurShader);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #22
0
ファイル: PlanarReflection.cs プロジェクト: ilmtee/Ceto
 void Start()
 {
     try
     {
         m_imageBlur = new ImageBlur(blurShader);
     }
     catch (Exception e)
     {
         Ocean.LogError(e.ToString());
         WasError = true;
         enabled  = false;
     }
 }
コード例 #23
0
ファイル: OceanComponent.cs プロジェクト: K07H/The-Forest
 protected virtual void OnDestroy()
 {
     try
     {
         this.m_ocean.Deregister(this);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #24
0
        /// <summary>
        ///
        /// </summary>
        public Projection3f(Ocean ocean)
        {
            m_ocean = ocean;

            m_projectorP = new Matrix4x4();
            m_projectorV = new Matrix4x4();
            m_projectorR = Matrix4x4.identity;
            m_projectorI = new Matrix4x4();

            m_pointList = new List <Vector3>(12);

            m_frustumCorners = new Vector3[8];
        }
コード例 #25
0
 /// <summary>
 /// On awake find the ocean and store a reference to it.
 /// </summary>
 protected virtual void Awake()
 {
     try
     {
         m_ocean = GetComponent <Ocean>();
         m_ocean.Register(this);
     }
     catch (Exception e)
     {
         Ocean.LogError(e.ToString());
         WasError = true;
         enabled  = false;
     }
 }
コード例 #26
0
 /// <summary>
 /// On awake find the ocean and store a reference to it.
 /// </summary>
 protected virtual void Awake()
 {
     try
     {
         m_ocean = GetComponent<Ocean>();
         m_ocean.Register(this);
     }
     catch(Exception e)
     {
         Ocean.LogError(e.ToString());
         WasError = true;
         enabled = false;
     }
 }
コード例 #27
0
ファイル: OceanComponent.cs プロジェクト: GameDiffs/TheForest
 protected virtual void Awake()
 {
     try
     {
         this.m_ocean = base.GetComponent<Ocean>();
         this.m_ocean.Register(this);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.WasError = true;
         base.enabled = false;
     }
 }
コード例 #28
0
ファイル: OceanComponent.cs プロジェクト: K07H/The-Forest
 protected virtual void Awake()
 {
     try
     {
         this.m_ocean = base.GetComponent <Ocean>();
         this.m_ocean.Register(this);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         this.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #29
0
 private void Update()
 {
     try
     {
         Shader.SetGlobalFloat("Ceto_GridEdgeBorder", Mathf.Max(0f, this.borderLength));
         int     num = this.ResolutionToNumber(this.resolution);
         Vector2 v   = new Vector2((float)num / (float)this.ScreenWidth(), (float)num / (float)this.ScreenHeight());
         Shader.SetGlobalVector("Ceto_ScreenGridSize", v);
         this.CreateGrid(this.resolution);
         Dictionary <MESH_RESOLUTION, ProjectedGrid.Grid> .Enumerator enumerator = this.m_grids.GetEnumerator();
         while (enumerator.MoveNext())
         {
             KeyValuePair <MESH_RESOLUTION, ProjectedGrid.Grid> current = enumerator.Current;
             ProjectedGrid.Grid value = current.Value;
             KeyValuePair <MESH_RESOLUTION, ProjectedGrid.Grid> current2 = enumerator.Current;
             bool flag = current2.Key == this.resolution;
             if (flag)
             {
                 this.UpdateGrid(value);
                 this.Activate(value.top, true);
                 this.Activate(value.under, true);
             }
             else
             {
                 this.Activate(value.top, false);
                 this.Activate(value.under, false);
             }
         }
         if (this.m_ocean.UnderWater == null || this.m_ocean.UnderWater.Mode == UNDERWATER_MODE.ABOVE_ONLY)
         {
             enumerator = this.m_grids.GetEnumerator();
             while (enumerator.MoveNext())
             {
                 KeyValuePair <MESH_RESOLUTION, ProjectedGrid.Grid> current3 = enumerator.Current;
                 this.Activate(current3.Value.under, false);
             }
         }
         if (this.oceanTopSideMat != null && this.m_ocean.UnderWater != null && this.m_ocean.UnderWater.DepthMode == DEPTH_MODE.USE_DEPTH_BUFFER && this.oceanTopSideMat.shader.isSupported && this.oceanTopSideMat.renderQueue <= 2500)
         {
             Ocean.LogWarning("Underwater depth mode must be USE_OCEAN_DEPTH_PASS if using opaque material. Underwater effect will not look correct.");
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #30
0
 protected override void OnDisable()
 {
     base.OnDisable();
     try
     {
         Shader.DisableKeyword("CETO_UNDERWATER_ON");
         this.SetBottomActive(this.m_bottomMask, false);
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #31
0
ファイル: WaveSpectrum.cs プロジェクト: ahvonenj/TheForest
 private void UpdateSpectrumScheduler()
 {
     try
     {
         this.m_scheduler.DisableMultithreading = Ocean.DISABLE_ALL_MULTITHREADING;
         this.m_scheduler.CheckForException();
         this.m_scheduler.Update();
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #32
0
ファイル: PlanarReflection.cs プロジェクト: K07H/The-Forest
 protected override void OnDestroy()
 {
     base.OnDestroy();
     try
     {
         if (this.m_dummy != null)
         {
             UnityEngine.Object.DestroyImmediate(this.m_dummy);
         }
     }
     catch (Exception ex)
     {
         Ocean.LogError(ex.ToString());
         base.WasError = true;
         base.enabled  = false;
     }
 }
コード例 #33
0
ファイル: Projection3f.cs プロジェクト: BenjaminLovegrove/ATR
        /// <summary>
        /// 
        /// </summary>
        public Projection3f(Ocean ocean)
        {
            m_ocean = ocean;

            m_projectorP = new Matrix4x4();
            m_projectorV = new Matrix4x4();
            m_projectorR = Matrix4x4.identity;
            m_projectorI = new Matrix4x4();

            m_pointList = new List<Vector3>(12);

            m_frustumCorners = new Vector3[8];
        }
コード例 #34
0
ファイル: Projection3d.cs プロジェクト: BenjaminLovegrove/ATR
        /// <summary>
        /// 
        /// </summary>
        public Projection3d(Ocean ocean)
        {
            m_ocean = ocean;

            m_projectorP = new double[16];
            m_projectorV = new double[16];
            m_projectorVP = new double[16];
            m_projectorIVP = new double[16];
            m_projectorR = new double[16];
            m_projectorI = new double[16];

            MATRIX_BUFFER0 = new double[16];
            MATRIX_BUFFER1 = new double[16];
            VECTOR_BUFFER = new double[4];

            m_up = new double[]{0,1,0};

            m_xaxis = new double[3];
            m_yaxis = new double[3];
            m_zaxis = new double[3];

            m_a = new double[4];
            m_b = new double[4];
            m_ab = new double[4];

            m_pos = new double[3];
            m_dir = new double[3];
            m_lookAt = new double[3];

            m_p = new double[4];
            m_q = new double[4];
            m_p0 = new double[4];
            m_p1 = new double[4];

            Identity(m_projectorR);

            m_pointList = new List<double[]>(32);
            for(int i = 0; i < 32; i++)
                m_pointList.Add(new double[3]);

            m_frustumCorners = new List<double[]>(8);
            for(int i = 0; i < 8; i++)
                m_frustumCorners.Add(new double[3]);

            m_quad = new List<double[]>(4);
            m_quad.Add(new double[]{0, 0, 0, 1});
            m_quad.Add(new double[]{1, 0, 0, 1});
            m_quad.Add(new double[]{1, 1, 0, 1});
            m_quad.Add(new double[]{0, 1, 0, 1});

            m_corners = new List<double[]>(8);
            // near
            m_corners.Add(new double[]{-1, -1, -1, 1});
            m_corners.Add(new double[]{ 1, -1, -1, 1});
            m_corners.Add(new double[]{ 1,  1, -1, 1});
            m_corners.Add(new double[]{-1,  1, -1, 1});
            // far
            m_corners.Add(new double[]{-1, -1, 1, 1});
            m_corners.Add(new double[]{ 1, -1, 1, 1});
            m_corners.Add(new double[]{ 1,  1, 1, 1});
            m_corners.Add(new double[]{-1,  1, 1, 1});
        }