/// <summary>
        /// Copy constructor - wont duplicate textures tho - just settings and references
        /// </summary>
        /// <param name="src">Source object</param>
        public CTSTerrainTextureDetails(CTSTerrainTextureDetails src)
        {
            m_isOpenInEditor     = src.m_isOpenInEditor;
            m_textureIdx         = src.m_textureIdx;
            m_name               = src.m_name;
            m_detailPower        = src.m_detailPower;
            m_snowReductionPower = src.m_snowReductionPower;
            m_geologicalPower    = src.m_geologicalPower;
            m_triplanar          = src.m_triplanar;
            m_tint               = src.m_tint;
            m_tintBrightness     = src.m_tintBrightness;
            m_smoothness         = src.m_smoothness;

            #if !UNITY_WEBGL
            m_substanceRegenOnBake = src.m_substanceRegenOnBake;
            m_substanceWasChanged  = src.m_substanceWasChanged;
            m_substance            = src.m_substance;
            #endif

            m_albedoIdx         = src.m_albedoIdx;
            m_albedoTilingClose = src.m_albedoTilingClose;
            m_albedoTilingFar   = src.m_albedoTilingFar;
            m_albedoWasChanged  = src.m_albedoWasChanged;
            m_albedoTexture     = src.m_albedoTexture;

            m_normalIdx        = src.m_normalIdx;
            m_normalStrength   = src.m_normalStrength;
            m_normalWasChanged = src.m_normalWasChanged;
            m_normalTexture    = src.m_normalTexture;

            m_heightIdx              = src.m_heightIdx;
            m_heightDepth            = src.m_heightDepth;
            m_heightTesselationDepth = src.m_heightTesselationDepth;
            m_heightContrast         = src.m_heightContrast;
            m_heightBlendClose       = src.m_heightBlendClose;
            m_heightBlendFar         = src.m_heightBlendFar;
            m_heightWasChanged       = src.m_heightWasChanged;
            m_heightTexture          = src.m_heightTexture;

            m_aoIdx        = src.m_aoIdx;
            m_aoPower      = src.m_aoPower;
            m_aoWasChanged = src.m_aoWasChanged;
            m_aoTexture    = src.m_aoTexture;

            m_emissionIdx        = src.m_emissionIdx;
            m_emissionStrength   = src.m_emissionStrength;
            m_emissionWasChanged = src.m_emissionWasChanged;
            m_emissionTexture    = src.m_emissionTexture;

            m_smoothness       = src.m_smoothness;
            m_roughnessTexture = src.m_roughnessTexture;
        }
    void CreateCTSProfile()
    {
        var CTSpro = new CTSProfile();

        CTSpro.name            = VegetationPackage.name + " CTSProfile";
        CTSpro.TerrainTextures = new List <CTS.CTSTerrainTextureDetails>();
        for (int i = 0; i < VegetationPackage.TerrainTextureCount; i++)
        {
            var ctsTex = new CTS.CTSTerrainTextureDetails();
            ctsTex.Albedo = VegetationPackage.TerrainTextureList[i].Texture;
            ctsTex.Normal = VegetationPackage.TerrainTextureList[i].TextureNormals;
            CTSpro.TerrainTextures.Add(ctsTex);
        }
        AssetDatabase.CreateAsset(CTSpro, pathMain + "/" + CTSpro.name + ".asset");
        VPI[VPI.Length - 1]._CTSProfile = pathMain + "/" + CTSpro.name + ".asset";
        CTSProfilePackage = CTSpro;
    }
Esempio n. 3
0
        private void ConstructNormalsTextureArray()
        {
            this.m_needsNormalsArrayUpdate = false;
            List <Texture2D> sourceTextures = new List <Texture2D>();
            int num1 = 0;

            for (int index = 0; index < this.m_terrainTextures.Count; ++index)
            {
                CTSTerrainTextureDetails terrainTexture = this.m_terrainTextures[index];
                if (Object.op_Inequality((Object)terrainTexture.Normal, (Object)null))
                {
                    sourceTextures.Add(this.BakeNormal(terrainTexture.Normal));
                    terrainTexture.m_normalIdx = num1++;
                }
                else
                {
                    terrainTexture.m_normalIdx = -1;
                }
                terrainTexture.m_normalWasChanged = false;
            }
            if (Object.op_Inequality((Object)this.m_snowNormalTexture, (Object)null))
            {
                sourceTextures.Add(this.BakeNormal(this.m_snowNormalTexture));
                this.m_snowNormalTextureIdx = num1++;
            }
            else
            {
                this.m_snowNormalTextureIdx = -1;
            }
            if (Object.op_Implicit((Object)this.m_globalDetailNormalMap))
            {
                sourceTextures.Add(this.BakeNormal(this.m_globalDetailNormalMap));
                int num2 = num1;
                int num3 = num2 + 1;
                this.m_globalDetailNormalMapIdx = num2;
            }
            else
            {
                this.m_globalDetailNormalMapIdx = -1;
            }
            this.NormalsTextureArray = this.GetTextureArray(sourceTextures, CTSConstants.TextureType.Normal, this.m_normalAniso);
        }
Esempio n. 4
0
 public void UpdateSettingsFromTerrain(Terrain terrain, bool forceUpdate)
 {
     if (Object.op_Equality((Object)terrain, (Object)null) || Object.op_Equality((Object)terrain.get_terrainData(), (Object)null))
     {
         return;
     }
     if (forceUpdate)
     {
         this.m_needsAlbedosArrayUpdate = true;
         this.m_needsNormalsArrayUpdate = true;
     }
     while (this.m_terrainTextures.Count > terrain.get_terrainData().get_splatPrototypes().Length)
     {
         this.m_terrainTextures.RemoveAt(this.m_terrainTextures.Count - 1);
         this.m_needsAlbedosArrayUpdate = true;
         this.m_needsNormalsArrayUpdate = true;
     }
     SplatPrototype[] splatPrototypes = terrain.get_terrainData().get_splatPrototypes();
     for (int index = 0; index < splatPrototypes.Length; ++index)
     {
         SplatPrototype splatPrototype = splatPrototypes[index];
         if (index < this.m_terrainTextures.Count)
         {
             CTSTerrainTextureDetails terrainTexture = this.m_terrainTextures[index];
             terrainTexture.Albedo = splatPrototype.get_texture();
             terrainTexture.m_albedoTilingClose = (float)terrain.get_terrainData().get_splatPrototypes()[index].get_tileSize().x;
             terrainTexture.Normal = splatPrototype.get_normalMap();
         }
         else
         {
             this.m_terrainTextures.Add(new CTSTerrainTextureDetails()
             {
                 m_textureIdx        = index,
                 Albedo              = terrain.get_terrainData().get_splatPrototypes()[index].get_texture(),
                 m_albedoTilingClose = (float)terrain.get_terrainData().get_splatPrototypes()[index].get_tileSize().x,
                 Normal              = terrain.get_terrainData().get_splatPrototypes()[index].get_normalMap()
             });
         }
     }
     this.RegenerateArraysIfNecessary();
 }
 public CTSTerrainTextureDetails(CTSTerrainTextureDetails src)
 {
     this.m_isOpenInEditor         = src.m_isOpenInEditor;
     this.m_textureIdx             = src.m_textureIdx;
     this.m_name                   = src.m_name;
     this.m_detailPower            = src.m_detailPower;
     this.m_snowReductionPower     = src.m_snowReductionPower;
     this.m_geologicalPower        = src.m_geologicalPower;
     this.m_triplanar              = src.m_triplanar;
     this.m_tint                   = src.m_tint;
     this.m_tintBrightness         = src.m_tintBrightness;
     this.m_smoothness             = src.m_smoothness;
     this.m_albedoIdx              = src.m_albedoIdx;
     this.m_albedoTilingClose      = src.m_albedoTilingClose;
     this.m_albedoTilingFar        = src.m_albedoTilingFar;
     this.m_albedoWasChanged       = src.m_albedoWasChanged;
     this.m_albedoTexture          = src.m_albedoTexture;
     this.m_normalIdx              = src.m_normalIdx;
     this.m_normalStrength         = src.m_normalStrength;
     this.m_normalWasChanged       = src.m_normalWasChanged;
     this.m_normalTexture          = src.m_normalTexture;
     this.m_heightIdx              = src.m_heightIdx;
     this.m_heightDepth            = src.m_heightDepth;
     this.m_heightTesselationDepth = src.m_heightTesselationDepth;
     this.m_heightContrast         = src.m_heightContrast;
     this.m_heightBlendClose       = src.m_heightBlendClose;
     this.m_heightBlendFar         = src.m_heightBlendFar;
     this.m_heightWasChanged       = src.m_heightWasChanged;
     this.m_heightTexture          = src.m_heightTexture;
     this.m_aoIdx                  = src.m_aoIdx;
     this.m_aoPower                = src.m_aoPower;
     this.m_aoWasChanged           = src.m_aoWasChanged;
     this.m_aoTexture              = src.m_aoTexture;
     this.m_emissionIdx            = src.m_emissionIdx;
     this.m_emissionStrength       = src.m_emissionStrength;
     this.m_emissionWasChanged     = src.m_emissionWasChanged;
     this.m_emissionTexture        = src.m_emissionTexture;
     this.m_smoothness             = src.m_smoothness;
     this.m_roughnessTexture       = src.m_roughnessTexture;
 }
Esempio n. 6
0
        public void ConstructTerrainReplacementNormals()
        {
            if (Application.get_isPlaying())
            {
                return;
            }
            while (this.m_replacementTerrainNormals.Count > this.m_terrainTextures.Count)
            {
                this.m_replacementTerrainNormals.RemoveAt(this.m_replacementTerrainNormals.Count - 1);
            }
            while (this.m_replacementTerrainNormals.Count < this.m_terrainTextures.Count)
            {
                this.m_replacementTerrainNormals.Add((Texture2D)null);
            }
            string path1 = this.m_ctsDirectory + "Terrains/ReplacementTextures/";

            Directory.CreateDirectory(path1);
            for (int index = 0; index < this.m_terrainTextures.Count; ++index)
            {
                CTSTerrainTextureDetails terrainTexture = this.m_terrainTextures[index];
                if (Object.op_Inequality((Object)terrainTexture.Normal, (Object)null))
                {
                    string path2 = path1 + ((Object)terrainTexture.Normal).get_name() + "_nrm_cts.png";
                    if (!File.Exists(path2))
                    {
                        Texture2D texture2D = CTSProfile.ResizeTexture(terrainTexture.Normal, this.m_normalFormat, this.m_normalAniso, 64, 64, false, true, false);
                        ((Object)texture2D).set_name(((Object)terrainTexture.Normal).get_name() + "_nrm_cts");
                        this.m_replacementTerrainNormals[index] = texture2D;
                        byte[] png = ImageConversion.EncodeToPNG(this.m_replacementTerrainNormals[index]);
                        File.WriteAllBytes(path2, png);
                    }
                }
                else
                {
                    this.m_replacementTerrainNormals[index] = (Texture2D)null;
                }
            }
            CompleteTerrainShader.SetDirty((Object)this, false, true);
        }
Esempio n. 7
0
        private void ConstructAlbedosTextureArray()
        {
            this.m_needsAlbedosArrayUpdate = false;
            List <Texture2D> sourceTextures = new List <Texture2D>();
            int  num1 = 0;
            byte minHeight;
            byte maxHeight;

            for (int index = 0; index < this.m_terrainTextures.Count; ++index)
            {
                CTSTerrainTextureDetails terrainTexture = this.m_terrainTextures[index];
                if (Object.op_Inequality((Object)terrainTexture.Albedo, (Object)null))
                {
                    Texture2D texture2D = !Object.op_Equality((Object)terrainTexture.Smoothness, (Object)null) || !Object.op_Equality((Object)terrainTexture.Roughness, (Object)null) ? this.BakeAlbedo(terrainTexture.Albedo, terrainTexture.Smoothness, terrainTexture.Roughness) : (!this.m_albedoCompress ? CTSProfile.ResizeTexture(terrainTexture.Albedo, this.m_albedoFormat, this.m_albedoAniso, this.m_albedoTextureSizePx, this.m_albedoTextureSizePx, true, false, false) : CTSProfile.ResizeTexture(terrainTexture.Albedo, this.m_albedoFormat, this.m_albedoAniso, this.m_albedoTextureSizePx, this.m_albedoTextureSizePx, true, false, true));
                    sourceTextures.Add(texture2D);
                    Color linear = ((Color) ref texture2D.GetPixels(texture2D.get_mipmapCount() - 1)[0]).get_linear();
                    terrainTexture.m_albedoAverage = new Vector4((float)linear.r, (float)linear.g, (float)linear.b, (float)linear.a);
                    terrainTexture.m_albedoIdx     = num1++;
                    if ((this.m_shaderType == CTSConstants.ShaderType.Advanced || this.m_shaderType == CTSConstants.ShaderType.Tesselation) && (Object.op_Inequality((Object)terrainTexture.Height, (Object)null) || Object.op_Inequality((Object)terrainTexture.AmbientOcclusion, (Object)null)))
                    {
                        sourceTextures.Add(this.BakeHAOTexture(terrainTexture.m_name, terrainTexture.Height, terrainTexture.AmbientOcclusion, out minHeight, out maxHeight));
                        if (Object.op_Inequality((Object)terrainTexture.Height, (Object)null))
                        {
                            terrainTexture.m_heightIdx = num1;
                            terrainTexture.m_heightMin = (float)minHeight / (float)byte.MaxValue;
                            terrainTexture.m_heightMax = (float)maxHeight / (float)byte.MaxValue;
                        }
                        else
                        {
                            terrainTexture.m_heightIdx = -1;
                        }
                        terrainTexture.m_aoIdx = !Object.op_Inequality((Object)terrainTexture.AmbientOcclusion, (Object)null) ? -1 : num1;
                        ++num1;
                    }
                    else
                    {
                        terrainTexture.m_aoIdx     = -1;
                        terrainTexture.m_heightIdx = -1;
                    }
                }
                else
                {
                    terrainTexture.m_albedoIdx = -1;
                }
                terrainTexture.m_albedoWasChanged = false;
            }
            if (Object.op_Inequality((Object)this.m_snowAlbedoTexture, (Object)null))
            {
                Texture2D texture2D = !this.m_albedoCompress ? CTSProfile.ResizeTexture(this.m_snowAlbedoTexture, this.m_albedoFormat, this.m_normalAniso, this.m_albedoTextureSizePx, this.m_albedoTextureSizePx, true, false, false) : CTSProfile.ResizeTexture(this.m_snowAlbedoTexture, this.m_albedoFormat, this.m_normalAniso, this.m_albedoTextureSizePx, this.m_albedoTextureSizePx, true, false, true);
                Color     linear    = ((Color) ref texture2D.GetPixels(texture2D.get_mipmapCount() - 1)[0]).get_linear();
                this.m_snowAverage = new Vector4((float)linear.r, (float)linear.g, (float)linear.b, (float)linear.a);
                sourceTextures.Add(texture2D);
                this.m_snowAlbedoTextureIdx = num1++;
            }
            else
            {
                this.m_snowAlbedoTextureIdx = -1;
            }
            if (Object.op_Inequality((Object)this.m_snowHeightTexture, (Object)null) || Object.op_Inequality((Object)this.m_snowAOTexture, (Object)null))
            {
                sourceTextures.Add(this.BakeHAOTexture("CTS_SnowHAO", this.m_snowHeightTexture, this.m_snowAOTexture, out minHeight, out maxHeight));
                if (Object.op_Inequality((Object)this.m_snowHeightTexture, (Object)null))
                {
                    this.m_snowHeightTextureIdx  = num1;
                    this.m_snowHeightmapMinValue = (float)minHeight / (float)byte.MaxValue;
                    this.m_snowHeightmapMaxValue = (float)maxHeight / (float)byte.MaxValue;
                }
                else
                {
                    this.m_snowHeightTextureIdx  = -1;
                    this.m_snowHeightmapMinValue = 0.0f;
                    this.m_snowHeightmapMaxValue = 1f;
                }
                this.m_snowAOTextureIdx = !Object.op_Inequality((Object)this.m_snowAOTexture, (Object)null) ? -1 : num1;
                int num2 = num1 + 1;
            }
            else
            {
                this.m_snowAOTextureIdx     = -1;
                this.m_snowHeightTextureIdx = -1;
            }
            this.AlbedosTextureArray = this.GetTextureArray(sourceTextures, CTSConstants.TextureType.Albedo, this.m_albedoAniso);
        }
Esempio n. 8
0
        private void GetTexturesAndSettingsAtCurrentLocation()
        {
            this.m_textureList.Clear();
            CTSProfile ctsProfile = (CTSProfile)null;

            SplatPrototype[] splatPrototypeArray = new SplatPrototype[0];
            Vector3          position            = ((Component)this).get_transform().get_position();
            Vector3          localScale          = ((Component)this).get_transform().get_localScale();
            Vector3          eulerAngles         = ((Component)this).get_transform().get_eulerAngles();

            for (int index1 = this.m_filters.Length - 1; index1 >= 0; --index1)
            {
                Mesh sharedMesh = this.m_filters[index1].get_sharedMesh();
                if (Object.op_Inequality((Object)sharedMesh, (Object)null))
                {
                    Vector3[] vertices = sharedMesh.get_vertices();
                    for (int index2 = vertices.Length - 1; index2 >= 0; --index2)
                    {
                        Vector3 locationWU = Vector3.op_Addition(position, Quaternion.op_Multiply(Quaternion.Euler(eulerAngles), Vector3.Scale(vertices[index2], localScale)));
                        Terrain terrain    = this.GetTerrain(locationWU);
                        if (Object.op_Inequality((Object)terrain, (Object)null))
                        {
                            if (Object.op_Equality((Object)ctsProfile, (Object)null))
                            {
                                CompleteTerrainShader component = (CompleteTerrainShader)((Component)terrain).get_gameObject().GetComponent <CompleteTerrainShader>();
                                if (Object.op_Inequality((Object)component, (Object)null))
                                {
                                    ctsProfile = component.Profile;
                                }
                            }
                            if (splatPrototypeArray.Length == 0)
                            {
                                splatPrototypeArray = terrain.get_terrainData().get_splatPrototypes();
                            }
                            Vector3 localPosition = this.GetLocalPosition(terrain, locationWU);
                            float[,,] texturesAtLocation = this.GetTexturesAtLocation(terrain, localPosition);
                            for (int index3 = 0; index3 < texturesAtLocation.GetLength(2); ++index3)
                            {
                                if (index3 == this.m_textureList.Count)
                                {
                                    this.m_textureList.Add(new CTSMeshBlender.TextureData()
                                    {
                                        m_terrainIdx             = index3,
                                        m_terrainTextureStrength = texturesAtLocation[0, 0, index3]
                                    });
                                }
                                else
                                {
                                    this.m_textureList[index3].m_terrainTextureStrength += texturesAtLocation[0, 0, index3];
                                }
                            }
                        }
                    }
                }
            }
            List <CTSMeshBlender.TextureData> list = this.m_textureList.OrderByDescending <CTSMeshBlender.TextureData, float>((Func <CTSMeshBlender.TextureData, float>)(x => x.m_terrainTextureStrength)).ToList <CTSMeshBlender.TextureData>();

            while (list.Count > 3)
            {
                list.RemoveAt(list.Count - 1);
            }
            this.m_textureList = list.OrderBy <CTSMeshBlender.TextureData, int>((Func <CTSMeshBlender.TextureData, int>)(x => x.m_terrainIdx)).ToList <CTSMeshBlender.TextureData>();
            if (Object.op_Inequality((Object)ctsProfile, (Object)null))
            {
                this.m_geoMap            = ctsProfile.GeoAlbedo;
                this.m_geoMapClosePower  = ctsProfile.m_geoMapClosePower;
                this.m_geoMapOffsetClose = ctsProfile.m_geoMapCloseOffset;
                this.m_geoTilingClose    = ctsProfile.m_geoMapTilingClose;
                this.m_smoothness        = ctsProfile.m_globalTerrainSmoothness;
                this.m_specular          = ctsProfile.m_globalTerrainSpecular;
                switch (ctsProfile.m_globalAOType)
                {
                case CTSConstants.AOType.None:
                    this.m_useAO        = false;
                    this.m_useAOTexture = false;
                    break;

                case CTSConstants.AOType.NormalMapBased:
                    this.m_useAO        = true;
                    this.m_useAOTexture = false;
                    break;

                case CTSConstants.AOType.TextureBased:
                    this.m_useAO        = true;
                    this.m_useAOTexture = true;
                    break;
                }
            }
            else
            {
                this.m_geoMap            = (Texture2D)null;
                this.m_geoMapClosePower  = 0.0f;
                this.m_geoMapOffsetClose = 0.0f;
                this.m_geoTilingClose    = 0.0f;
                this.m_smoothness        = 1f;
                this.m_specular          = 1f;
                this.m_useAO             = true;
                this.m_useAOTexture      = false;
            }
            byte minHeight = 0;
            byte maxHeight = 0;

            for (int index = 0; index < this.m_textureList.Count; ++index)
            {
                CTSMeshBlender.TextureData texture = this.m_textureList[index];
                if (Object.op_Inequality((Object)ctsProfile, (Object)null) && texture.m_terrainIdx < ctsProfile.TerrainTextures.Count)
                {
                    CTSTerrainTextureDetails terrainTexture = ctsProfile.TerrainTextures[texture.m_terrainIdx];
                    texture.m_albedo           = terrainTexture.Albedo;
                    texture.m_normal           = terrainTexture.Normal;
                    texture.m_hao_in_GA        = ctsProfile.BakeHAOTexture(((Object)terrainTexture.Albedo).get_name(), terrainTexture.Height, terrainTexture.AmbientOcclusion, out minHeight, out maxHeight);
                    texture.m_aoPower          = terrainTexture.m_aoPower;
                    texture.m_color            = new Vector4((float)terrainTexture.m_tint.r * terrainTexture.m_tintBrightness, (float)terrainTexture.m_tint.g * terrainTexture.m_tintBrightness, (float)terrainTexture.m_tint.b * terrainTexture.m_tintBrightness, terrainTexture.m_smoothness);
                    texture.m_geoPower         = terrainTexture.m_geologicalPower;
                    texture.m_normalPower      = terrainTexture.m_normalStrength;
                    texture.m_tiling           = terrainTexture.m_albedoTilingClose;
                    texture.m_heightContrast   = terrainTexture.m_heightContrast;
                    texture.m_heightDepth      = terrainTexture.m_heightDepth;
                    texture.m_heightBlendClose = terrainTexture.m_heightBlendClose;
                }
                else if (texture.m_terrainIdx < splatPrototypeArray.Length)
                {
                    SplatPrototype splatPrototype = splatPrototypeArray[texture.m_terrainIdx];
                    texture.m_albedo           = splatPrototype.get_texture();
                    texture.m_normal           = splatPrototype.get_normalMap();
                    texture.m_hao_in_GA        = (Texture2D)null;
                    texture.m_aoPower          = 0.0f;
                    texture.m_color            = Vector4.get_one();
                    texture.m_geoPower         = 0.0f;
                    texture.m_normalPower      = 1f;
                    texture.m_tiling           = (float)splatPrototype.get_tileSize().x;
                    texture.m_heightContrast   = 1f;
                    texture.m_heightDepth      = 1f;
                    texture.m_heightBlendClose = 1f;
                }
            }
        }