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);
            }
        }
Ejemplo n.º 2
0
		private void CreateShoreMasks()
		{
			this.Release();
			Terrain component = base.GetComponent<Terrain>();
			if (component == null)
			{
				Ocean.LogWarning("The AddAutoShoreMask script must be attached to a component with a Terrain. The shore mask will not be created.");
				base.enabled = false;
				return;
			}
			if (component.terrainData == null)
			{
				Ocean.LogWarning("The terrain data is null. The shore mask will not be created.");
				base.enabled = false;
				return;
			}
			Vector3 size = component.terrainData.size;
			this.resolution = Mathf.Clamp(this.resolution, 32, 4096);
			this.m_width = size.x;
			this.m_height = size.z;
			float level = Ocean.Instance.level;
			float[] data = ShoreMaskGenerator.CreateHeightMap(component);
			int heightmapResolution = component.terrainData.heightmapResolution;
			InterpolatedArray2f heightMap = new InterpolatedArray2f(data, heightmapResolution, heightmapResolution, 1, false);
			if (this.useHeightMask || this.useNormalMask || this.useFoamMask)
			{
				this.m_heightMask = ShoreMaskGenerator.CreateMask(heightMap, this.resolution, this.resolution, level, this.heightSpread, TextureFormat.ARGB32);
			}
			if (this.useEdgeFoam)
			{
				this.m_edgeFoam = ShoreMaskGenerator.CreateMask(heightMap, this.resolution, this.resolution, level, this.foamSpread, TextureFormat.ARGB32);
			}
			if (this.useClipMask)
			{
				this.m_clipMask = ShoreMaskGenerator.CreateClipMask(heightMap, this.resolution, this.resolution, level + this.clipOffset, TextureFormat.ARGB32);
			}
			if (this.useHeightMask)
			{
				this.m_overlays[0].HeightTex.mask = this.m_heightMask;
			}
			if (this.useNormalMask)
			{
				this.m_overlays[0].NormalTex.mask = this.m_heightMask;
			}
			if (this.useFoamMask)
			{
				this.m_overlays[0].FoamTex.mask = this.m_heightMask;
			}
			if (this.useEdgeFoam)
			{
				this.m_overlays[0].FoamTex.tex = this.m_edgeFoam;
			}
			if (this.useClipMask)
			{
				this.m_overlays[0].ClipTex.tex = this.m_clipMask;
			}
			if (!this.m_registered)
			{
				Ocean.Instance.OverlayManager.Add(this.m_overlays[0]);
				this.m_registered = true;
			}
			this.m_heightSpread = this.heightSpread;
			this.m_foamSpread = this.foamSpread;
			this.m_clipOffset = this.clipOffset;
			this.m_resolution = (float)this.resolution;
		}
        void CreateShoreMasks()
        {
            Terrain terrain;

            GameObject obj = Selection.activeGameObject;

            //If obj is null user has not selected a object.
            if (obj == null)
            {
                string msg = string.Format("{0:MM/dd/yy H:mm:ss zzz} - No object was selected. Please select the terrain in the scene. The shore mask will not be created.", DateTime.Now);
                Ocean.LogInfo(msg);
                return;
            }

            terrain = obj.GetComponent <Terrain>();

            //If terrain is null user has not selected a object with a terrain component.
            if (terrain == null)
            {
                string msg = string.Format("{0:MM/dd/yy H:mm:ss zzz} - Selected object was not a terrain. The shore mask will not be created.", DateTime.Now);
                Ocean.LogInfo(msg);
                return;
            }

            //If terrain data is null user has deleted the data at some point.
            if (terrain.terrainData == null)
            {
                string msg = string.Format("{0:MM/dd/yy H:mm:ss zzz} - Terrains data is null. The shore mask will not be created.", DateTime.Now);
                Ocean.LogInfo(msg);
                return;
            }

            DateTime time = DateTime.Now;

            //Get the height map data from the terrain.
            float[] data = ShoreMaskGenerator.CreateHeightMap(terrain);

            int resolution = terrain.terrainData.heightmapResolution;

            //Export each of the masks if required.

            if (m_exportHeightMask)
            {
                ExportMask(data, resolution, m_heightMaskResolution, terrain.name + "-HeightMask", time, m_heightMaskSpread, false, true);
            }

            if (m_exportEdgeFoam)
            {
                ExportMask(data, resolution, m_edgeFoamResolution, terrain.name + "-EdgeFoam", time, m_edgeFoamSpread, false, false);
            }

            if (m_exportFoamMask)
            {
                ExportMask(data, resolution, m_foamMaskResolution, terrain.name + "-FoamMask", time, m_foamMaskSpread, false, false);
            }

            if (m_exportNormalMask)
            {
                ExportMask(data, resolution, m_normalMaskResolution, terrain.name + "-NormalMask", time, m_normalMaskSpread, false, false);
            }

            if (m_exportClipMask)
            {
                ExportMask(data, resolution, m_clipMaskResolution, terrain.name + "-ClipMask", time, m_clipMaskOffset, true, true);
            }
        }
Ejemplo n.º 4
0
        void CreateShoreMasks()
        {
            //float t = Time.realtimeSinceStartup;

            Release();

            Terrain terrain = GetComponent <Terrain>();

            if (terrain == null)
            {
                //If there gameobject has not terrain print a warning and return.
                //Do this rather than have a terrain as a required component as it would be
                //rather annoying for the script to create a terrain if added to wrong gameobject.
                Ocean.LogWarning("The AddAutoShoreMask script must be attached to a component with a Terrain. The shore mask will not be created.");
                enabled = false;
                return;
            }

            if (terrain.terrainData == null)
            {
                //This can happen if the terrain data in asset folder is deleted
                Ocean.LogWarning("The terrain data is null. The shore mask will not be created.");
                enabled = false;
                return;
            }

            Vector3 size = terrain.terrainData.size;

            resolution = Mathf.Clamp(resolution, 32, 4096);

            m_width  = size.x;
            m_height = size.z;

            float level = Ocean.Instance.level;

            float[] data = ShoreMaskGenerator.CreateHeightMap(terrain);

            int actualResolution          = terrain.terrainData.heightmapResolution;
            InterpolatedArray2f heightMap = new InterpolatedArray2f(data, actualResolution, actualResolution, 1, false);

            if (useHeightMask || useNormalMask || useFoamMask)
            {
                m_heightMask = ShoreMaskGenerator.CreateMask(heightMap, resolution, resolution, level, heightSpread, TextureFormat.ARGB32);
            }

            if (useEdgeFoam)
            {
                m_edgeFoam = ShoreMaskGenerator.CreateMask(heightMap, resolution, resolution, level, foamSpread, TextureFormat.ARGB32);
            }

            if (useClipMask)
            {
                m_clipMask = ShoreMaskGenerator.CreateClipMask(heightMap, resolution, resolution, level + clipOffset, TextureFormat.ARGB32);
            }

            if (useHeightMask)
            {
                m_overlays[0].HeightTex.mask = m_heightMask;
            }

            if (useNormalMask)
            {
                m_overlays[0].NormalTex.mask = m_heightMask;
            }

            if (useFoamMask)
            {
                m_overlays[0].FoamTex.mask = m_heightMask;
            }

            if (useEdgeFoam)
            {
                m_overlays[0].FoamTex.tex = m_edgeFoam;
            }

            if (useClipMask)
            {
                m_overlays[0].ClipTex.tex = m_clipMask;
            }

            if (!m_registered)
            {
                Ocean.Instance.OverlayManager.Add(m_overlays[0]);
                m_registered = true;
            }

            m_heightSpread = heightSpread;
            m_foamSpread   = foamSpread;
            m_clipOffset   = clipOffset;
            m_resolution   = resolution;

            //Debug.Log("Shore mask creation time = " + (Time.realtimeSinceStartup - t) * 1000.0f);
        }