2301 lines
103 KiB
C#
2301 lines
103 KiB
C#
using System;
|
|
using UnityEngine;
|
|
|
|
[Serializable]
|
|
public class ReliefTerrainGlobalSettingsHolder
|
|
{
|
|
public int numTiles;
|
|
|
|
public int numLayers;
|
|
|
|
[NonSerialized]
|
|
public bool dont_check_weak_references;
|
|
|
|
[NonSerialized]
|
|
public bool dont_check_for_interfering_terrain_replacement_shaders;
|
|
|
|
[NonSerialized]
|
|
public Texture2D[] bakeJobArray;
|
|
|
|
public Texture2D[] splats;
|
|
|
|
public Texture2D[] splat_atlases = new Texture2D[3];
|
|
|
|
public string save_path_atlasA = string.Empty;
|
|
|
|
public string save_path_atlasB = string.Empty;
|
|
|
|
public string save_path_atlasC = string.Empty;
|
|
|
|
public string save_path_terrain_steepness = string.Empty;
|
|
|
|
public string save_path_terrain_height = string.Empty;
|
|
|
|
public string save_path_terrain_direction = string.Empty;
|
|
|
|
public string save_path_Bump01 = string.Empty;
|
|
|
|
public string save_path_Bump23 = string.Empty;
|
|
|
|
public string save_path_Bump45 = string.Empty;
|
|
|
|
public string save_path_Bump67 = string.Empty;
|
|
|
|
public string save_path_Bump89 = string.Empty;
|
|
|
|
public string save_path_BumpAB = string.Empty;
|
|
|
|
public string save_path_HeightMap = string.Empty;
|
|
|
|
public string save_path_HeightMap2 = string.Empty;
|
|
|
|
public string save_path_HeightMap3 = string.Empty;
|
|
|
|
public string save_path_SSColorCombinedA = string.Empty;
|
|
|
|
public string save_path_SSColorCombinedB = string.Empty;
|
|
|
|
public string newPresetName = "a preset name...";
|
|
|
|
public Texture2D activateObject;
|
|
|
|
private GameObject _RTP_LODmanager;
|
|
|
|
public RTP_LODmanager _RTP_LODmanagerScript;
|
|
|
|
public float RTP_MIP_BIAS;
|
|
|
|
public float MasterLayerBrightness = 1f;
|
|
|
|
public float MasterLayerSaturation = 1f;
|
|
|
|
public float EmissionRefractFiltering = 4f;
|
|
|
|
public float EmissionRefractAnimSpeed = 4f;
|
|
|
|
public RTPColorChannels SuperDetailA_channel;
|
|
|
|
public RTPColorChannels SuperDetailB_channel;
|
|
|
|
public Texture2D Bump01;
|
|
|
|
public Texture2D Bump23;
|
|
|
|
public Texture2D Bump45;
|
|
|
|
public Texture2D Bump67;
|
|
|
|
public Texture2D Bump89;
|
|
|
|
public Texture2D BumpAB;
|
|
|
|
public Texture2D BumpGlobal;
|
|
|
|
public int BumpGlobalCombinedSize = 1024;
|
|
|
|
public Texture2D SSColorCombinedA;
|
|
|
|
public Texture2D SSColorCombinedB;
|
|
|
|
public Texture2D VerticalTexture;
|
|
|
|
public float BumpMapGlobalScale;
|
|
|
|
public Vector3 GlobalColorMapBlendValues;
|
|
|
|
public float _GlobalColorMapNearMIP;
|
|
|
|
public float GlobalColorMapSaturation;
|
|
|
|
public float GlobalColorMapSaturationFar = 1f;
|
|
|
|
public float GlobalColorMapDistortByPerlin = 0.005f;
|
|
|
|
public float GlobalColorMapBrightness;
|
|
|
|
public float GlobalColorMapBrightnessFar = 1f;
|
|
|
|
public float _FarNormalDamp;
|
|
|
|
public float blendMultiplier;
|
|
|
|
public Vector3 terrainTileSize;
|
|
|
|
public Texture2D HeightMap;
|
|
|
|
public Vector4 ReliefTransform;
|
|
|
|
public float DIST_STEPS;
|
|
|
|
public float WAVELENGTH;
|
|
|
|
public float ReliefBorderBlend;
|
|
|
|
public float ExtrudeHeight;
|
|
|
|
public float LightmapShading;
|
|
|
|
public float RTP_AOsharpness;
|
|
|
|
public float RTP_AOamp;
|
|
|
|
public float _occlusionStrength = 1f;
|
|
|
|
public float SHADOW_STEPS;
|
|
|
|
public float WAVELENGTH_SHADOWS;
|
|
|
|
public float SelfShadowStrength;
|
|
|
|
public float ShadowSmoothing;
|
|
|
|
public float ShadowSoftnessFade = 0.8f;
|
|
|
|
public float distance_start;
|
|
|
|
public float distance_transition;
|
|
|
|
public float distance_start_bumpglobal;
|
|
|
|
public float distance_transition_bumpglobal;
|
|
|
|
public float rtp_perlin_start_val;
|
|
|
|
public float _Phong;
|
|
|
|
public float tessHeight = 300f;
|
|
|
|
public float _TessSubdivisions = 1f;
|
|
|
|
public float _TessSubdivisionsFar = 1f;
|
|
|
|
public float _TessYOffset;
|
|
|
|
public float trees_shadow_distance_start;
|
|
|
|
public float trees_shadow_distance_transition;
|
|
|
|
public float trees_shadow_value;
|
|
|
|
public float trees_pixel_distance_start;
|
|
|
|
public float trees_pixel_distance_transition;
|
|
|
|
public float trees_pixel_blend_val;
|
|
|
|
public float global_normalMap_multiplier;
|
|
|
|
public float global_normalMap_farUsage;
|
|
|
|
public float _AmbientEmissiveMultiplier = 1f;
|
|
|
|
public float _AmbientEmissiveRelief = 0.5f;
|
|
|
|
public Texture2D HeightMap2;
|
|
|
|
public Texture2D HeightMap3;
|
|
|
|
public int rtp_mipoffset_globalnorm;
|
|
|
|
public float _SuperDetailTiling;
|
|
|
|
public Texture2D SuperDetailA;
|
|
|
|
public Texture2D SuperDetailB;
|
|
|
|
public float TERRAIN_GlobalWetness;
|
|
|
|
public Texture2D TERRAIN_RippleMap;
|
|
|
|
public float TERRAIN_RippleScale;
|
|
|
|
public float TERRAIN_FlowScale;
|
|
|
|
public float TERRAIN_FlowSpeed;
|
|
|
|
public float TERRAIN_FlowCycleScale;
|
|
|
|
public float TERRAIN_FlowMipOffset;
|
|
|
|
public float TERRAIN_WetDarkening;
|
|
|
|
public float TERRAIN_WetDropletsStrength;
|
|
|
|
public float TERRAIN_WetHeight_Treshold;
|
|
|
|
public float TERRAIN_WetHeight_Transition;
|
|
|
|
public float TERRAIN_RainIntensity;
|
|
|
|
public float TERRAIN_DropletsSpeed;
|
|
|
|
public float TERRAIN_mipoffset_flowSpeed;
|
|
|
|
public float TERRAIN_CausticsAnimSpeed;
|
|
|
|
public Color TERRAIN_CausticsColor;
|
|
|
|
public GameObject TERRAIN_CausticsWaterLevelRefObject;
|
|
|
|
public float TERRAIN_CausticsWaterLevel;
|
|
|
|
public float TERRAIN_CausticsWaterLevelByAngle;
|
|
|
|
public float TERRAIN_CausticsWaterDeepFadeLength;
|
|
|
|
public float TERRAIN_CausticsWaterShallowFadeLength;
|
|
|
|
public float TERRAIN_CausticsTilingScale;
|
|
|
|
public Texture2D TERRAIN_CausticsTex;
|
|
|
|
public Vector4 RTP_LightDefVector;
|
|
|
|
public Texture2D[] Bumps;
|
|
|
|
public float[] FarSpecCorrection;
|
|
|
|
public float[] MIPmult;
|
|
|
|
public float[] MixScale;
|
|
|
|
public float[] MixBlend;
|
|
|
|
public float[] MixSaturation;
|
|
|
|
public float[] RTP_DiffFresnel;
|
|
|
|
public float[] RTP_metallic;
|
|
|
|
public float[] RTP_glossMin;
|
|
|
|
public float[] RTP_glossMax;
|
|
|
|
public float[] RTP_glitter;
|
|
|
|
public float[] GlobalColorBottom;
|
|
|
|
public float[] GlobalColorTop;
|
|
|
|
public float[] GlobalColorColormapLoSat;
|
|
|
|
public float[] GlobalColorColormapHiSat;
|
|
|
|
public float[] GlobalColorLayerLoSat;
|
|
|
|
public float[] GlobalColorLayerHiSat;
|
|
|
|
public float[] GlobalColorLoBlend;
|
|
|
|
public float[] GlobalColorHiBlend;
|
|
|
|
public float[] MixBrightness;
|
|
|
|
public float[] MixReplace;
|
|
|
|
public float[] LayerBrightness;
|
|
|
|
public float[] LayerBrightness2Spec;
|
|
|
|
public float[] LayerAlbedo2SpecColor;
|
|
|
|
public float[] LayerSaturation;
|
|
|
|
public float[] LayerEmission;
|
|
|
|
public Color[] LayerEmissionColor;
|
|
|
|
public float[] LayerEmissionRefractStrength;
|
|
|
|
public float[] LayerEmissionRefractHBedge;
|
|
|
|
public float[] GlobalColorPerLayer;
|
|
|
|
public float[] PER_LAYER_HEIGHT_MODIFIER;
|
|
|
|
public float[] _SuperDetailStrengthMultA;
|
|
|
|
public float[] _SuperDetailStrengthMultASelfMaskNear;
|
|
|
|
public float[] _SuperDetailStrengthMultASelfMaskFar;
|
|
|
|
public float[] _SuperDetailStrengthMultB;
|
|
|
|
public float[] _SuperDetailStrengthMultBSelfMaskNear;
|
|
|
|
public float[] _SuperDetailStrengthMultBSelfMaskFar;
|
|
|
|
public float[] _SuperDetailStrengthNormal;
|
|
|
|
public float[] _BumpMapGlobalStrength;
|
|
|
|
public float[] AO_strength = new float[12]
|
|
{
|
|
1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f,
|
|
1f, 1f
|
|
};
|
|
|
|
public float[] VerticalTextureStrength;
|
|
|
|
public float VerticalTextureGlobalBumpInfluence;
|
|
|
|
public float VerticalTextureTiling;
|
|
|
|
public Texture2D[] Heights;
|
|
|
|
public float[] _snow_strength_per_layer;
|
|
|
|
public ProceduralMaterial[] Substances;
|
|
|
|
public float[] TERRAIN_LayerWetStrength;
|
|
|
|
public float[] TERRAIN_WaterLevel;
|
|
|
|
public float[] TERRAIN_WaterLevelSlopeDamp;
|
|
|
|
public float[] TERRAIN_WaterEdge;
|
|
|
|
public float[] TERRAIN_WaterGloss;
|
|
|
|
public float[] TERRAIN_WaterGlossDamper;
|
|
|
|
public float[] TERRAIN_Refraction;
|
|
|
|
public float[] TERRAIN_WetRefraction;
|
|
|
|
public float[] TERRAIN_Flow;
|
|
|
|
public float[] TERRAIN_WetFlow;
|
|
|
|
public float[] TERRAIN_WaterMetallic;
|
|
|
|
public float[] TERRAIN_WetGloss;
|
|
|
|
public Color[] TERRAIN_WaterColor;
|
|
|
|
public float[] TERRAIN_WaterEmission;
|
|
|
|
public float _snow_strength;
|
|
|
|
public float _global_color_brightness_to_snow;
|
|
|
|
public float _snow_slope_factor;
|
|
|
|
public float _snow_edge_definition;
|
|
|
|
public float _snow_height_treshold;
|
|
|
|
public float _snow_height_transition;
|
|
|
|
public Color _snow_color;
|
|
|
|
public float _snow_gloss;
|
|
|
|
public float _snow_reflectivness;
|
|
|
|
public float _snow_deep_factor;
|
|
|
|
public float _snow_diff_fresnel;
|
|
|
|
public float _snow_metallic;
|
|
|
|
public float _snow_Frost;
|
|
|
|
public float _snow_MicroTiling = 1f;
|
|
|
|
public float _snow_BumpMicro = 0.2f;
|
|
|
|
public Color _SnowGlitterColor = new Color(1f, 1f, 1f, 0.1f);
|
|
|
|
public float _snow_occlusionStrength = 0.5f;
|
|
|
|
public int _snow_TranslucencyDeferredLightIndex;
|
|
|
|
public Color _GlitterColor;
|
|
|
|
public float[] _GlitterStrength;
|
|
|
|
public float _GlitterTiling;
|
|
|
|
public float _GlitterDensity;
|
|
|
|
public float _GlitterFilter;
|
|
|
|
public float _GlitterColorization;
|
|
|
|
public Texture2D _SparkleMap;
|
|
|
|
public bool _4LAYERS_SHADER_USED;
|
|
|
|
public bool flat_dir_ref = true;
|
|
|
|
public bool flip_dir_ref = true;
|
|
|
|
public GameObject direction_object;
|
|
|
|
public bool show_details;
|
|
|
|
public bool show_details_main;
|
|
|
|
public bool show_details_atlasing;
|
|
|
|
public bool show_details_layers;
|
|
|
|
public bool show_details_uv_blend;
|
|
|
|
public bool show_controlmaps;
|
|
|
|
public bool show_controlmaps_build;
|
|
|
|
public bool show_controlmaps_helpers;
|
|
|
|
public bool show_controlmaps_highcost;
|
|
|
|
public bool show_controlmaps_splats;
|
|
|
|
public bool show_vert_texture;
|
|
|
|
public bool show_global_color;
|
|
|
|
public bool show_snow;
|
|
|
|
public bool show_global_bump;
|
|
|
|
public bool show_global_bump_normals;
|
|
|
|
public bool show_global_bump_superdetail;
|
|
|
|
public ReliefTerrainMenuItems submenu;
|
|
|
|
public ReliefTerrainSettingsItems submenu_settings;
|
|
|
|
public ReliefTerrainDerivedTexturesItems submenu_derived_textures;
|
|
|
|
public ReliefTerrainControlTexturesItems submenu_control_textures;
|
|
|
|
public bool show_global_wet_settings;
|
|
|
|
public bool show_global_reflection_settings;
|
|
|
|
public int show_active_layer;
|
|
|
|
public bool show_derivedmaps;
|
|
|
|
public bool show_settings;
|
|
|
|
public bool undo_flag;
|
|
|
|
public bool paint_flag;
|
|
|
|
public float paint_size = 0.5f;
|
|
|
|
public float paint_smoothness;
|
|
|
|
public float paint_opacity = 1f;
|
|
|
|
public Color paintColor = new Color(0.5f, 0.3f, 0f, 0f);
|
|
|
|
public bool preserveBrightness = true;
|
|
|
|
public bool paint_alpha_flag;
|
|
|
|
public bool paint_wetmask;
|
|
|
|
public RaycastHit paintHitInfo;
|
|
|
|
public bool paintHitInfo_flag;
|
|
|
|
public bool cut_holes;
|
|
|
|
private Texture2D dumb_tex;
|
|
|
|
public Color[] paintColorSwatches;
|
|
|
|
public Material use_mat;
|
|
|
|
public ReliefTerrainGlobalSettingsHolder()
|
|
{
|
|
Bumps = new Texture2D[12];
|
|
Heights = new Texture2D[12];
|
|
FarSpecCorrection = new float[12];
|
|
MIPmult = new float[12];
|
|
MixScale = new float[12];
|
|
MixBlend = new float[12];
|
|
MixSaturation = new float[12];
|
|
RTP_DiffFresnel = new float[12];
|
|
RTP_metallic = new float[12];
|
|
RTP_glossMin = new float[12];
|
|
RTP_glossMax = new float[12];
|
|
RTP_glitter = new float[12];
|
|
MixBrightness = new float[12];
|
|
MixReplace = new float[12];
|
|
LayerBrightness = new float[12];
|
|
LayerBrightness2Spec = new float[12];
|
|
LayerAlbedo2SpecColor = new float[12];
|
|
LayerSaturation = new float[12];
|
|
LayerEmission = new float[12];
|
|
LayerEmissionColor = new Color[12];
|
|
LayerEmissionRefractStrength = new float[12];
|
|
LayerEmissionRefractHBedge = new float[12];
|
|
GlobalColorPerLayer = new float[12];
|
|
GlobalColorBottom = new float[12];
|
|
GlobalColorTop = new float[12];
|
|
GlobalColorColormapLoSat = new float[12];
|
|
GlobalColorColormapHiSat = new float[12];
|
|
GlobalColorLayerLoSat = new float[12];
|
|
GlobalColorLayerHiSat = new float[12];
|
|
GlobalColorLoBlend = new float[12];
|
|
GlobalColorHiBlend = new float[12];
|
|
PER_LAYER_HEIGHT_MODIFIER = new float[12];
|
|
_snow_strength_per_layer = new float[12];
|
|
Substances = new ProceduralMaterial[12];
|
|
_SuperDetailStrengthMultA = new float[12];
|
|
_SuperDetailStrengthMultASelfMaskNear = new float[12];
|
|
_SuperDetailStrengthMultASelfMaskFar = new float[12];
|
|
_SuperDetailStrengthMultB = new float[12];
|
|
_SuperDetailStrengthMultBSelfMaskNear = new float[12];
|
|
_SuperDetailStrengthMultBSelfMaskFar = new float[12];
|
|
_SuperDetailStrengthNormal = new float[12];
|
|
_BumpMapGlobalStrength = new float[12];
|
|
AO_strength = new float[12];
|
|
VerticalTextureStrength = new float[12];
|
|
TERRAIN_LayerWetStrength = new float[12];
|
|
TERRAIN_WaterLevel = new float[12];
|
|
TERRAIN_WaterLevelSlopeDamp = new float[12];
|
|
TERRAIN_WaterEdge = new float[12];
|
|
TERRAIN_WaterGloss = new float[12];
|
|
TERRAIN_WaterGlossDamper = new float[12];
|
|
TERRAIN_Refraction = new float[12];
|
|
TERRAIN_WetRefraction = new float[12];
|
|
TERRAIN_Flow = new float[12];
|
|
TERRAIN_WetFlow = new float[12];
|
|
TERRAIN_WaterMetallic = new float[12];
|
|
TERRAIN_WetGloss = new float[12];
|
|
TERRAIN_WaterColor = new Color[12];
|
|
TERRAIN_WaterEmission = new float[12];
|
|
_GlitterStrength = new float[12];
|
|
}
|
|
|
|
public void ReInit(Terrain terrainComp)
|
|
{
|
|
if (terrainComp.terrainData.splatPrototypes.Length > numLayers)
|
|
{
|
|
Texture2D[] array = new Texture2D[terrainComp.terrainData.splatPrototypes.Length];
|
|
Texture2D[] array2 = new Texture2D[terrainComp.terrainData.splatPrototypes.Length];
|
|
for (int i = 0; i < splats.Length; i++)
|
|
{
|
|
array[i] = splats[i];
|
|
array2[i] = Bumps[i];
|
|
}
|
|
splats = array;
|
|
Bumps = array2;
|
|
splats[terrainComp.terrainData.splatPrototypes.Length - 1] = terrainComp.terrainData.splatPrototypes[(terrainComp.terrainData.splatPrototypes.Length - 2 >= 0) ? (terrainComp.terrainData.splatPrototypes.Length - 2) : 0].texture;
|
|
Bumps[terrainComp.terrainData.splatPrototypes.Length - 1] = terrainComp.terrainData.splatPrototypes[(terrainComp.terrainData.splatPrototypes.Length - 2 >= 0) ? (terrainComp.terrainData.splatPrototypes.Length - 2) : 0].normalMap;
|
|
}
|
|
else if (terrainComp.terrainData.splatPrototypes.Length < numLayers)
|
|
{
|
|
Texture2D[] array3 = new Texture2D[terrainComp.terrainData.splatPrototypes.Length];
|
|
Texture2D[] array4 = new Texture2D[terrainComp.terrainData.splatPrototypes.Length];
|
|
for (int j = 0; j < array3.Length; j++)
|
|
{
|
|
array3[j] = splats[j];
|
|
array4[j] = Bumps[j];
|
|
}
|
|
splats = array3;
|
|
Bumps = array4;
|
|
}
|
|
numLayers = terrainComp.terrainData.splatPrototypes.Length;
|
|
}
|
|
|
|
public void SetShaderParam(string name, Texture2D tex)
|
|
{
|
|
if ((bool)tex)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetTexture(name, tex);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalTexture(name, tex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetShaderParam(string name, Cubemap tex)
|
|
{
|
|
if ((bool)tex)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetTexture(name, tex);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalTexture(name, tex);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetShaderParam(string name, Matrix4x4 mtx)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetMatrix(name, mtx);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalMatrix(name, mtx);
|
|
}
|
|
}
|
|
|
|
public void SetShaderParam(string name, Vector4 vec)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetVector(name, vec);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalVector(name, vec);
|
|
}
|
|
}
|
|
|
|
public void SetShaderParam(string name, float val)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetFloat(name, val);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalFloat(name, val);
|
|
}
|
|
}
|
|
|
|
public void SetShaderParam(string name, Color col)
|
|
{
|
|
if ((bool)use_mat)
|
|
{
|
|
use_mat.SetColor(name, col);
|
|
}
|
|
else
|
|
{
|
|
Shader.SetGlobalColor(name, col);
|
|
}
|
|
}
|
|
|
|
public RTP_LODmanager Get_RTP_LODmanagerScript()
|
|
{
|
|
return _RTP_LODmanagerScript;
|
|
}
|
|
|
|
private void CheckLightScriptForDefered()
|
|
{
|
|
Light[] array = UnityEngine.Object.FindObjectsOfType<Light>();
|
|
Light light = null;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (array[i].type == LightType.Directional)
|
|
{
|
|
if (!(array[i].gameObject.GetComponent<ReliefShaders_applyLightForDeferred>() == null))
|
|
{
|
|
return;
|
|
}
|
|
light = array[i];
|
|
}
|
|
}
|
|
if ((bool)light)
|
|
{
|
|
ReliefShaders_applyLightForDeferred reliefShaders_applyLightForDeferred = light.gameObject.AddComponent(typeof(ReliefShaders_applyLightForDeferred)) as ReliefShaders_applyLightForDeferred;
|
|
reliefShaders_applyLightForDeferred.lightForSelfShadowing = light;
|
|
}
|
|
}
|
|
|
|
public void RefreshAll()
|
|
{
|
|
CheckLightScriptForDefered();
|
|
ReliefTerrain[] array = UnityEngine.Object.FindObjectsOfType(typeof(ReliefTerrain)) as ReliefTerrain[];
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
if (array[i].globalSettingsHolder != null)
|
|
{
|
|
Terrain terrain = array[i].GetComponent(typeof(Terrain)) as Terrain;
|
|
if ((bool)terrain)
|
|
{
|
|
array[i].globalSettingsHolder.Refresh(terrain.materialTemplate);
|
|
}
|
|
else
|
|
{
|
|
array[i].globalSettingsHolder.Refresh(array[i].GetComponent<Renderer>().sharedMaterial);
|
|
}
|
|
array[i].RefreshTextures();
|
|
}
|
|
}
|
|
GeometryVsTerrainBlend[] array2 = UnityEngine.Object.FindObjectsOfType(typeof(GeometryVsTerrainBlend)) as GeometryVsTerrainBlend[];
|
|
for (int j = 0; j < array2.Length; j++)
|
|
{
|
|
array2[j].SetupValues();
|
|
}
|
|
}
|
|
|
|
public void Refresh(Material mat = null, ReliefTerrain rt_caller = null)
|
|
{
|
|
if (splats == null)
|
|
{
|
|
return;
|
|
}
|
|
if (mat == null && rt_caller != null && rt_caller.globalSettingsHolder == this)
|
|
{
|
|
Terrain terrain = rt_caller.GetComponent(typeof(Terrain)) as Terrain;
|
|
if ((bool)terrain)
|
|
{
|
|
rt_caller.globalSettingsHolder.Refresh(terrain.materialTemplate);
|
|
}
|
|
else if (rt_caller.GetComponent<Renderer>() != null && rt_caller.GetComponent<Renderer>().sharedMaterial != null)
|
|
{
|
|
rt_caller.globalSettingsHolder.Refresh(rt_caller.GetComponent<Renderer>().sharedMaterial);
|
|
}
|
|
}
|
|
use_mat = mat;
|
|
if (mat != null)
|
|
{
|
|
mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
|
|
}
|
|
for (int i = 0; i < numLayers; i++)
|
|
{
|
|
if (i < 4)
|
|
{
|
|
SetShaderParam("_SplatA" + i, splats[i]);
|
|
}
|
|
else if (i < 8)
|
|
{
|
|
if (_4LAYERS_SHADER_USED)
|
|
{
|
|
SetShaderParam("_SplatC" + (i - 4), splats[i]);
|
|
SetShaderParam("_SplatB" + (i - 4), splats[i]);
|
|
}
|
|
else
|
|
{
|
|
SetShaderParam("_SplatB" + (i - 4), splats[i]);
|
|
}
|
|
}
|
|
else if (i < 12)
|
|
{
|
|
SetShaderParam("_SplatC" + (i - 4), splats[i]);
|
|
}
|
|
}
|
|
CheckAndUpdate(ref RTP_DiffFresnel, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_metallic, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_glossMin, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_glossMax, 1f, numLayers);
|
|
CheckAndUpdate(ref RTP_glitter, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterGloss, 0.1f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterGlossDamper, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterMetallic, 0.1f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WetGloss, 0.05f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WetFlow, 0.05f, numLayers);
|
|
CheckAndUpdate(ref MixBrightness, 2f, numLayers);
|
|
CheckAndUpdate(ref MixReplace, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerBrightness, 1f, numLayers);
|
|
CheckAndUpdate(ref LayerBrightness2Spec, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerAlbedo2SpecColor, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerSaturation, 1f, numLayers);
|
|
CheckAndUpdate(ref LayerEmission, 0f, numLayers);
|
|
CheckAndUpdate(ref FarSpecCorrection, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionColor, Color.black, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionRefractStrength, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionRefractHBedge, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterEmission, 0f, numLayers);
|
|
CheckAndUpdate(ref _GlitterStrength, 0f, numLayers);
|
|
SetShaderParam("terrainTileSize", terrainTileSize);
|
|
SetShaderParam("RTP_AOamp", RTP_AOamp);
|
|
SetShaderParam("RTP_AOsharpness", RTP_AOsharpness);
|
|
SetShaderParam("_occlusionStrength", _occlusionStrength);
|
|
SetShaderParam("EmissionRefractFiltering", EmissionRefractFiltering);
|
|
SetShaderParam("EmissionRefractAnimSpeed", EmissionRefractAnimSpeed);
|
|
SetShaderParam("_VerticalTexture", VerticalTexture);
|
|
SetShaderParam("_GlobalColorMapBlendValues", GlobalColorMapBlendValues);
|
|
SetShaderParam("_GlobalColorMapSaturation", GlobalColorMapSaturation);
|
|
SetShaderParam("_GlobalColorMapSaturationFar", GlobalColorMapSaturationFar);
|
|
SetShaderParam("_GlobalColorMapDistortByPerlin", GlobalColorMapDistortByPerlin);
|
|
SetShaderParam("_GlobalColorMapBrightness", GlobalColorMapBrightness);
|
|
SetShaderParam("_GlobalColorMapBrightnessFar", GlobalColorMapBrightnessFar);
|
|
SetShaderParam("_GlobalColorMapNearMIP", _GlobalColorMapNearMIP);
|
|
SetShaderParam("_RTP_MIP_BIAS", RTP_MIP_BIAS);
|
|
SetShaderParam("_BumpMapGlobalScale", BumpMapGlobalScale);
|
|
SetShaderParam("_FarNormalDamp", _FarNormalDamp);
|
|
SetShaderParam("_blend_multiplier", blendMultiplier);
|
|
SetShaderParam("_TERRAIN_ReliefTransform", ReliefTransform);
|
|
SetShaderParam("_TERRAIN_ReliefTransformTriplanarZ", ReliefTransform.x);
|
|
SetShaderParam("_TERRAIN_DIST_STEPS", DIST_STEPS);
|
|
SetShaderParam("_TERRAIN_WAVELENGTH", WAVELENGTH);
|
|
SetShaderParam("_TERRAIN_ExtrudeHeight", ExtrudeHeight);
|
|
SetShaderParam("_TERRAIN_LightmapShading", LightmapShading);
|
|
SetShaderParam("_TERRAIN_SHADOW_STEPS", SHADOW_STEPS);
|
|
SetShaderParam("_TERRAIN_WAVELENGTH_SHADOWS", WAVELENGTH_SHADOWS);
|
|
SetShaderParam("_TERRAIN_SelfShadowStrength", SelfShadowStrength);
|
|
SetShaderParam("_TERRAIN_ShadowSmoothing", (1f - ShadowSmoothing) * 6f);
|
|
SetShaderParam("_TERRAIN_ShadowSoftnessFade", ShadowSoftnessFade);
|
|
SetShaderParam("_TERRAIN_distance_start", distance_start);
|
|
SetShaderParam("_TERRAIN_distance_transition", distance_transition);
|
|
SetShaderParam("_TERRAIN_distance_start_bumpglobal", distance_start_bumpglobal);
|
|
SetShaderParam("_TERRAIN_distance_transition_bumpglobal", distance_transition_bumpglobal);
|
|
SetShaderParam("rtp_perlin_start_val", rtp_perlin_start_val);
|
|
Shader.SetGlobalVector("_TERRAIN_trees_shadow_values", new Vector4(trees_shadow_distance_start, trees_shadow_distance_transition, trees_shadow_value, global_normalMap_multiplier));
|
|
Shader.SetGlobalVector("_TERRAIN_trees_pixel_values", new Vector4(trees_pixel_distance_start, trees_pixel_distance_transition, trees_pixel_blend_val, global_normalMap_farUsage));
|
|
SetShaderParam("_Phong", _Phong);
|
|
SetShaderParam("_TessSubdivisions", _TessSubdivisions);
|
|
SetShaderParam("_TessSubdivisionsFar", _TessSubdivisionsFar);
|
|
SetShaderParam("_TessYOffset", _TessYOffset);
|
|
Shader.SetGlobalFloat("_AmbientEmissiveMultiplier", _AmbientEmissiveMultiplier);
|
|
Shader.SetGlobalFloat("_AmbientEmissiveRelief", _AmbientEmissiveRelief);
|
|
SetShaderParam("_SuperDetailTiling", _SuperDetailTiling);
|
|
Shader.SetGlobalFloat("rtp_snow_strength", _snow_strength);
|
|
Shader.SetGlobalFloat("rtp_global_color_brightness_to_snow", _global_color_brightness_to_snow);
|
|
Shader.SetGlobalFloat("rtp_snow_slope_factor", _snow_slope_factor);
|
|
Shader.SetGlobalFloat("rtp_snow_edge_definition", _snow_edge_definition);
|
|
Shader.SetGlobalFloat("rtp_snow_height_treshold", _snow_height_treshold);
|
|
Shader.SetGlobalFloat("rtp_snow_height_transition", _snow_height_transition);
|
|
Shader.SetGlobalColor("rtp_snow_color", _snow_color);
|
|
Shader.SetGlobalFloat("rtp_snow_gloss", _snow_gloss);
|
|
Shader.SetGlobalFloat("rtp_snow_reflectivness", _snow_reflectivness);
|
|
Shader.SetGlobalFloat("rtp_snow_deep_factor", _snow_deep_factor);
|
|
Shader.SetGlobalFloat("rtp_snow_diff_fresnel", _snow_diff_fresnel);
|
|
Shader.SetGlobalFloat("rtp_snow_metallic", _snow_metallic);
|
|
Shader.SetGlobalFloat("rtp_snow_Frost", _snow_Frost);
|
|
Shader.SetGlobalFloat("rtp_snow_MicroTiling", _snow_MicroTiling);
|
|
Shader.SetGlobalFloat("rtp_snow_BumpMicro", _snow_BumpMicro);
|
|
Shader.SetGlobalFloat("rtp_snow_occlusionStrength", _snow_occlusionStrength);
|
|
Shader.SetGlobalFloat("rtp_snow_TranslucencyDeferredLightIndex", _snow_TranslucencyDeferredLightIndex);
|
|
Shader.SetGlobalColor("_SnowGlitterColor", _SnowGlitterColor);
|
|
SetShaderParam("TERRAIN_CausticsAnimSpeed", TERRAIN_CausticsAnimSpeed);
|
|
SetShaderParam("TERRAIN_CausticsColor", TERRAIN_CausticsColor);
|
|
if ((bool)TERRAIN_CausticsWaterLevelRefObject)
|
|
{
|
|
TERRAIN_CausticsWaterLevel = TERRAIN_CausticsWaterLevelRefObject.transform.position.y;
|
|
}
|
|
Shader.SetGlobalFloat("TERRAIN_CausticsWaterLevel", TERRAIN_CausticsWaterLevel);
|
|
Shader.SetGlobalFloat("TERRAIN_CausticsWaterLevelByAngle", TERRAIN_CausticsWaterLevelByAngle);
|
|
Shader.SetGlobalFloat("TERRAIN_CausticsWaterDeepFadeLength", TERRAIN_CausticsWaterDeepFadeLength);
|
|
Shader.SetGlobalFloat("TERRAIN_CausticsWaterShallowFadeLength", TERRAIN_CausticsWaterShallowFadeLength);
|
|
SetShaderParam("TERRAIN_CausticsTilingScale", TERRAIN_CausticsTilingScale);
|
|
SetShaderParam("TERRAIN_CausticsTex", TERRAIN_CausticsTex);
|
|
SetShaderParam("_GlitterColor", _GlitterColor);
|
|
SetShaderParam("_GlitterTiling", _GlitterTiling);
|
|
SetShaderParam("_GlitterDensity", _GlitterDensity);
|
|
SetShaderParam("_GlitterFilter", _GlitterFilter);
|
|
SetShaderParam("_GlitterColorization", _GlitterColorization);
|
|
SetShaderParam("_SparkleMap", _SparkleMap);
|
|
if (numLayers > 0)
|
|
{
|
|
int num = 512;
|
|
for (int j = 0; j < numLayers; j++)
|
|
{
|
|
if ((bool)splats[j])
|
|
{
|
|
num = splats[j].width;
|
|
break;
|
|
}
|
|
}
|
|
SetShaderParam("rtp_mipoffset_color", (0f - Mathf.Log(1024f / (float)num)) / Mathf.Log(2f));
|
|
if (Bump01 != null)
|
|
{
|
|
num = Bump01.width;
|
|
}
|
|
SetShaderParam("rtp_mipoffset_bump", (0f - Mathf.Log(1024f / (float)num)) / Mathf.Log(2f));
|
|
if ((bool)HeightMap)
|
|
{
|
|
num = HeightMap.width;
|
|
}
|
|
else if ((bool)HeightMap2)
|
|
{
|
|
num = HeightMap2.width;
|
|
}
|
|
else if ((bool)HeightMap3)
|
|
{
|
|
num = HeightMap3.width;
|
|
}
|
|
SetShaderParam("rtp_mipoffset_height", (0f - Mathf.Log(1024f / (float)num)) / Mathf.Log(2f));
|
|
num = BumpGlobalCombinedSize;
|
|
SetShaderParam("rtp_mipoffset_globalnorm", (0f - Mathf.Log(1024f / ((float)num * BumpMapGlobalScale))) / Mathf.Log(2f) + (float)rtp_mipoffset_globalnorm);
|
|
SetShaderParam("rtp_mipoffset_superdetail", (0f - Mathf.Log(1024f / ((float)num * _SuperDetailTiling))) / Mathf.Log(2f));
|
|
SetShaderParam("rtp_mipoffset_flow", (0f - Mathf.Log(1024f / ((float)num * TERRAIN_FlowScale))) / Mathf.Log(2f) + TERRAIN_FlowMipOffset);
|
|
if ((bool)TERRAIN_RippleMap)
|
|
{
|
|
num = TERRAIN_RippleMap.width;
|
|
}
|
|
SetShaderParam("rtp_mipoffset_ripple", (0f - Mathf.Log(1024f / ((float)num * TERRAIN_RippleScale))) / Mathf.Log(2f));
|
|
if ((bool)TERRAIN_CausticsTex)
|
|
{
|
|
num = TERRAIN_CausticsTex.width;
|
|
}
|
|
SetShaderParam("rtp_mipoffset_caustics", (0f - Mathf.Log(1024f / ((float)num * TERRAIN_CausticsTilingScale))) / Mathf.Log(2f));
|
|
}
|
|
Shader.SetGlobalFloat("TERRAIN_GlobalWetness", TERRAIN_GlobalWetness);
|
|
SetShaderParam("TERRAIN_RippleMap", TERRAIN_RippleMap);
|
|
SetShaderParam("TERRAIN_RippleScale", TERRAIN_RippleScale);
|
|
SetShaderParam("TERRAIN_FlowScale", TERRAIN_FlowScale);
|
|
SetShaderParam("TERRAIN_FlowMipOffset", TERRAIN_FlowMipOffset);
|
|
SetShaderParam("TERRAIN_FlowSpeed", TERRAIN_FlowSpeed);
|
|
SetShaderParam("TERRAIN_FlowCycleScale", TERRAIN_FlowCycleScale);
|
|
Shader.SetGlobalFloat("TERRAIN_RainIntensity", TERRAIN_RainIntensity);
|
|
SetShaderParam("TERRAIN_DropletsSpeed", TERRAIN_DropletsSpeed);
|
|
SetShaderParam("TERRAIN_WetDropletsStrength", TERRAIN_WetDropletsStrength);
|
|
SetShaderParam("TERRAIN_WetDarkening", TERRAIN_WetDarkening);
|
|
SetShaderParam("TERRAIN_mipoffset_flowSpeed", TERRAIN_mipoffset_flowSpeed);
|
|
SetShaderParam("TERRAIN_WetHeight_Treshold", TERRAIN_WetHeight_Treshold);
|
|
SetShaderParam("TERRAIN_WetHeight_Transition", TERRAIN_WetHeight_Transition);
|
|
Shader.SetGlobalVector("RTP_LightDefVector", RTP_LightDefVector);
|
|
SetShaderParam("_VerticalTextureGlobalBumpInfluence", VerticalTextureGlobalBumpInfluence);
|
|
SetShaderParam("_VerticalTextureTiling", VerticalTextureTiling);
|
|
SetShaderParam("_FarSpecCorrection0123", getVector(FarSpecCorrection, 0, 3));
|
|
SetShaderParam("_MIPmult0123", getVector(MIPmult, 0, 3));
|
|
SetShaderParam("_MixScale0123", getVector(MixScale, 0, 3));
|
|
SetShaderParam("_MixBlend0123", getVector(MixBlend, 0, 3));
|
|
SetShaderParam("_MixSaturation0123", getVector(MixSaturation, 0, 3));
|
|
SetShaderParam("RTP_DiffFresnel0123", getVector(RTP_DiffFresnel, 0, 3));
|
|
SetShaderParam("RTP_metallic0123", getVector(RTP_metallic, 0, 3));
|
|
SetShaderParam("RTP_glossMin0123", getVector(RTP_glossMin, 0, 3));
|
|
SetShaderParam("RTP_glossMax0123", getVector(RTP_glossMax, 0, 3));
|
|
SetShaderParam("RTP_glitter0123", getVector(RTP_glitter, 0, 3));
|
|
SetShaderParam("_MixBrightness0123", getVector(MixBrightness, 0, 3));
|
|
SetShaderParam("_MixReplace0123", getVector(MixReplace, 0, 3));
|
|
SetShaderParam("_LayerBrightness0123", MasterLayerBrightness * getVector(LayerBrightness, 0, 3));
|
|
SetShaderParam("_LayerSaturation0123", MasterLayerSaturation * getVector(LayerSaturation, 0, 3));
|
|
SetShaderParam("_LayerEmission0123", getVector(LayerEmission, 0, 3));
|
|
SetShaderParam("_LayerEmissionColorR0123", getColorVector(LayerEmissionColor, 0, 3, 0));
|
|
SetShaderParam("_LayerEmissionColorG0123", getColorVector(LayerEmissionColor, 0, 3, 1));
|
|
SetShaderParam("_LayerEmissionColorB0123", getColorVector(LayerEmissionColor, 0, 3, 2));
|
|
SetShaderParam("_LayerEmissionColorA0123", getColorVector(LayerEmissionColor, 0, 3, 3));
|
|
SetShaderParam("_LayerBrightness2Spec0123", getVector(LayerBrightness2Spec, 0, 3));
|
|
SetShaderParam("_LayerAlbedo2SpecColor0123", getVector(LayerAlbedo2SpecColor, 0, 3));
|
|
SetShaderParam("_LayerEmissionRefractStrength0123", getVector(LayerEmissionRefractStrength, 0, 3));
|
|
SetShaderParam("_LayerEmissionRefractHBedge0123", getVector(LayerEmissionRefractHBedge, 0, 3));
|
|
SetShaderParam("_GlobalColorPerLayer0123", getVector(GlobalColorPerLayer, 0, 3));
|
|
SetShaderParam("_GlobalColorBottom0123", getVector(GlobalColorBottom, 0, 3));
|
|
SetShaderParam("_GlobalColorTop0123", getVector(GlobalColorTop, 0, 3));
|
|
SetShaderParam("_GlobalColorColormapLoSat0123", getVector(GlobalColorColormapLoSat, 0, 3));
|
|
SetShaderParam("_GlobalColorColormapHiSat0123", getVector(GlobalColorColormapHiSat, 0, 3));
|
|
SetShaderParam("_GlobalColorLayerLoSat0123", getVector(GlobalColorLayerLoSat, 0, 3));
|
|
SetShaderParam("_GlobalColorLayerHiSat0123", getVector(GlobalColorLayerHiSat, 0, 3));
|
|
SetShaderParam("_GlobalColorLoBlend0123", getVector(GlobalColorLoBlend, 0, 3));
|
|
SetShaderParam("_GlobalColorHiBlend0123", getVector(GlobalColorHiBlend, 0, 3));
|
|
SetShaderParam("PER_LAYER_HEIGHT_MODIFIER0123", getVector(PER_LAYER_HEIGHT_MODIFIER, 0, 3));
|
|
SetShaderParam("rtp_snow_strength_per_layer0123", getVector(_snow_strength_per_layer, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultA0123", getVector(_SuperDetailStrengthMultA, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultB0123", getVector(_SuperDetailStrengthMultB, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthNormal0123", getVector(_SuperDetailStrengthNormal, 0, 3));
|
|
SetShaderParam("_BumpMapGlobalStrength0123", getVector(_BumpMapGlobalStrength, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskNear0123", getVector(_SuperDetailStrengthMultASelfMaskNear, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskFar0123", getVector(_SuperDetailStrengthMultASelfMaskFar, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskNear0123", getVector(_SuperDetailStrengthMultBSelfMaskNear, 0, 3));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskFar0123", getVector(_SuperDetailStrengthMultBSelfMaskFar, 0, 3));
|
|
SetShaderParam("TERRAIN_LayerWetStrength0123", getVector(TERRAIN_LayerWetStrength, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterLevel0123", getVector(TERRAIN_WaterLevel, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterLevelSlopeDamp0123", getVector(TERRAIN_WaterLevelSlopeDamp, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterEdge0123", getVector(TERRAIN_WaterEdge, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterGloss0123", getVector(TERRAIN_WaterGloss, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterGlossDamper0123", getVector(TERRAIN_WaterGlossDamper, 0, 3));
|
|
SetShaderParam("TERRAIN_Refraction0123", getVector(TERRAIN_Refraction, 0, 3));
|
|
SetShaderParam("TERRAIN_WetRefraction0123", getVector(TERRAIN_WetRefraction, 0, 3));
|
|
SetShaderParam("TERRAIN_Flow0123", getVector(TERRAIN_Flow, 0, 3));
|
|
SetShaderParam("TERRAIN_WetFlow0123", getVector(TERRAIN_WetFlow, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterMetallic0123", getVector(TERRAIN_WaterMetallic, 0, 3));
|
|
SetShaderParam("TERRAIN_WetGloss0123", getVector(TERRAIN_WetGloss, 0, 3));
|
|
SetShaderParam("TERRAIN_WaterColorR0123", getColorVector(TERRAIN_WaterColor, 0, 3, 0));
|
|
SetShaderParam("TERRAIN_WaterColorG0123", getColorVector(TERRAIN_WaterColor, 0, 3, 1));
|
|
SetShaderParam("TERRAIN_WaterColorB0123", getColorVector(TERRAIN_WaterColor, 0, 3, 2));
|
|
SetShaderParam("TERRAIN_WaterColorA0123", getColorVector(TERRAIN_WaterColor, 0, 3, 3));
|
|
SetShaderParam("TERRAIN_WaterEmission0123", getVector(TERRAIN_WaterEmission, 0, 3));
|
|
SetShaderParam("_GlitterStrength0123", getVector(_GlitterStrength, 0, 3));
|
|
SetShaderParam("RTP_AO_0123", getVector(AO_strength, 0, 3));
|
|
SetShaderParam("_VerticalTexture0123", getVector(VerticalTextureStrength, 0, 3));
|
|
if (numLayers > 4 && _4LAYERS_SHADER_USED)
|
|
{
|
|
SetShaderParam("_FarSpecCorrection89AB", getVector(FarSpecCorrection, 4, 7));
|
|
SetShaderParam("_MIPmult89AB", getVector(MIPmult, 4, 7));
|
|
SetShaderParam("_MixScale89AB", getVector(MixScale, 4, 7));
|
|
SetShaderParam("_MixBlend89AB", getVector(MixBlend, 4, 7));
|
|
SetShaderParam("_MixSaturation89AB", getVector(MixSaturation, 4, 7));
|
|
SetShaderParam("RTP_DiffFresnel89AB", getVector(RTP_DiffFresnel, 4, 7));
|
|
SetShaderParam("RTP_metallic89AB", getVector(RTP_metallic, 4, 7));
|
|
SetShaderParam("RTP_glossMin89AB", getVector(RTP_glossMin, 4, 7));
|
|
SetShaderParam("RTP_glossMax89AB", getVector(RTP_glossMax, 4, 7));
|
|
SetShaderParam("RTP_glitter89AB", getVector(RTP_glitter, 4, 7));
|
|
SetShaderParam("_MixBrightness89AB", getVector(MixBrightness, 4, 7));
|
|
SetShaderParam("_MixReplace89AB", getVector(MixReplace, 4, 7));
|
|
SetShaderParam("_LayerBrightness89AB", MasterLayerBrightness * getVector(LayerBrightness, 4, 7));
|
|
SetShaderParam("_LayerSaturation89AB", MasterLayerSaturation * getVector(LayerSaturation, 4, 7));
|
|
SetShaderParam("_LayerEmission89AB", getVector(LayerEmission, 4, 7));
|
|
SetShaderParam("_LayerEmissionColorR89AB", getColorVector(LayerEmissionColor, 4, 7, 0));
|
|
SetShaderParam("_LayerEmissionColorG89AB", getColorVector(LayerEmissionColor, 4, 7, 1));
|
|
SetShaderParam("_LayerEmissionColorB89AB", getColorVector(LayerEmissionColor, 4, 7, 2));
|
|
SetShaderParam("_LayerEmissionColorA89AB", getColorVector(LayerEmissionColor, 4, 7, 3));
|
|
SetShaderParam("_LayerBrightness2Spec89AB", getVector(LayerBrightness2Spec, 4, 7));
|
|
SetShaderParam("_LayerAlbedo2SpecColor89AB", getVector(LayerAlbedo2SpecColor, 4, 7));
|
|
SetShaderParam("_LayerEmissionRefractStrength89AB", getVector(LayerEmissionRefractStrength, 4, 7));
|
|
SetShaderParam("_LayerEmissionRefractHBedge89AB", getVector(LayerEmissionRefractHBedge, 4, 7));
|
|
SetShaderParam("_GlobalColorPerLayer89AB", getVector(GlobalColorPerLayer, 4, 7));
|
|
SetShaderParam("_GlobalColorBottom89AB", getVector(GlobalColorBottom, 4, 7));
|
|
SetShaderParam("_GlobalColorTop89AB", getVector(GlobalColorTop, 4, 7));
|
|
SetShaderParam("_GlobalColorColormapLoSat89AB", getVector(GlobalColorColormapLoSat, 4, 7));
|
|
SetShaderParam("_GlobalColorColormapHiSat89AB", getVector(GlobalColorColormapHiSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLayerLoSat89AB", getVector(GlobalColorLayerLoSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLayerHiSat89AB", getVector(GlobalColorLayerHiSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLoBlend89AB", getVector(GlobalColorLoBlend, 4, 7));
|
|
SetShaderParam("_GlobalColorHiBlend89AB", getVector(GlobalColorHiBlend, 4, 7));
|
|
SetShaderParam("PER_LAYER_HEIGHT_MODIFIER89AB", getVector(PER_LAYER_HEIGHT_MODIFIER, 4, 7));
|
|
SetShaderParam("rtp_snow_strength_per_layer89AB", getVector(_snow_strength_per_layer, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultA89AB", getVector(_SuperDetailStrengthMultA, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultB89AB", getVector(_SuperDetailStrengthMultB, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthNormal89AB", getVector(_SuperDetailStrengthNormal, 4, 7));
|
|
SetShaderParam("_BumpMapGlobalStrength89AB", getVector(_BumpMapGlobalStrength, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskNear89AB", getVector(_SuperDetailStrengthMultASelfMaskNear, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskFar89AB", getVector(_SuperDetailStrengthMultASelfMaskFar, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskNear89AB", getVector(_SuperDetailStrengthMultBSelfMaskNear, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskFar89AB", getVector(_SuperDetailStrengthMultBSelfMaskFar, 4, 7));
|
|
SetShaderParam("TERRAIN_LayerWetStrength89AB", getVector(TERRAIN_LayerWetStrength, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterLevel89AB", getVector(TERRAIN_WaterLevel, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterLevelSlopeDamp89AB", getVector(TERRAIN_WaterLevelSlopeDamp, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterEdge89AB", getVector(TERRAIN_WaterEdge, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterGloss89AB", getVector(TERRAIN_WaterGloss, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterGlossDamper89AB", getVector(TERRAIN_WaterGlossDamper, 4, 7));
|
|
SetShaderParam("TERRAIN_Refraction89AB", getVector(TERRAIN_Refraction, 4, 7));
|
|
SetShaderParam("TERRAIN_WetRefraction89AB", getVector(TERRAIN_WetRefraction, 4, 7));
|
|
SetShaderParam("TERRAIN_Flow89AB", getVector(TERRAIN_Flow, 4, 7));
|
|
SetShaderParam("TERRAIN_WetFlow89AB", getVector(TERRAIN_WetFlow, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterMetallic89AB", getVector(TERRAIN_WaterMetallic, 4, 7));
|
|
SetShaderParam("TERRAIN_WetGloss89AB", getVector(TERRAIN_WetGloss, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterColorR89AB", getColorVector(TERRAIN_WaterColor, 4, 7, 0));
|
|
SetShaderParam("TERRAIN_WaterColorG89AB", getColorVector(TERRAIN_WaterColor, 4, 7, 1));
|
|
SetShaderParam("TERRAIN_WaterColorB89AB", getColorVector(TERRAIN_WaterColor, 4, 7, 2));
|
|
SetShaderParam("TERRAIN_WaterColorA89AB", getColorVector(TERRAIN_WaterColor, 4, 7, 3));
|
|
SetShaderParam("TERRAIN_WaterEmission89AB", getVector(TERRAIN_WaterEmission, 4, 7));
|
|
SetShaderParam("_GlitterStrength89AB", getVector(_GlitterStrength, 4, 7));
|
|
SetShaderParam("RTP_AO_89AB", getVector(AO_strength, 4, 7));
|
|
SetShaderParam("_VerticalTexture89AB", getVector(VerticalTextureStrength, 4, 7));
|
|
}
|
|
else
|
|
{
|
|
SetShaderParam("_FarSpecCorrection4567", getVector(FarSpecCorrection, 4, 7));
|
|
SetShaderParam("_MIPmult4567", getVector(MIPmult, 4, 7));
|
|
SetShaderParam("_MixScale4567", getVector(MixScale, 4, 7));
|
|
SetShaderParam("_MixBlend4567", getVector(MixBlend, 4, 7));
|
|
SetShaderParam("_MixSaturation4567", getVector(MixSaturation, 4, 7));
|
|
SetShaderParam("RTP_DiffFresnel4567", getVector(RTP_DiffFresnel, 4, 7));
|
|
SetShaderParam("RTP_metallic4567", getVector(RTP_metallic, 4, 7));
|
|
SetShaderParam("RTP_glossMin4567", getVector(RTP_glossMin, 4, 7));
|
|
SetShaderParam("RTP_glossMax4567", getVector(RTP_glossMax, 4, 7));
|
|
SetShaderParam("RTP_glitter4567", getVector(RTP_glitter, 4, 7));
|
|
SetShaderParam("_MixBrightness4567", getVector(MixBrightness, 4, 7));
|
|
SetShaderParam("_MixReplace4567", getVector(MixReplace, 4, 7));
|
|
SetShaderParam("_LayerBrightness4567", MasterLayerBrightness * getVector(LayerBrightness, 4, 7));
|
|
SetShaderParam("_LayerSaturation4567", MasterLayerSaturation * getVector(LayerSaturation, 4, 7));
|
|
SetShaderParam("_LayerEmission4567", getVector(LayerEmission, 4, 7));
|
|
SetShaderParam("_LayerEmissionColorR4567", getColorVector(LayerEmissionColor, 4, 7, 0));
|
|
SetShaderParam("_LayerEmissionColorG4567", getColorVector(LayerEmissionColor, 4, 7, 1));
|
|
SetShaderParam("_LayerEmissionColorB4567", getColorVector(LayerEmissionColor, 4, 7, 2));
|
|
SetShaderParam("_LayerEmissionColorA4567", getColorVector(LayerEmissionColor, 4, 7, 3));
|
|
SetShaderParam("_LayerBrightness2Spec4567", getVector(LayerBrightness2Spec, 4, 7));
|
|
SetShaderParam("_LayerAlbedo2SpecColor4567", getVector(LayerAlbedo2SpecColor, 4, 7));
|
|
SetShaderParam("_LayerEmissionRefractStrength4567", getVector(LayerEmissionRefractStrength, 4, 7));
|
|
SetShaderParam("_LayerEmissionRefractHBedge4567", getVector(LayerEmissionRefractHBedge, 4, 7));
|
|
SetShaderParam("_GlobalColorPerLayer4567", getVector(GlobalColorPerLayer, 4, 7));
|
|
SetShaderParam("_GlobalColorBottom4567", getVector(GlobalColorBottom, 4, 7));
|
|
SetShaderParam("_GlobalColorTop4567", getVector(GlobalColorTop, 4, 7));
|
|
SetShaderParam("_GlobalColorColormapLoSat4567", getVector(GlobalColorColormapLoSat, 4, 7));
|
|
SetShaderParam("_GlobalColorColormapHiSat4567", getVector(GlobalColorColormapHiSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLayerLoSat4567", getVector(GlobalColorLayerLoSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLayerHiSat4567", getVector(GlobalColorLayerHiSat, 4, 7));
|
|
SetShaderParam("_GlobalColorLoBlend4567", getVector(GlobalColorLoBlend, 4, 7));
|
|
SetShaderParam("_GlobalColorHiBlend4567", getVector(GlobalColorHiBlend, 4, 7));
|
|
SetShaderParam("PER_LAYER_HEIGHT_MODIFIER4567", getVector(PER_LAYER_HEIGHT_MODIFIER, 4, 7));
|
|
SetShaderParam("rtp_snow_strength_per_layer4567", getVector(_snow_strength_per_layer, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultA4567", getVector(_SuperDetailStrengthMultA, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultB4567", getVector(_SuperDetailStrengthMultB, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthNormal4567", getVector(_SuperDetailStrengthNormal, 4, 7));
|
|
SetShaderParam("_BumpMapGlobalStrength4567", getVector(_BumpMapGlobalStrength, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskNear4567", getVector(_SuperDetailStrengthMultASelfMaskNear, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskFar4567", getVector(_SuperDetailStrengthMultASelfMaskFar, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskNear4567", getVector(_SuperDetailStrengthMultBSelfMaskNear, 4, 7));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskFar4567", getVector(_SuperDetailStrengthMultBSelfMaskFar, 4, 7));
|
|
SetShaderParam("TERRAIN_LayerWetStrength4567", getVector(TERRAIN_LayerWetStrength, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterLevel4567", getVector(TERRAIN_WaterLevel, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterLevelSlopeDamp4567", getVector(TERRAIN_WaterLevelSlopeDamp, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterEdge4567", getVector(TERRAIN_WaterEdge, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterGloss4567", getVector(TERRAIN_WaterGloss, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterGlossDamper4567", getVector(TERRAIN_WaterGlossDamper, 4, 7));
|
|
SetShaderParam("TERRAIN_Refraction4567", getVector(TERRAIN_Refraction, 4, 7));
|
|
SetShaderParam("TERRAIN_WetRefraction4567", getVector(TERRAIN_WetRefraction, 4, 7));
|
|
SetShaderParam("TERRAIN_Flow4567", getVector(TERRAIN_Flow, 4, 7));
|
|
SetShaderParam("TERRAIN_WetFlow4567", getVector(TERRAIN_WetFlow, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterMetallic4567", getVector(TERRAIN_WaterMetallic, 4, 7));
|
|
SetShaderParam("TERRAIN_WetGloss4567", getVector(TERRAIN_WetGloss, 4, 7));
|
|
SetShaderParam("TERRAIN_WaterColorR4567", getColorVector(TERRAIN_WaterColor, 4, 7, 0));
|
|
SetShaderParam("TERRAIN_WaterColorG4567", getColorVector(TERRAIN_WaterColor, 4, 7, 1));
|
|
SetShaderParam("TERRAIN_WaterColorB4567", getColorVector(TERRAIN_WaterColor, 4, 7, 2));
|
|
SetShaderParam("TERRAIN_WaterColorA4567", getColorVector(TERRAIN_WaterColor, 4, 7, 3));
|
|
SetShaderParam("TERRAIN_WaterEmission4567", getVector(TERRAIN_WaterEmission, 4, 7));
|
|
SetShaderParam("_GlitterStrength4567", getVector(_GlitterStrength, 4, 7));
|
|
SetShaderParam("RTP_AO_4567", getVector(AO_strength, 4, 7));
|
|
SetShaderParam("_VerticalTexture4567", getVector(VerticalTextureStrength, 4, 7));
|
|
SetShaderParam("_FarSpecCorrection89AB", getVector(FarSpecCorrection, 8, 11));
|
|
SetShaderParam("_MIPmult89AB", getVector(MIPmult, 8, 11));
|
|
SetShaderParam("_MixScale89AB", getVector(MixScale, 8, 11));
|
|
SetShaderParam("_MixBlend89AB", getVector(MixBlend, 8, 11));
|
|
SetShaderParam("_MixSaturation89AB", getVector(MixSaturation, 8, 11));
|
|
SetShaderParam("RTP_DiffFresnel89AB", getVector(RTP_DiffFresnel, 8, 11));
|
|
SetShaderParam("RTP_metallic89AB", getVector(RTP_metallic, 8, 11));
|
|
SetShaderParam("RTP_glossMin89AB", getVector(RTP_glossMin, 8, 11));
|
|
SetShaderParam("RTP_glossMax89AB", getVector(RTP_glossMax, 8, 11));
|
|
SetShaderParam("RTP_glitter89AB", getVector(RTP_glitter, 8, 11));
|
|
SetShaderParam("_MixBrightness89AB", getVector(MixBrightness, 8, 11));
|
|
SetShaderParam("_MixReplace89AB", getVector(MixReplace, 8, 11));
|
|
SetShaderParam("_LayerBrightness89AB", MasterLayerBrightness * getVector(LayerBrightness, 8, 11));
|
|
SetShaderParam("_LayerSaturation89AB", MasterLayerSaturation * getVector(LayerSaturation, 8, 11));
|
|
SetShaderParam("_LayerEmission89AB", getVector(LayerEmission, 8, 11));
|
|
SetShaderParam("_LayerEmissionColorR89AB", getColorVector(LayerEmissionColor, 8, 11, 0));
|
|
SetShaderParam("_LayerEmissionColorG89AB", getColorVector(LayerEmissionColor, 8, 11, 1));
|
|
SetShaderParam("_LayerEmissionColorB89AB", getColorVector(LayerEmissionColor, 8, 11, 2));
|
|
SetShaderParam("_LayerEmissionColorA89AB", getColorVector(LayerEmissionColor, 8, 11, 3));
|
|
SetShaderParam("_LayerBrightness2Spec89AB", getVector(LayerBrightness2Spec, 8, 11));
|
|
SetShaderParam("_LayerAlbedo2SpecColor89AB", getVector(LayerAlbedo2SpecColor, 8, 11));
|
|
SetShaderParam("_LayerEmissionRefractStrength89AB", getVector(LayerEmissionRefractStrength, 8, 11));
|
|
SetShaderParam("_LayerEmissionRefractHBedge89AB", getVector(LayerEmissionRefractHBedge, 8, 11));
|
|
SetShaderParam("_GlobalColorPerLayer89AB", getVector(GlobalColorPerLayer, 8, 11));
|
|
SetShaderParam("_GlobalColorBottom89AB", getVector(GlobalColorBottom, 8, 11));
|
|
SetShaderParam("_GlobalColorTop89AB", getVector(GlobalColorTop, 8, 11));
|
|
SetShaderParam("_GlobalColorColormapLoSat89AB", getVector(GlobalColorColormapLoSat, 8, 11));
|
|
SetShaderParam("_GlobalColorColormapHiSat89AB", getVector(GlobalColorColormapHiSat, 8, 11));
|
|
SetShaderParam("_GlobalColorLayerLoSat89AB", getVector(GlobalColorLayerLoSat, 8, 11));
|
|
SetShaderParam("_GlobalColorLayerHiSat89AB", getVector(GlobalColorLayerHiSat, 8, 11));
|
|
SetShaderParam("_GlobalColorLoBlend89AB", getVector(GlobalColorLoBlend, 8, 11));
|
|
SetShaderParam("_GlobalColorHiBlend89AB", getVector(GlobalColorHiBlend, 8, 11));
|
|
SetShaderParam("PER_LAYER_HEIGHT_MODIFIER89AB", getVector(PER_LAYER_HEIGHT_MODIFIER, 8, 11));
|
|
SetShaderParam("rtp_snow_strength_per_layer89AB", getVector(_snow_strength_per_layer, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultA89AB", getVector(_SuperDetailStrengthMultA, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultB89AB", getVector(_SuperDetailStrengthMultB, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthNormal89AB", getVector(_SuperDetailStrengthNormal, 8, 11));
|
|
SetShaderParam("_BumpMapGlobalStrength89AB", getVector(_BumpMapGlobalStrength, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskNear89AB", getVector(_SuperDetailStrengthMultASelfMaskNear, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultASelfMaskFar89AB", getVector(_SuperDetailStrengthMultASelfMaskFar, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskNear89AB", getVector(_SuperDetailStrengthMultBSelfMaskNear, 8, 11));
|
|
SetShaderParam("_SuperDetailStrengthMultBSelfMaskFar89AB", getVector(_SuperDetailStrengthMultBSelfMaskFar, 8, 11));
|
|
SetShaderParam("TERRAIN_LayerWetStrength89AB", getVector(TERRAIN_LayerWetStrength, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterLevel89AB", getVector(TERRAIN_WaterLevel, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterLevelSlopeDamp89AB", getVector(TERRAIN_WaterLevelSlopeDamp, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterEdge89AB", getVector(TERRAIN_WaterEdge, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterGloss89AB", getVector(TERRAIN_WaterGloss, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterGlossDamper89AB", getVector(TERRAIN_WaterGlossDamper, 8, 11));
|
|
SetShaderParam("TERRAIN_Refraction89AB", getVector(TERRAIN_Refraction, 8, 11));
|
|
SetShaderParam("TERRAIN_WetRefraction89AB", getVector(TERRAIN_WetRefraction, 8, 11));
|
|
SetShaderParam("TERRAIN_Flow89AB", getVector(TERRAIN_Flow, 8, 11));
|
|
SetShaderParam("TERRAIN_WetFlow89AB", getVector(TERRAIN_WetFlow, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterMetallic89AB", getVector(TERRAIN_WaterMetallic, 8, 11));
|
|
SetShaderParam("TERRAIN_WetGloss89AB", getVector(TERRAIN_WetGloss, 8, 11));
|
|
SetShaderParam("TERRAIN_WaterColorR89AB", getColorVector(TERRAIN_WaterColor, 8, 11, 0));
|
|
SetShaderParam("TERRAIN_WaterColorG89AB", getColorVector(TERRAIN_WaterColor, 8, 11, 1));
|
|
SetShaderParam("TERRAIN_WaterColorB89AB", getColorVector(TERRAIN_WaterColor, 8, 11, 2));
|
|
SetShaderParam("TERRAIN_WaterColorA89AB", getColorVector(TERRAIN_WaterColor, 8, 11, 3));
|
|
SetShaderParam("TERRAIN_WaterEmission89AB", getVector(TERRAIN_WaterEmission, 8, 11));
|
|
SetShaderParam("_GlitterStrength89AB", getVector(_GlitterStrength, 8, 11));
|
|
SetShaderParam("RTP_AO_89AB", getVector(AO_strength, 8, 11));
|
|
SetShaderParam("_VerticalTexture89AB", getVector(VerticalTextureStrength, 8, 11));
|
|
}
|
|
if (splat_atlases.Length == 2)
|
|
{
|
|
Texture2D texture2D = splat_atlases[0];
|
|
Texture2D texture2D2 = splat_atlases[1];
|
|
splat_atlases = new Texture2D[3];
|
|
splat_atlases[0] = texture2D;
|
|
splat_atlases[1] = texture2D2;
|
|
}
|
|
SetShaderParam("_SplatAtlasA", splat_atlases[0]);
|
|
SetShaderParam("_BumpMap01", Bump01);
|
|
SetShaderParam("_BumpMap23", Bump23);
|
|
SetShaderParam("_TERRAIN_HeightMap", HeightMap);
|
|
SetShaderParam("_SSColorCombinedA", SSColorCombinedA);
|
|
if (numLayers > 4)
|
|
{
|
|
SetShaderParam("_SplatAtlasB", splat_atlases[1]);
|
|
SetShaderParam("_SplatAtlasC", splat_atlases[1]);
|
|
SetShaderParam("_TERRAIN_HeightMap2", HeightMap2);
|
|
SetShaderParam("_SSColorCombinedB", SSColorCombinedB);
|
|
}
|
|
if (numLayers > 8)
|
|
{
|
|
SetShaderParam("_SplatAtlasC", splat_atlases[2]);
|
|
}
|
|
if (numLayers > 4 && _4LAYERS_SHADER_USED)
|
|
{
|
|
SetShaderParam("_BumpMap89", Bump45);
|
|
SetShaderParam("_BumpMapAB", Bump67);
|
|
SetShaderParam("_TERRAIN_HeightMap3", HeightMap2);
|
|
SetShaderParam("_BumpMap45", Bump45);
|
|
SetShaderParam("_BumpMap67", Bump67);
|
|
}
|
|
else
|
|
{
|
|
SetShaderParam("_BumpMap45", Bump45);
|
|
SetShaderParam("_BumpMap67", Bump67);
|
|
SetShaderParam("_BumpMap89", Bump89);
|
|
SetShaderParam("_BumpMapAB", BumpAB);
|
|
SetShaderParam("_TERRAIN_HeightMap3", HeightMap3);
|
|
}
|
|
use_mat = null;
|
|
}
|
|
|
|
public Vector4 getVector(float[] vec, int idxA, int idxB)
|
|
{
|
|
if (vec == null)
|
|
{
|
|
return Vector4.zero;
|
|
}
|
|
Vector4 zero = Vector4.zero;
|
|
for (int i = idxA; i <= idxB; i++)
|
|
{
|
|
if (i < vec.Length)
|
|
{
|
|
zero[i - idxA] = vec[i];
|
|
}
|
|
}
|
|
return zero;
|
|
}
|
|
|
|
public Vector4 getColorVector(Color[] vec, int idxA, int idxB, int channel)
|
|
{
|
|
if (vec == null)
|
|
{
|
|
return Vector4.zero;
|
|
}
|
|
Vector4 zero = Vector4.zero;
|
|
for (int i = idxA; i <= idxB; i++)
|
|
{
|
|
if (i < vec.Length)
|
|
{
|
|
zero[i - idxA] = vec[i][channel];
|
|
}
|
|
}
|
|
return zero;
|
|
}
|
|
|
|
public Texture2D get_dumb_tex()
|
|
{
|
|
if (!dumb_tex)
|
|
{
|
|
dumb_tex = new Texture2D(32, 32, TextureFormat.RGB24, false);
|
|
Color[] pixels = dumb_tex.GetPixels();
|
|
for (int i = 0; i < pixels.Length; i++)
|
|
{
|
|
pixels[i] = Color.white;
|
|
}
|
|
dumb_tex.SetPixels(pixels);
|
|
dumb_tex.Apply();
|
|
}
|
|
return dumb_tex;
|
|
}
|
|
|
|
public void SyncGlobalPropsAcrossTerrainGroups()
|
|
{
|
|
ReliefTerrain[] array = (ReliefTerrain[])UnityEngine.Object.FindObjectsOfType(typeof(ReliefTerrain));
|
|
ReliefTerrainGlobalSettingsHolder[] array2 = new ReliefTerrainGlobalSettingsHolder[array.Length];
|
|
int num = 0;
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
bool flag = false;
|
|
for (int j = 0; j < num; j++)
|
|
{
|
|
if (array2[j] == array[i].globalSettingsHolder)
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!flag)
|
|
{
|
|
array2[num++] = array[i].globalSettingsHolder;
|
|
}
|
|
}
|
|
for (int k = 0; k < num; k++)
|
|
{
|
|
if (array2[k] != this)
|
|
{
|
|
array2[k].trees_shadow_distance_start = trees_shadow_distance_start;
|
|
array2[k].trees_shadow_distance_transition = trees_shadow_distance_transition;
|
|
array2[k].trees_shadow_value = trees_shadow_value;
|
|
array2[k].global_normalMap_multiplier = global_normalMap_multiplier;
|
|
array2[k].trees_pixel_distance_start = trees_pixel_distance_start;
|
|
array2[k].trees_pixel_distance_transition = trees_pixel_distance_transition;
|
|
array2[k].trees_pixel_blend_val = trees_pixel_blend_val;
|
|
array2[k].global_normalMap_farUsage = global_normalMap_farUsage;
|
|
array2[k]._AmbientEmissiveMultiplier = _AmbientEmissiveMultiplier;
|
|
array2[k]._AmbientEmissiveRelief = _AmbientEmissiveRelief;
|
|
array2[k]._snow_strength = _snow_strength;
|
|
array2[k]._global_color_brightness_to_snow = _global_color_brightness_to_snow;
|
|
array2[k]._snow_slope_factor = _snow_slope_factor;
|
|
array2[k]._snow_edge_definition = _snow_edge_definition;
|
|
array2[k]._snow_height_treshold = _snow_height_treshold;
|
|
array2[k]._snow_height_transition = _snow_height_transition;
|
|
array2[k]._snow_color = _snow_color;
|
|
array2[k]._snow_gloss = _snow_gloss;
|
|
array2[k]._snow_reflectivness = _snow_reflectivness;
|
|
array2[k]._snow_deep_factor = _snow_deep_factor;
|
|
array2[k]._snow_diff_fresnel = _snow_diff_fresnel;
|
|
array2[k]._snow_metallic = _snow_metallic;
|
|
array2[k]._snow_Frost = _snow_Frost;
|
|
array2[k]._snow_MicroTiling = _snow_MicroTiling;
|
|
array2[k]._snow_BumpMicro = _snow_BumpMicro;
|
|
array2[k]._snow_occlusionStrength = _snow_occlusionStrength;
|
|
array2[k]._snow_TranslucencyDeferredLightIndex = _snow_TranslucencyDeferredLightIndex;
|
|
array2[k]._SnowGlitterColor = _SnowGlitterColor;
|
|
array2[k]._GlitterColor = _GlitterColor;
|
|
array2[k]._GlitterTiling = _GlitterTiling;
|
|
array2[k]._GlitterDensity = _GlitterDensity;
|
|
array2[k]._GlitterFilter = _GlitterFilter;
|
|
array2[k]._GlitterColorization = _GlitterColorization;
|
|
array2[k]._SparkleMap = _SparkleMap;
|
|
array2[k].TERRAIN_CausticsWaterLevel = TERRAIN_CausticsWaterLevel;
|
|
array2[k].TERRAIN_CausticsWaterLevelByAngle = TERRAIN_CausticsWaterLevelByAngle;
|
|
array2[k].TERRAIN_CausticsWaterDeepFadeLength = TERRAIN_CausticsWaterDeepFadeLength;
|
|
array2[k].TERRAIN_CausticsWaterShallowFadeLength = TERRAIN_CausticsWaterShallowFadeLength;
|
|
array2[k].TERRAIN_GlobalWetness = TERRAIN_GlobalWetness;
|
|
array2[k].TERRAIN_RainIntensity = TERRAIN_RainIntensity;
|
|
array2[k].RTP_LightDefVector = RTP_LightDefVector;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void RestorePreset(ReliefTerrainPresetHolder holder)
|
|
{
|
|
numLayers = holder.numLayers;
|
|
splats = new Texture2D[holder.splats.Length];
|
|
for (int i = 0; i < holder.splats.Length; i++)
|
|
{
|
|
splats[i] = holder.splats[i];
|
|
}
|
|
splat_atlases = new Texture2D[3];
|
|
for (int j = 0; j < splat_atlases.Length; j++)
|
|
{
|
|
splat_atlases[j] = holder.splat_atlases[j];
|
|
}
|
|
RTP_MIP_BIAS = holder.RTP_MIP_BIAS;
|
|
MasterLayerBrightness = holder.MasterLayerBrightness;
|
|
MasterLayerSaturation = holder.MasterLayerSaturation;
|
|
SuperDetailA_channel = holder.SuperDetailA_channel;
|
|
SuperDetailB_channel = holder.SuperDetailB_channel;
|
|
Bump01 = holder.Bump01;
|
|
Bump23 = holder.Bump23;
|
|
Bump45 = holder.Bump45;
|
|
Bump67 = holder.Bump67;
|
|
Bump89 = holder.Bump89;
|
|
BumpAB = holder.BumpAB;
|
|
SSColorCombinedA = holder.SSColorCombinedA;
|
|
SSColorCombinedB = holder.SSColorCombinedB;
|
|
BumpGlobal = holder.BumpGlobal;
|
|
VerticalTexture = holder.VerticalTexture;
|
|
BumpMapGlobalScale = holder.BumpMapGlobalScale;
|
|
GlobalColorMapBlendValues = holder.GlobalColorMapBlendValues;
|
|
GlobalColorMapSaturation = holder.GlobalColorMapSaturation;
|
|
GlobalColorMapSaturationFar = holder.GlobalColorMapSaturationFar;
|
|
GlobalColorMapDistortByPerlin = holder.GlobalColorMapDistortByPerlin;
|
|
GlobalColorMapBrightness = holder.GlobalColorMapBrightness;
|
|
GlobalColorMapBrightnessFar = holder.GlobalColorMapBrightnessFar;
|
|
_GlobalColorMapNearMIP = holder._GlobalColorMapNearMIP;
|
|
_FarNormalDamp = holder._FarNormalDamp;
|
|
blendMultiplier = holder.blendMultiplier;
|
|
HeightMap = holder.HeightMap;
|
|
HeightMap2 = holder.HeightMap2;
|
|
HeightMap3 = holder.HeightMap3;
|
|
ReliefTransform = holder.ReliefTransform;
|
|
DIST_STEPS = holder.DIST_STEPS;
|
|
WAVELENGTH = holder.WAVELENGTH;
|
|
ReliefBorderBlend = holder.ReliefBorderBlend;
|
|
ExtrudeHeight = holder.ExtrudeHeight;
|
|
LightmapShading = holder.LightmapShading;
|
|
SHADOW_STEPS = holder.SHADOW_STEPS;
|
|
WAVELENGTH_SHADOWS = holder.WAVELENGTH_SHADOWS;
|
|
SelfShadowStrength = holder.SelfShadowStrength;
|
|
ShadowSmoothing = holder.ShadowSmoothing;
|
|
ShadowSoftnessFade = holder.ShadowSoftnessFade;
|
|
distance_start = holder.distance_start;
|
|
distance_transition = holder.distance_transition;
|
|
distance_start_bumpglobal = holder.distance_start_bumpglobal;
|
|
distance_transition_bumpglobal = holder.distance_transition_bumpglobal;
|
|
rtp_perlin_start_val = holder.rtp_perlin_start_val;
|
|
_Phong = holder._Phong;
|
|
tessHeight = holder.tessHeight;
|
|
_TessSubdivisions = holder._TessSubdivisions;
|
|
_TessSubdivisionsFar = holder._TessSubdivisionsFar;
|
|
_TessYOffset = holder._TessYOffset;
|
|
trees_shadow_distance_start = holder.trees_shadow_distance_start;
|
|
trees_shadow_distance_transition = holder.trees_shadow_distance_transition;
|
|
trees_shadow_value = holder.trees_shadow_value;
|
|
trees_pixel_distance_start = holder.trees_pixel_distance_start;
|
|
trees_pixel_distance_transition = holder.trees_pixel_distance_transition;
|
|
trees_pixel_blend_val = holder.trees_pixel_blend_val;
|
|
global_normalMap_multiplier = holder.global_normalMap_multiplier;
|
|
global_normalMap_farUsage = holder.global_normalMap_farUsage;
|
|
_AmbientEmissiveMultiplier = holder._AmbientEmissiveMultiplier;
|
|
_AmbientEmissiveRelief = holder._AmbientEmissiveRelief;
|
|
rtp_mipoffset_globalnorm = holder.rtp_mipoffset_globalnorm;
|
|
_SuperDetailTiling = holder._SuperDetailTiling;
|
|
SuperDetailA = holder.SuperDetailA;
|
|
SuperDetailB = holder.SuperDetailB;
|
|
TERRAIN_GlobalWetness = holder.TERRAIN_GlobalWetness;
|
|
TERRAIN_RippleMap = holder.TERRAIN_RippleMap;
|
|
TERRAIN_RippleScale = holder.TERRAIN_RippleScale;
|
|
TERRAIN_FlowScale = holder.TERRAIN_FlowScale;
|
|
TERRAIN_FlowSpeed = holder.TERRAIN_FlowSpeed;
|
|
TERRAIN_FlowCycleScale = holder.TERRAIN_FlowCycleScale;
|
|
TERRAIN_FlowMipOffset = holder.TERRAIN_FlowMipOffset;
|
|
TERRAIN_WetDarkening = holder.TERRAIN_WetDarkening;
|
|
TERRAIN_WetDropletsStrength = holder.TERRAIN_WetDropletsStrength;
|
|
TERRAIN_WetHeight_Treshold = holder.TERRAIN_WetHeight_Treshold;
|
|
TERRAIN_WetHeight_Transition = holder.TERRAIN_WetHeight_Transition;
|
|
TERRAIN_RainIntensity = holder.TERRAIN_RainIntensity;
|
|
TERRAIN_DropletsSpeed = holder.TERRAIN_DropletsSpeed;
|
|
TERRAIN_mipoffset_flowSpeed = holder.TERRAIN_mipoffset_flowSpeed;
|
|
TERRAIN_CausticsAnimSpeed = holder.TERRAIN_CausticsAnimSpeed;
|
|
TERRAIN_CausticsColor = holder.TERRAIN_CausticsColor;
|
|
TERRAIN_CausticsWaterLevel = holder.TERRAIN_CausticsWaterLevel;
|
|
TERRAIN_CausticsWaterLevelByAngle = holder.TERRAIN_CausticsWaterLevelByAngle;
|
|
TERRAIN_CausticsWaterDeepFadeLength = holder.TERRAIN_CausticsWaterDeepFadeLength;
|
|
TERRAIN_CausticsWaterShallowFadeLength = holder.TERRAIN_CausticsWaterShallowFadeLength;
|
|
TERRAIN_CausticsTilingScale = holder.TERRAIN_CausticsTilingScale;
|
|
TERRAIN_CausticsTex = holder.TERRAIN_CausticsTex;
|
|
RTP_AOsharpness = holder.RTP_AOsharpness;
|
|
RTP_AOamp = holder.RTP_AOamp;
|
|
_occlusionStrength = holder._occlusionStrength;
|
|
RTP_LightDefVector = holder.RTP_LightDefVector;
|
|
EmissionRefractFiltering = holder.EmissionRefractFiltering;
|
|
EmissionRefractAnimSpeed = holder.EmissionRefractAnimSpeed;
|
|
VerticalTextureGlobalBumpInfluence = holder.VerticalTextureGlobalBumpInfluence;
|
|
VerticalTextureTiling = holder.VerticalTextureTiling;
|
|
_snow_strength = holder._snow_strength;
|
|
_global_color_brightness_to_snow = holder._global_color_brightness_to_snow;
|
|
_snow_slope_factor = holder._snow_slope_factor;
|
|
_snow_edge_definition = holder._snow_edge_definition;
|
|
_snow_height_treshold = holder._snow_height_treshold;
|
|
_snow_height_transition = holder._snow_height_transition;
|
|
_snow_color = holder._snow_color;
|
|
_snow_gloss = holder._snow_gloss;
|
|
_snow_reflectivness = holder._snow_reflectivness;
|
|
_snow_deep_factor = holder._snow_deep_factor;
|
|
_snow_diff_fresnel = holder._snow_diff_fresnel;
|
|
_snow_metallic = holder._snow_metallic;
|
|
_snow_Frost = holder._snow_Frost;
|
|
_snow_MicroTiling = holder._snow_MicroTiling;
|
|
_snow_BumpMicro = holder._snow_BumpMicro;
|
|
_snow_occlusionStrength = holder._snow_occlusionStrength;
|
|
_snow_TranslucencyDeferredLightIndex = holder._snow_TranslucencyDeferredLightIndex;
|
|
_SnowGlitterColor = holder._SnowGlitterColor;
|
|
_GlitterColor = holder._GlitterColor;
|
|
_GlitterTiling = holder._GlitterTiling;
|
|
_GlitterDensity = holder._GlitterDensity;
|
|
_GlitterFilter = holder._GlitterFilter;
|
|
_GlitterColorization = holder._GlitterColorization;
|
|
_SparkleMap = holder._SparkleMap;
|
|
Bumps = new Texture2D[holder.Bumps.Length];
|
|
FarSpecCorrection = new float[holder.Bumps.Length];
|
|
MixScale = new float[holder.Bumps.Length];
|
|
MixBlend = new float[holder.Bumps.Length];
|
|
MixSaturation = new float[holder.Bumps.Length];
|
|
RTP_DiffFresnel = new float[holder.Bumps.Length];
|
|
RTP_metallic = new float[holder.Bumps.Length];
|
|
RTP_glossMin = new float[holder.Bumps.Length];
|
|
RTP_glossMax = new float[holder.Bumps.Length];
|
|
RTP_glitter = new float[holder.Bumps.Length];
|
|
MixBrightness = new float[holder.Bumps.Length];
|
|
MixReplace = new float[holder.Bumps.Length];
|
|
LayerBrightness = new float[holder.Bumps.Length];
|
|
LayerBrightness2Spec = new float[holder.Bumps.Length];
|
|
LayerAlbedo2SpecColor = new float[holder.Bumps.Length];
|
|
LayerSaturation = new float[holder.Bumps.Length];
|
|
LayerEmission = new float[holder.Bumps.Length];
|
|
LayerEmissionColor = new Color[holder.Bumps.Length];
|
|
LayerEmissionRefractStrength = new float[holder.Bumps.Length];
|
|
LayerEmissionRefractHBedge = new float[holder.Bumps.Length];
|
|
GlobalColorPerLayer = new float[holder.Bumps.Length];
|
|
GlobalColorBottom = new float[holder.Bumps.Length];
|
|
GlobalColorTop = new float[holder.Bumps.Length];
|
|
GlobalColorColormapLoSat = new float[holder.Bumps.Length];
|
|
GlobalColorColormapHiSat = new float[holder.Bumps.Length];
|
|
GlobalColorLayerLoSat = new float[holder.Bumps.Length];
|
|
GlobalColorLayerHiSat = new float[holder.Bumps.Length];
|
|
GlobalColorLoBlend = new float[holder.Bumps.Length];
|
|
GlobalColorHiBlend = new float[holder.Bumps.Length];
|
|
PER_LAYER_HEIGHT_MODIFIER = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultA = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultASelfMaskNear = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultASelfMaskFar = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultB = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultBSelfMaskNear = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthMultBSelfMaskFar = new float[holder.Bumps.Length];
|
|
_SuperDetailStrengthNormal = new float[holder.Bumps.Length];
|
|
_BumpMapGlobalStrength = new float[holder.Bumps.Length];
|
|
AO_strength = new float[holder.Bumps.Length];
|
|
VerticalTextureStrength = new float[holder.Bumps.Length];
|
|
Heights = new Texture2D[holder.Bumps.Length];
|
|
_snow_strength_per_layer = new float[holder.Bumps.Length];
|
|
Substances = new ProceduralMaterial[holder.Bumps.Length];
|
|
TERRAIN_LayerWetStrength = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterLevel = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterLevelSlopeDamp = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterEdge = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterGloss = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterGlossDamper = new float[holder.Bumps.Length];
|
|
TERRAIN_Refraction = new float[holder.Bumps.Length];
|
|
TERRAIN_WetRefraction = new float[holder.Bumps.Length];
|
|
TERRAIN_Flow = new float[holder.Bumps.Length];
|
|
TERRAIN_WetFlow = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterMetallic = new float[holder.Bumps.Length];
|
|
TERRAIN_WetGloss = new float[holder.Bumps.Length];
|
|
TERRAIN_WaterColor = new Color[holder.Bumps.Length];
|
|
TERRAIN_WaterEmission = new float[holder.Bumps.Length];
|
|
_GlitterStrength = new float[holder.Bumps.Length];
|
|
for (int k = 0; k < holder.Bumps.Length; k++)
|
|
{
|
|
Bumps[k] = holder.Bumps[k];
|
|
FarSpecCorrection[k] = holder.FarSpecCorrection[k];
|
|
MixScale[k] = holder.MixScale[k];
|
|
MixBlend[k] = holder.MixBlend[k];
|
|
MixSaturation[k] = holder.MixSaturation[k];
|
|
CheckAndUpdate(ref holder.RTP_DiffFresnel, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.RTP_metallic, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.RTP_glossMin, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.RTP_glossMax, 1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.RTP_glitter, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WaterGloss, 0.1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WaterGlossDamper, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WaterMetallic, 0.1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WetGloss, 0.05f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WetFlow, 0.05f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.MixBrightness, 2f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.MixReplace, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerBrightness, 1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerBrightness2Spec, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerAlbedo2SpecColor, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerSaturation, 1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerEmission, 1f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerEmissionColor, Color.black, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.FarSpecCorrection, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerEmissionRefractStrength, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.LayerEmissionRefractHBedge, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder.TERRAIN_WaterEmission, 0f, holder.Bumps.Length);
|
|
CheckAndUpdate(ref holder._GlitterStrength, 0f, holder.Bumps.Length);
|
|
RTP_DiffFresnel[k] = holder.RTP_DiffFresnel[k];
|
|
RTP_metallic[k] = holder.RTP_metallic[k];
|
|
RTP_glossMin[k] = holder.RTP_glossMin[k];
|
|
RTP_glossMax[k] = holder.RTP_glossMax[k];
|
|
RTP_glitter[k] = holder.RTP_glitter[k];
|
|
MixBrightness[k] = holder.MixBrightness[k];
|
|
MixReplace[k] = holder.MixReplace[k];
|
|
LayerBrightness[k] = holder.LayerBrightness[k];
|
|
LayerBrightness2Spec[k] = holder.LayerBrightness2Spec[k];
|
|
LayerAlbedo2SpecColor[k] = holder.LayerAlbedo2SpecColor[k];
|
|
LayerSaturation[k] = holder.LayerSaturation[k];
|
|
LayerEmission[k] = holder.LayerEmission[k];
|
|
LayerEmissionColor[k] = holder.LayerEmissionColor[k];
|
|
LayerEmissionRefractStrength[k] = holder.LayerEmissionRefractStrength[k];
|
|
LayerEmissionRefractHBedge[k] = holder.LayerEmissionRefractHBedge[k];
|
|
GlobalColorPerLayer[k] = holder.GlobalColorPerLayer[k];
|
|
GlobalColorBottom[k] = holder.GlobalColorBottom[k];
|
|
GlobalColorTop[k] = holder.GlobalColorTop[k];
|
|
GlobalColorColormapLoSat[k] = holder.GlobalColorColormapLoSat[k];
|
|
GlobalColorColormapHiSat[k] = holder.GlobalColorColormapHiSat[k];
|
|
GlobalColorLayerLoSat[k] = holder.GlobalColorLayerLoSat[k];
|
|
GlobalColorLayerHiSat[k] = holder.GlobalColorLayerHiSat[k];
|
|
GlobalColorLoBlend[k] = holder.GlobalColorLoBlend[k];
|
|
GlobalColorHiBlend[k] = holder.GlobalColorHiBlend[k];
|
|
PER_LAYER_HEIGHT_MODIFIER[k] = holder.PER_LAYER_HEIGHT_MODIFIER[k];
|
|
_SuperDetailStrengthMultA[k] = holder._SuperDetailStrengthMultA[k];
|
|
_SuperDetailStrengthMultASelfMaskNear[k] = holder._SuperDetailStrengthMultASelfMaskNear[k];
|
|
_SuperDetailStrengthMultASelfMaskFar[k] = holder._SuperDetailStrengthMultASelfMaskFar[k];
|
|
_SuperDetailStrengthMultB[k] = holder._SuperDetailStrengthMultB[k];
|
|
_SuperDetailStrengthMultBSelfMaskNear[k] = holder._SuperDetailStrengthMultBSelfMaskNear[k];
|
|
_SuperDetailStrengthMultBSelfMaskFar[k] = holder._SuperDetailStrengthMultBSelfMaskFar[k];
|
|
_SuperDetailStrengthNormal[k] = holder._SuperDetailStrengthNormal[k];
|
|
_BumpMapGlobalStrength[k] = holder._BumpMapGlobalStrength[k];
|
|
VerticalTextureStrength[k] = holder.VerticalTextureStrength[k];
|
|
AO_strength[k] = holder.AO_strength[k];
|
|
Heights[k] = holder.Heights[k];
|
|
_snow_strength_per_layer[k] = holder._snow_strength_per_layer[k];
|
|
Substances[k] = holder.Substances[k];
|
|
TERRAIN_LayerWetStrength[k] = holder.TERRAIN_LayerWetStrength[k];
|
|
TERRAIN_WaterLevel[k] = holder.TERRAIN_WaterLevel[k];
|
|
TERRAIN_WaterLevelSlopeDamp[k] = holder.TERRAIN_WaterLevelSlopeDamp[k];
|
|
TERRAIN_WaterEdge[k] = holder.TERRAIN_WaterEdge[k];
|
|
TERRAIN_WaterGloss[k] = holder.TERRAIN_WaterGloss[k];
|
|
TERRAIN_WaterGlossDamper[k] = holder.TERRAIN_WaterGlossDamper[k];
|
|
TERRAIN_Refraction[k] = holder.TERRAIN_Refraction[k];
|
|
TERRAIN_WetRefraction[k] = holder.TERRAIN_WetRefraction[k];
|
|
TERRAIN_Flow[k] = holder.TERRAIN_Flow[k];
|
|
TERRAIN_WetFlow[k] = holder.TERRAIN_WetFlow[k];
|
|
TERRAIN_WaterMetallic[k] = holder.TERRAIN_WaterMetallic[k];
|
|
TERRAIN_WetGloss[k] = holder.TERRAIN_WetGloss[k];
|
|
TERRAIN_WaterColor[k] = holder.TERRAIN_WaterColor[k];
|
|
TERRAIN_WaterEmission[k] = holder.TERRAIN_WaterEmission[k];
|
|
_GlitterStrength[k] = holder._GlitterStrength[k];
|
|
}
|
|
}
|
|
|
|
public void GlossBakeJob(Texture2D detailTex, Texture2D normalTex)
|
|
{
|
|
bakeJobArray = new Texture2D[2] { detailTex, normalTex };
|
|
}
|
|
|
|
public void SavePreset(ref ReliefTerrainPresetHolder holder)
|
|
{
|
|
holder.numLayers = numLayers;
|
|
holder.splats = new Texture2D[splats.Length];
|
|
for (int i = 0; i < holder.splats.Length; i++)
|
|
{
|
|
holder.splats[i] = splats[i];
|
|
}
|
|
holder.splat_atlases = new Texture2D[3];
|
|
for (int j = 0; j < splat_atlases.Length; j++)
|
|
{
|
|
holder.splat_atlases[j] = splat_atlases[j];
|
|
}
|
|
holder.RTP_MIP_BIAS = RTP_MIP_BIAS;
|
|
holder.MasterLayerBrightness = MasterLayerBrightness;
|
|
holder.MasterLayerSaturation = MasterLayerSaturation;
|
|
holder.SuperDetailA_channel = SuperDetailA_channel;
|
|
holder.SuperDetailB_channel = SuperDetailB_channel;
|
|
holder.Bump01 = Bump01;
|
|
holder.Bump23 = Bump23;
|
|
holder.Bump45 = Bump45;
|
|
holder.Bump67 = Bump67;
|
|
holder.Bump89 = Bump89;
|
|
holder.BumpAB = BumpAB;
|
|
holder.SSColorCombinedA = SSColorCombinedA;
|
|
holder.SSColorCombinedB = SSColorCombinedB;
|
|
holder.BumpGlobal = BumpGlobal;
|
|
holder.VerticalTexture = VerticalTexture;
|
|
holder.BumpMapGlobalScale = BumpMapGlobalScale;
|
|
holder.GlobalColorMapBlendValues = GlobalColorMapBlendValues;
|
|
holder.GlobalColorMapSaturation = GlobalColorMapSaturation;
|
|
holder.GlobalColorMapSaturationFar = GlobalColorMapSaturationFar;
|
|
holder.GlobalColorMapDistortByPerlin = GlobalColorMapDistortByPerlin;
|
|
holder.GlobalColorMapBrightness = GlobalColorMapBrightness;
|
|
holder.GlobalColorMapBrightnessFar = GlobalColorMapBrightnessFar;
|
|
holder._GlobalColorMapNearMIP = _GlobalColorMapNearMIP;
|
|
holder._FarNormalDamp = _FarNormalDamp;
|
|
holder.blendMultiplier = blendMultiplier;
|
|
holder.HeightMap = HeightMap;
|
|
holder.HeightMap2 = HeightMap2;
|
|
holder.HeightMap3 = HeightMap3;
|
|
holder.ReliefTransform = ReliefTransform;
|
|
holder.DIST_STEPS = DIST_STEPS;
|
|
holder.WAVELENGTH = WAVELENGTH;
|
|
holder.ReliefBorderBlend = ReliefBorderBlend;
|
|
holder.ExtrudeHeight = ExtrudeHeight;
|
|
holder.LightmapShading = LightmapShading;
|
|
holder.SHADOW_STEPS = SHADOW_STEPS;
|
|
holder.WAVELENGTH_SHADOWS = WAVELENGTH_SHADOWS;
|
|
holder.SelfShadowStrength = SelfShadowStrength;
|
|
holder.ShadowSmoothing = ShadowSmoothing;
|
|
holder.ShadowSoftnessFade = ShadowSoftnessFade;
|
|
holder.distance_start = distance_start;
|
|
holder.distance_transition = distance_transition;
|
|
holder.distance_start_bumpglobal = distance_start_bumpglobal;
|
|
holder.distance_transition_bumpglobal = distance_transition_bumpglobal;
|
|
holder.rtp_perlin_start_val = rtp_perlin_start_val;
|
|
holder._Phong = _Phong;
|
|
holder.tessHeight = tessHeight;
|
|
holder._TessSubdivisions = _TessSubdivisions;
|
|
holder._TessSubdivisionsFar = _TessSubdivisionsFar;
|
|
holder._TessYOffset = _TessYOffset;
|
|
holder.trees_shadow_distance_start = trees_shadow_distance_start;
|
|
holder.trees_shadow_distance_transition = trees_shadow_distance_transition;
|
|
holder.trees_shadow_value = trees_shadow_value;
|
|
holder.trees_pixel_distance_start = trees_pixel_distance_start;
|
|
holder.trees_pixel_distance_transition = trees_pixel_distance_transition;
|
|
holder.trees_pixel_blend_val = trees_pixel_blend_val;
|
|
holder.global_normalMap_multiplier = global_normalMap_multiplier;
|
|
holder.global_normalMap_farUsage = global_normalMap_farUsage;
|
|
holder._AmbientEmissiveMultiplier = _AmbientEmissiveMultiplier;
|
|
holder._AmbientEmissiveRelief = _AmbientEmissiveRelief;
|
|
holder.rtp_mipoffset_globalnorm = rtp_mipoffset_globalnorm;
|
|
holder._SuperDetailTiling = _SuperDetailTiling;
|
|
holder.SuperDetailA = SuperDetailA;
|
|
holder.SuperDetailB = SuperDetailB;
|
|
holder.TERRAIN_GlobalWetness = TERRAIN_GlobalWetness;
|
|
holder.TERRAIN_RippleMap = TERRAIN_RippleMap;
|
|
holder.TERRAIN_RippleScale = TERRAIN_RippleScale;
|
|
holder.TERRAIN_FlowScale = TERRAIN_FlowScale;
|
|
holder.TERRAIN_FlowSpeed = TERRAIN_FlowSpeed;
|
|
holder.TERRAIN_FlowCycleScale = TERRAIN_FlowCycleScale;
|
|
holder.TERRAIN_FlowMipOffset = TERRAIN_FlowMipOffset;
|
|
holder.TERRAIN_WetDarkening = TERRAIN_WetDarkening;
|
|
holder.TERRAIN_WetDropletsStrength = TERRAIN_WetDropletsStrength;
|
|
holder.TERRAIN_WetHeight_Treshold = TERRAIN_WetHeight_Treshold;
|
|
holder.TERRAIN_WetHeight_Transition = TERRAIN_WetHeight_Transition;
|
|
holder.TERRAIN_RainIntensity = TERRAIN_RainIntensity;
|
|
holder.TERRAIN_DropletsSpeed = TERRAIN_DropletsSpeed;
|
|
holder.TERRAIN_mipoffset_flowSpeed = TERRAIN_mipoffset_flowSpeed;
|
|
holder.TERRAIN_CausticsAnimSpeed = TERRAIN_CausticsAnimSpeed;
|
|
holder.TERRAIN_CausticsColor = TERRAIN_CausticsColor;
|
|
holder.TERRAIN_CausticsWaterLevel = TERRAIN_CausticsWaterLevel;
|
|
holder.TERRAIN_CausticsWaterLevelByAngle = TERRAIN_CausticsWaterLevelByAngle;
|
|
holder.TERRAIN_CausticsWaterDeepFadeLength = TERRAIN_CausticsWaterDeepFadeLength;
|
|
holder.TERRAIN_CausticsWaterShallowFadeLength = TERRAIN_CausticsWaterShallowFadeLength;
|
|
holder.TERRAIN_CausticsTilingScale = TERRAIN_CausticsTilingScale;
|
|
holder.TERRAIN_CausticsTex = TERRAIN_CausticsTex;
|
|
holder.RTP_AOsharpness = RTP_AOsharpness;
|
|
holder.RTP_AOamp = RTP_AOamp;
|
|
holder._occlusionStrength = _occlusionStrength;
|
|
holder.RTP_LightDefVector = RTP_LightDefVector;
|
|
holder.EmissionRefractFiltering = EmissionRefractFiltering;
|
|
holder.EmissionRefractAnimSpeed = EmissionRefractAnimSpeed;
|
|
holder.VerticalTextureGlobalBumpInfluence = VerticalTextureGlobalBumpInfluence;
|
|
holder.VerticalTextureTiling = VerticalTextureTiling;
|
|
holder._snow_strength = _snow_strength;
|
|
holder._global_color_brightness_to_snow = _global_color_brightness_to_snow;
|
|
holder._snow_slope_factor = _snow_slope_factor;
|
|
holder._snow_edge_definition = _snow_edge_definition;
|
|
holder._snow_height_treshold = _snow_height_treshold;
|
|
holder._snow_height_transition = _snow_height_transition;
|
|
holder._snow_color = _snow_color;
|
|
holder._snow_gloss = _snow_gloss;
|
|
holder._snow_reflectivness = _snow_reflectivness;
|
|
holder._snow_deep_factor = _snow_deep_factor;
|
|
holder._snow_diff_fresnel = _snow_diff_fresnel;
|
|
holder._snow_metallic = _snow_metallic;
|
|
holder._snow_Frost = _snow_Frost;
|
|
holder._snow_MicroTiling = _snow_MicroTiling;
|
|
holder._snow_BumpMicro = _snow_BumpMicro;
|
|
holder._snow_occlusionStrength = _snow_occlusionStrength;
|
|
holder._snow_TranslucencyDeferredLightIndex = _snow_TranslucencyDeferredLightIndex;
|
|
holder._SnowGlitterColor = _SnowGlitterColor;
|
|
holder._GlitterColor = _GlitterColor;
|
|
holder._GlitterTiling = _GlitterTiling;
|
|
holder._GlitterDensity = _GlitterDensity;
|
|
holder._GlitterFilter = _GlitterFilter;
|
|
holder._GlitterColorization = _GlitterColorization;
|
|
holder._SparkleMap = _SparkleMap;
|
|
holder.Bumps = new Texture2D[numLayers];
|
|
holder.Spec = new float[numLayers];
|
|
holder.FarSpecCorrection = new float[numLayers];
|
|
holder.MixScale = new float[numLayers];
|
|
holder.MixBlend = new float[numLayers];
|
|
holder.MixSaturation = new float[numLayers];
|
|
holder.RTP_DiffFresnel = new float[numLayers];
|
|
holder.RTP_metallic = new float[numLayers];
|
|
holder.RTP_glossMin = new float[numLayers];
|
|
holder.RTP_glossMax = new float[numLayers];
|
|
holder.RTP_glitter = new float[numLayers];
|
|
holder.MixBrightness = new float[numLayers];
|
|
holder.MixReplace = new float[numLayers];
|
|
holder.LayerBrightness = new float[numLayers];
|
|
holder.LayerBrightness2Spec = new float[numLayers];
|
|
holder.LayerAlbedo2SpecColor = new float[numLayers];
|
|
holder.LayerSaturation = new float[numLayers];
|
|
holder.LayerEmission = new float[numLayers];
|
|
holder.LayerEmissionColor = new Color[numLayers];
|
|
holder.LayerEmissionRefractStrength = new float[numLayers];
|
|
holder.LayerEmissionRefractHBedge = new float[numLayers];
|
|
holder.GlobalColorPerLayer = new float[numLayers];
|
|
holder.GlobalColorBottom = new float[numLayers];
|
|
holder.GlobalColorTop = new float[numLayers];
|
|
holder.GlobalColorColormapLoSat = new float[numLayers];
|
|
holder.GlobalColorColormapHiSat = new float[numLayers];
|
|
holder.GlobalColorLayerLoSat = new float[numLayers];
|
|
holder.GlobalColorLayerHiSat = new float[numLayers];
|
|
holder.GlobalColorLoBlend = new float[numLayers];
|
|
holder.GlobalColorHiBlend = new float[numLayers];
|
|
holder.PER_LAYER_HEIGHT_MODIFIER = new float[numLayers];
|
|
holder._SuperDetailStrengthMultA = new float[numLayers];
|
|
holder._SuperDetailStrengthMultASelfMaskNear = new float[numLayers];
|
|
holder._SuperDetailStrengthMultASelfMaskFar = new float[numLayers];
|
|
holder._SuperDetailStrengthMultB = new float[numLayers];
|
|
holder._SuperDetailStrengthMultBSelfMaskNear = new float[numLayers];
|
|
holder._SuperDetailStrengthMultBSelfMaskFar = new float[numLayers];
|
|
holder._SuperDetailStrengthNormal = new float[numLayers];
|
|
holder._BumpMapGlobalStrength = new float[numLayers];
|
|
holder.VerticalTextureStrength = new float[numLayers];
|
|
holder.AO_strength = new float[numLayers];
|
|
holder.Heights = new Texture2D[numLayers];
|
|
holder._snow_strength_per_layer = new float[numLayers];
|
|
holder.Substances = new ProceduralMaterial[numLayers];
|
|
holder.TERRAIN_LayerWetStrength = new float[numLayers];
|
|
holder.TERRAIN_WaterLevel = new float[numLayers];
|
|
holder.TERRAIN_WaterLevelSlopeDamp = new float[numLayers];
|
|
holder.TERRAIN_WaterEdge = new float[numLayers];
|
|
holder.TERRAIN_WaterGloss = new float[numLayers];
|
|
holder.TERRAIN_WaterGlossDamper = new float[numLayers];
|
|
holder.TERRAIN_Refraction = new float[numLayers];
|
|
holder.TERRAIN_WetRefraction = new float[numLayers];
|
|
holder.TERRAIN_Flow = new float[numLayers];
|
|
holder.TERRAIN_WetFlow = new float[numLayers];
|
|
holder.TERRAIN_WaterMetallic = new float[numLayers];
|
|
holder.TERRAIN_WetGloss = new float[numLayers];
|
|
holder.TERRAIN_WaterColor = new Color[numLayers];
|
|
holder.TERRAIN_WaterEmission = new float[numLayers];
|
|
holder._GlitterStrength = new float[numLayers];
|
|
for (int k = 0; k < numLayers; k++)
|
|
{
|
|
holder.Bumps[k] = Bumps[k];
|
|
holder.FarSpecCorrection[k] = FarSpecCorrection[k];
|
|
holder.MixScale[k] = MixScale[k];
|
|
holder.MixBlend[k] = MixBlend[k];
|
|
holder.MixSaturation[k] = MixSaturation[k];
|
|
CheckAndUpdate(ref RTP_DiffFresnel, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_metallic, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_glossMin, 0f, numLayers);
|
|
CheckAndUpdate(ref RTP_glossMax, 1f, numLayers);
|
|
CheckAndUpdate(ref RTP_glitter, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterGloss, 0.1f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterGlossDamper, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterMetallic, 0.1f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WetGloss, 0.05f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WetFlow, 0.05f, numLayers);
|
|
CheckAndUpdate(ref MixBrightness, 2f, numLayers);
|
|
CheckAndUpdate(ref MixReplace, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerBrightness, 1f, numLayers);
|
|
CheckAndUpdate(ref LayerBrightness2Spec, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerAlbedo2SpecColor, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerSaturation, 1f, numLayers);
|
|
CheckAndUpdate(ref LayerEmission, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionColor, Color.black, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionRefractStrength, 0f, numLayers);
|
|
CheckAndUpdate(ref LayerEmissionRefractHBedge, 0f, numLayers);
|
|
CheckAndUpdate(ref TERRAIN_WaterEmission, 0.5f, numLayers);
|
|
CheckAndUpdate(ref _GlitterStrength, 0f, numLayers);
|
|
holder.RTP_DiffFresnel[k] = RTP_DiffFresnel[k];
|
|
holder.RTP_metallic[k] = RTP_metallic[k];
|
|
holder.RTP_glossMin[k] = RTP_glossMin[k];
|
|
holder.RTP_glossMax[k] = RTP_glossMax[k];
|
|
holder.RTP_glitter[k] = RTP_glitter[k];
|
|
holder.TERRAIN_WaterEmission[k] = TERRAIN_WaterEmission[k];
|
|
holder.MixBrightness[k] = MixBrightness[k];
|
|
holder.MixReplace[k] = MixReplace[k];
|
|
holder.LayerBrightness[k] = LayerBrightness[k];
|
|
holder.LayerBrightness2Spec[k] = LayerBrightness2Spec[k];
|
|
holder.LayerAlbedo2SpecColor[k] = LayerAlbedo2SpecColor[k];
|
|
holder.LayerSaturation[k] = LayerSaturation[k];
|
|
holder.LayerEmission[k] = LayerEmission[k];
|
|
holder.LayerEmissionColor[k] = LayerEmissionColor[k];
|
|
holder.LayerEmissionRefractStrength[k] = LayerEmissionRefractStrength[k];
|
|
holder.LayerEmissionRefractHBedge[k] = LayerEmissionRefractHBedge[k];
|
|
holder.GlobalColorPerLayer[k] = GlobalColorPerLayer[k];
|
|
holder.GlobalColorBottom[k] = GlobalColorBottom[k];
|
|
holder.GlobalColorTop[k] = GlobalColorTop[k];
|
|
holder.GlobalColorColormapLoSat[k] = GlobalColorColormapLoSat[k];
|
|
holder.GlobalColorColormapHiSat[k] = GlobalColorColormapHiSat[k];
|
|
holder.GlobalColorLayerLoSat[k] = GlobalColorLayerLoSat[k];
|
|
holder.GlobalColorLayerHiSat[k] = GlobalColorLayerHiSat[k];
|
|
holder.GlobalColorLoBlend[k] = GlobalColorLoBlend[k];
|
|
holder.GlobalColorHiBlend[k] = GlobalColorHiBlend[k];
|
|
holder.PER_LAYER_HEIGHT_MODIFIER[k] = PER_LAYER_HEIGHT_MODIFIER[k];
|
|
holder._SuperDetailStrengthMultA[k] = _SuperDetailStrengthMultA[k];
|
|
holder._SuperDetailStrengthMultASelfMaskNear[k] = _SuperDetailStrengthMultASelfMaskNear[k];
|
|
holder._SuperDetailStrengthMultASelfMaskFar[k] = _SuperDetailStrengthMultASelfMaskFar[k];
|
|
holder._SuperDetailStrengthMultB[k] = _SuperDetailStrengthMultB[k];
|
|
holder._SuperDetailStrengthMultBSelfMaskNear[k] = _SuperDetailStrengthMultBSelfMaskNear[k];
|
|
holder._SuperDetailStrengthMultBSelfMaskFar[k] = _SuperDetailStrengthMultBSelfMaskFar[k];
|
|
holder._SuperDetailStrengthNormal[k] = _SuperDetailStrengthNormal[k];
|
|
holder._BumpMapGlobalStrength[k] = _BumpMapGlobalStrength[k];
|
|
holder.VerticalTextureStrength[k] = VerticalTextureStrength[k];
|
|
holder.AO_strength[k] = AO_strength[k];
|
|
holder.Heights[k] = Heights[k];
|
|
holder._snow_strength_per_layer[k] = _snow_strength_per_layer[k];
|
|
holder.Substances[k] = Substances[k];
|
|
holder.TERRAIN_LayerWetStrength[k] = TERRAIN_LayerWetStrength[k];
|
|
holder.TERRAIN_WaterLevel[k] = TERRAIN_WaterLevel[k];
|
|
holder.TERRAIN_WaterLevelSlopeDamp[k] = TERRAIN_WaterLevelSlopeDamp[k];
|
|
holder.TERRAIN_WaterEdge[k] = TERRAIN_WaterEdge[k];
|
|
holder.TERRAIN_WaterGloss[k] = TERRAIN_WaterGloss[k];
|
|
holder.TERRAIN_WaterGlossDamper[k] = TERRAIN_WaterGlossDamper[k];
|
|
holder.TERRAIN_Refraction[k] = TERRAIN_Refraction[k];
|
|
holder.TERRAIN_WetRefraction[k] = TERRAIN_WetRefraction[k];
|
|
holder.TERRAIN_Flow[k] = TERRAIN_Flow[k];
|
|
holder.TERRAIN_WetFlow[k] = TERRAIN_WetFlow[k];
|
|
holder.TERRAIN_WaterMetallic[k] = TERRAIN_WaterMetallic[k];
|
|
holder.TERRAIN_WetGloss[k] = TERRAIN_WetGloss[k];
|
|
holder.TERRAIN_WaterColor[k] = TERRAIN_WaterColor[k];
|
|
holder._GlitterStrength[k] = _GlitterStrength[k];
|
|
}
|
|
}
|
|
|
|
public void InterpolatePresets(ReliefTerrainPresetHolder holderA, ReliefTerrainPresetHolder holderB, float t)
|
|
{
|
|
RTP_MIP_BIAS = Mathf.Lerp(holderA.RTP_MIP_BIAS, holderB.RTP_MIP_BIAS, t);
|
|
MasterLayerBrightness = Mathf.Lerp(holderA.MasterLayerBrightness, holderB.MasterLayerBrightness, t);
|
|
MasterLayerSaturation = Mathf.Lerp(holderA.MasterLayerSaturation, holderB.MasterLayerSaturation, t);
|
|
BumpMapGlobalScale = Mathf.Lerp(holderA.BumpMapGlobalScale, holderB.BumpMapGlobalScale, t);
|
|
GlobalColorMapBlendValues = Vector3.Lerp(holderA.GlobalColorMapBlendValues, holderB.GlobalColorMapBlendValues, t);
|
|
GlobalColorMapSaturation = Mathf.Lerp(holderA.GlobalColorMapSaturation, holderB.GlobalColorMapSaturation, t);
|
|
GlobalColorMapSaturationFar = Mathf.Lerp(holderA.GlobalColorMapSaturationFar, holderB.GlobalColorMapSaturationFar, t);
|
|
GlobalColorMapDistortByPerlin = Mathf.Lerp(holderA.GlobalColorMapDistortByPerlin, holderB.GlobalColorMapDistortByPerlin, t);
|
|
GlobalColorMapBrightness = Mathf.Lerp(holderA.GlobalColorMapBrightness, holderB.GlobalColorMapBrightness, t);
|
|
GlobalColorMapBrightnessFar = Mathf.Lerp(holderA.GlobalColorMapBrightnessFar, holderB.GlobalColorMapBrightnessFar, t);
|
|
_GlobalColorMapNearMIP = Mathf.Lerp(holderA._GlobalColorMapNearMIP, holderB._GlobalColorMapNearMIP, t);
|
|
_FarNormalDamp = Mathf.Lerp(holderA._FarNormalDamp, holderB._FarNormalDamp, t);
|
|
blendMultiplier = Mathf.Lerp(holderA.blendMultiplier, holderB.blendMultiplier, t);
|
|
ReliefTransform = Vector4.Lerp(holderA.ReliefTransform, holderB.ReliefTransform, t);
|
|
DIST_STEPS = Mathf.Lerp(holderA.DIST_STEPS, holderB.DIST_STEPS, t);
|
|
WAVELENGTH = Mathf.Lerp(holderA.WAVELENGTH, holderB.WAVELENGTH, t);
|
|
ReliefBorderBlend = Mathf.Lerp(holderA.ReliefBorderBlend, holderB.ReliefBorderBlend, t);
|
|
ExtrudeHeight = Mathf.Lerp(holderA.ExtrudeHeight, holderB.ExtrudeHeight, t);
|
|
LightmapShading = Mathf.Lerp(holderA.LightmapShading, holderB.LightmapShading, t);
|
|
SHADOW_STEPS = Mathf.Lerp(holderA.SHADOW_STEPS, holderB.SHADOW_STEPS, t);
|
|
WAVELENGTH_SHADOWS = Mathf.Lerp(holderA.WAVELENGTH_SHADOWS, holderB.WAVELENGTH_SHADOWS, t);
|
|
SelfShadowStrength = Mathf.Lerp(holderA.SelfShadowStrength, holderB.SelfShadowStrength, t);
|
|
ShadowSmoothing = Mathf.Lerp(holderA.ShadowSmoothing, holderB.ShadowSmoothing, t);
|
|
ShadowSoftnessFade = Mathf.Lerp(holderA.ShadowSoftnessFade, holderB.ShadowSoftnessFade, t);
|
|
distance_start = Mathf.Lerp(holderA.distance_start, holderB.distance_start, t);
|
|
distance_transition = Mathf.Lerp(holderA.distance_transition, holderB.distance_transition, t);
|
|
distance_start_bumpglobal = Mathf.Lerp(holderA.distance_start_bumpglobal, holderB.distance_start_bumpglobal, t);
|
|
distance_transition_bumpglobal = Mathf.Lerp(holderA.distance_transition_bumpglobal, holderB.distance_transition_bumpglobal, t);
|
|
rtp_perlin_start_val = Mathf.Lerp(holderA.rtp_perlin_start_val, holderB.rtp_perlin_start_val, t);
|
|
trees_shadow_distance_start = Mathf.Lerp(holderA.trees_shadow_distance_start, holderB.trees_shadow_distance_start, t);
|
|
trees_shadow_distance_transition = Mathf.Lerp(holderA.trees_shadow_distance_transition, holderB.trees_shadow_distance_transition, t);
|
|
trees_shadow_value = Mathf.Lerp(holderA.trees_shadow_value, holderB.trees_shadow_value, t);
|
|
trees_pixel_distance_start = Mathf.Lerp(holderA.trees_pixel_distance_start, holderB.trees_pixel_distance_start, t);
|
|
trees_pixel_distance_transition = Mathf.Lerp(holderA.trees_pixel_distance_transition, holderB.trees_pixel_distance_transition, t);
|
|
trees_pixel_blend_val = Mathf.Lerp(holderA.trees_pixel_blend_val, holderB.trees_pixel_blend_val, t);
|
|
global_normalMap_multiplier = Mathf.Lerp(holderA.global_normalMap_multiplier, holderB.global_normalMap_multiplier, t);
|
|
global_normalMap_farUsage = Mathf.Lerp(holderA.global_normalMap_farUsage, holderB.global_normalMap_farUsage, t);
|
|
_AmbientEmissiveMultiplier = Mathf.Lerp(holderA._AmbientEmissiveMultiplier, holderB._AmbientEmissiveMultiplier, t);
|
|
_AmbientEmissiveRelief = Mathf.Lerp(holderA._AmbientEmissiveRelief, holderB._AmbientEmissiveRelief, t);
|
|
_SuperDetailTiling = Mathf.Lerp(holderA._SuperDetailTiling, holderB._SuperDetailTiling, t);
|
|
TERRAIN_GlobalWetness = Mathf.Lerp(holderA.TERRAIN_GlobalWetness, holderB.TERRAIN_GlobalWetness, t);
|
|
TERRAIN_RippleScale = Mathf.Lerp(holderA.TERRAIN_RippleScale, holderB.TERRAIN_RippleScale, t);
|
|
TERRAIN_FlowScale = Mathf.Lerp(holderA.TERRAIN_FlowScale, holderB.TERRAIN_FlowScale, t);
|
|
TERRAIN_FlowSpeed = Mathf.Lerp(holderA.TERRAIN_FlowSpeed, holderB.TERRAIN_FlowSpeed, t);
|
|
TERRAIN_FlowCycleScale = Mathf.Lerp(holderA.TERRAIN_FlowCycleScale, holderB.TERRAIN_FlowCycleScale, t);
|
|
TERRAIN_FlowMipOffset = Mathf.Lerp(holderA.TERRAIN_FlowMipOffset, holderB.TERRAIN_FlowMipOffset, t);
|
|
TERRAIN_WetDarkening = Mathf.Lerp(holderA.TERRAIN_WetDarkening, holderB.TERRAIN_WetDarkening, t);
|
|
TERRAIN_WetDropletsStrength = Mathf.Lerp(holderA.TERRAIN_WetDropletsStrength, holderB.TERRAIN_WetDropletsStrength, t);
|
|
TERRAIN_WetHeight_Treshold = Mathf.Lerp(holderA.TERRAIN_WetHeight_Treshold, holderB.TERRAIN_WetHeight_Treshold, t);
|
|
TERRAIN_WetHeight_Transition = Mathf.Lerp(holderA.TERRAIN_WetHeight_Transition, holderB.TERRAIN_WetHeight_Transition, t);
|
|
TERRAIN_RainIntensity = Mathf.Lerp(holderA.TERRAIN_RainIntensity, holderB.TERRAIN_RainIntensity, t);
|
|
TERRAIN_DropletsSpeed = Mathf.Lerp(holderA.TERRAIN_DropletsSpeed, holderB.TERRAIN_DropletsSpeed, t);
|
|
TERRAIN_mipoffset_flowSpeed = Mathf.Lerp(holderA.TERRAIN_mipoffset_flowSpeed, holderB.TERRAIN_mipoffset_flowSpeed, t);
|
|
TERRAIN_CausticsAnimSpeed = Mathf.Lerp(holderA.TERRAIN_CausticsAnimSpeed, holderB.TERRAIN_CausticsAnimSpeed, t);
|
|
TERRAIN_CausticsColor = Color.Lerp(holderA.TERRAIN_CausticsColor, holderB.TERRAIN_CausticsColor, t);
|
|
TERRAIN_CausticsWaterLevel = Mathf.Lerp(holderA.TERRAIN_CausticsWaterLevel, holderB.TERRAIN_CausticsWaterLevel, t);
|
|
TERRAIN_CausticsWaterLevelByAngle = Mathf.Lerp(holderA.TERRAIN_CausticsWaterLevelByAngle, holderB.TERRAIN_CausticsWaterLevelByAngle, t);
|
|
TERRAIN_CausticsWaterDeepFadeLength = Mathf.Lerp(holderA.TERRAIN_CausticsWaterDeepFadeLength, holderB.TERRAIN_CausticsWaterDeepFadeLength, t);
|
|
TERRAIN_CausticsWaterShallowFadeLength = Mathf.Lerp(holderA.TERRAIN_CausticsWaterShallowFadeLength, holderB.TERRAIN_CausticsWaterShallowFadeLength, t);
|
|
TERRAIN_CausticsTilingScale = Mathf.Lerp(holderA.TERRAIN_CausticsTilingScale, holderB.TERRAIN_CausticsTilingScale, t);
|
|
RTP_AOsharpness = Mathf.Lerp(holderA.RTP_AOsharpness, holderB.RTP_AOsharpness, t);
|
|
RTP_AOamp = Mathf.Lerp(holderA.RTP_AOamp, holderB.RTP_AOamp, t);
|
|
_occlusionStrength = Mathf.Lerp(holderA._occlusionStrength, holderB._occlusionStrength, t);
|
|
RTP_LightDefVector = Vector4.Lerp(holderA.RTP_LightDefVector, holderB.RTP_LightDefVector, t);
|
|
EmissionRefractFiltering = Mathf.Lerp(holderA.EmissionRefractFiltering, holderB.EmissionRefractFiltering, t);
|
|
EmissionRefractAnimSpeed = Mathf.Lerp(holderA.EmissionRefractAnimSpeed, holderB.EmissionRefractAnimSpeed, t);
|
|
VerticalTextureGlobalBumpInfluence = Mathf.Lerp(holderA.VerticalTextureGlobalBumpInfluence, holderB.VerticalTextureGlobalBumpInfluence, t);
|
|
VerticalTextureTiling = Mathf.Lerp(holderA.VerticalTextureTiling, holderB.VerticalTextureTiling, t);
|
|
_snow_strength = Mathf.Lerp(holderA._snow_strength, holderB._snow_strength, t);
|
|
_global_color_brightness_to_snow = Mathf.Lerp(holderA._global_color_brightness_to_snow, holderB._global_color_brightness_to_snow, t);
|
|
_snow_slope_factor = Mathf.Lerp(holderA._snow_slope_factor, holderB._snow_slope_factor, t);
|
|
_snow_edge_definition = Mathf.Lerp(holderA._snow_edge_definition, holderB._snow_edge_definition, t);
|
|
_snow_height_treshold = Mathf.Lerp(holderA._snow_height_treshold, holderB._snow_height_treshold, t);
|
|
_snow_height_transition = Mathf.Lerp(holderA._snow_height_transition, holderB._snow_height_transition, t);
|
|
_snow_color = Color.Lerp(holderA._snow_color, holderB._snow_color, t);
|
|
_snow_gloss = Mathf.Lerp(holderA._snow_gloss, holderB._snow_gloss, t);
|
|
_snow_reflectivness = Mathf.Lerp(holderA._snow_reflectivness, holderB._snow_reflectivness, t);
|
|
_snow_deep_factor = Mathf.Lerp(holderA._snow_deep_factor, holderB._snow_deep_factor, t);
|
|
_snow_diff_fresnel = Mathf.Lerp(holderA._snow_diff_fresnel, holderB._snow_diff_fresnel, t);
|
|
_snow_metallic = Mathf.Lerp(holderA._snow_metallic, holderB._snow_metallic, t);
|
|
_snow_Frost = Mathf.Lerp(holderA._snow_Frost, holderB._snow_Frost, t);
|
|
_snow_MicroTiling = Mathf.Lerp(holderA._snow_MicroTiling, holderB._snow_MicroTiling, t);
|
|
_snow_BumpMicro = Mathf.Lerp(holderA._snow_BumpMicro, holderB._snow_BumpMicro, t);
|
|
_snow_occlusionStrength = Mathf.Lerp(holderA._snow_occlusionStrength, holderB._snow_occlusionStrength, t);
|
|
_SnowGlitterColor = Color.Lerp(holderA._SnowGlitterColor, holderB._SnowGlitterColor, t);
|
|
_GlitterColor = Color.Lerp(holderA._GlitterColor, holderB._GlitterColor, t);
|
|
_GlitterTiling = Mathf.Lerp(holderA._GlitterTiling, holderB._GlitterTiling, t);
|
|
_GlitterDensity = Mathf.Lerp(holderA._GlitterDensity, holderB._GlitterDensity, t);
|
|
_GlitterFilter = Mathf.Lerp(holderA._GlitterFilter, holderB._GlitterFilter, t);
|
|
_GlitterColorization = Mathf.Lerp(holderA._GlitterColorization, holderB._GlitterColorization, t);
|
|
for (int i = 0; i < holderA.Spec.Length; i++)
|
|
{
|
|
if (i < FarSpecCorrection.Length)
|
|
{
|
|
FarSpecCorrection[i] = Mathf.Lerp(holderA.FarSpecCorrection[i], holderB.FarSpecCorrection[i], t);
|
|
MixScale[i] = Mathf.Lerp(holderA.MixScale[i], holderB.MixScale[i], t);
|
|
MixBlend[i] = Mathf.Lerp(holderA.MixBlend[i], holderB.MixBlend[i], t);
|
|
MixSaturation[i] = Mathf.Lerp(holderA.MixSaturation[i], holderB.MixSaturation[i], t);
|
|
RTP_DiffFresnel[i] = Mathf.Lerp(holderA.RTP_DiffFresnel[i], holderB.RTP_DiffFresnel[i], t);
|
|
RTP_metallic[i] = Mathf.Lerp(holderA.RTP_metallic[i], holderB.RTP_metallic[i], t);
|
|
RTP_glossMin[i] = Mathf.Lerp(holderA.RTP_glossMin[i], holderB.RTP_glossMin[i], t);
|
|
RTP_glossMax[i] = Mathf.Lerp(holderA.RTP_glossMax[i], holderB.RTP_glossMax[i], t);
|
|
RTP_glitter[i] = Mathf.Lerp(holderA.RTP_glitter[i], holderB.RTP_glitter[i], t);
|
|
MixBrightness[i] = Mathf.Lerp(holderA.MixBrightness[i], holderB.MixBrightness[i], t);
|
|
MixReplace[i] = Mathf.Lerp(holderA.MixReplace[i], holderB.MixReplace[i], t);
|
|
LayerBrightness[i] = Mathf.Lerp(holderA.LayerBrightness[i], holderB.LayerBrightness[i], t);
|
|
LayerBrightness2Spec[i] = Mathf.Lerp(holderA.LayerBrightness2Spec[i], holderB.LayerBrightness2Spec[i], t);
|
|
LayerAlbedo2SpecColor[i] = Mathf.Lerp(holderA.LayerAlbedo2SpecColor[i], holderB.LayerAlbedo2SpecColor[i], t);
|
|
LayerSaturation[i] = Mathf.Lerp(holderA.LayerSaturation[i], holderB.LayerSaturation[i], t);
|
|
LayerEmission[i] = Mathf.Lerp(holderA.LayerEmission[i], holderB.LayerEmission[i], t);
|
|
LayerEmissionColor[i] = Color.Lerp(holderA.LayerEmissionColor[i], holderB.LayerEmissionColor[i], t);
|
|
LayerEmissionRefractStrength[i] = Mathf.Lerp(holderA.LayerEmissionRefractStrength[i], holderB.LayerEmissionRefractStrength[i], t);
|
|
LayerEmissionRefractHBedge[i] = Mathf.Lerp(holderA.LayerEmissionRefractHBedge[i], holderB.LayerEmissionRefractHBedge[i], t);
|
|
GlobalColorPerLayer[i] = Mathf.Lerp(holderA.GlobalColorPerLayer[i], holderB.GlobalColorPerLayer[i], t);
|
|
GlobalColorBottom[i] = Mathf.Lerp(holderA.GlobalColorBottom[i], holderB.GlobalColorBottom[i], t);
|
|
GlobalColorTop[i] = Mathf.Lerp(holderA.GlobalColorTop[i], holderB.GlobalColorTop[i], t);
|
|
GlobalColorColormapLoSat[i] = Mathf.Lerp(holderA.GlobalColorColormapLoSat[i], holderB.GlobalColorColormapLoSat[i], t);
|
|
GlobalColorColormapHiSat[i] = Mathf.Lerp(holderA.GlobalColorColormapHiSat[i], holderB.GlobalColorColormapHiSat[i], t);
|
|
GlobalColorLayerLoSat[i] = Mathf.Lerp(holderA.GlobalColorLayerLoSat[i], holderB.GlobalColorLayerLoSat[i], t);
|
|
GlobalColorLayerHiSat[i] = Mathf.Lerp(holderA.GlobalColorLayerHiSat[i], holderB.GlobalColorLayerHiSat[i], t);
|
|
GlobalColorLoBlend[i] = Mathf.Lerp(holderA.GlobalColorLoBlend[i], holderB.GlobalColorLoBlend[i], t);
|
|
GlobalColorHiBlend[i] = Mathf.Lerp(holderA.GlobalColorHiBlend[i], holderB.GlobalColorHiBlend[i], t);
|
|
PER_LAYER_HEIGHT_MODIFIER[i] = Mathf.Lerp(holderA.PER_LAYER_HEIGHT_MODIFIER[i], holderB.PER_LAYER_HEIGHT_MODIFIER[i], t);
|
|
_SuperDetailStrengthMultA[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultA[i], holderB._SuperDetailStrengthMultA[i], t);
|
|
_SuperDetailStrengthMultASelfMaskNear[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultASelfMaskNear[i], holderB._SuperDetailStrengthMultASelfMaskNear[i], t);
|
|
_SuperDetailStrengthMultASelfMaskFar[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultASelfMaskFar[i], holderB._SuperDetailStrengthMultASelfMaskFar[i], t);
|
|
_SuperDetailStrengthMultB[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultB[i], holderB._SuperDetailStrengthMultB[i], t);
|
|
_SuperDetailStrengthMultBSelfMaskNear[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultBSelfMaskNear[i], holderB._SuperDetailStrengthMultBSelfMaskNear[i], t);
|
|
_SuperDetailStrengthMultBSelfMaskFar[i] = Mathf.Lerp(holderA._SuperDetailStrengthMultBSelfMaskFar[i], holderB._SuperDetailStrengthMultBSelfMaskFar[i], t);
|
|
_SuperDetailStrengthNormal[i] = Mathf.Lerp(holderA._SuperDetailStrengthNormal[i], holderB._SuperDetailStrengthNormal[i], t);
|
|
_BumpMapGlobalStrength[i] = Mathf.Lerp(holderA._BumpMapGlobalStrength[i], holderB._BumpMapGlobalStrength[i], t);
|
|
AO_strength[i] = Mathf.Lerp(holderA.AO_strength[i], holderB.AO_strength[i], t);
|
|
VerticalTextureStrength[i] = Mathf.Lerp(holderA.VerticalTextureStrength[i], holderB.VerticalTextureStrength[i], t);
|
|
_snow_strength_per_layer[i] = Mathf.Lerp(holderA._snow_strength_per_layer[i], holderB._snow_strength_per_layer[i], t);
|
|
TERRAIN_LayerWetStrength[i] = Mathf.Lerp(holderA.TERRAIN_LayerWetStrength[i], holderB.TERRAIN_LayerWetStrength[i], t);
|
|
TERRAIN_WaterLevel[i] = Mathf.Lerp(holderA.TERRAIN_WaterLevel[i], holderB.TERRAIN_WaterLevel[i], t);
|
|
TERRAIN_WaterLevelSlopeDamp[i] = Mathf.Lerp(holderA.TERRAIN_WaterLevelSlopeDamp[i], holderB.TERRAIN_WaterLevelSlopeDamp[i], t);
|
|
TERRAIN_WaterEdge[i] = Mathf.Lerp(holderA.TERRAIN_WaterEdge[i], holderB.TERRAIN_WaterEdge[i], t);
|
|
TERRAIN_WaterGloss[i] = Mathf.Lerp(holderA.TERRAIN_WaterGloss[i], holderB.TERRAIN_WaterGloss[i], t);
|
|
TERRAIN_WaterGlossDamper[i] = Mathf.Lerp(holderA.TERRAIN_WaterGlossDamper[i], holderB.TERRAIN_WaterGlossDamper[i], t);
|
|
TERRAIN_Refraction[i] = Mathf.Lerp(holderA.TERRAIN_Refraction[i], holderB.TERRAIN_Refraction[i], t);
|
|
TERRAIN_WetRefraction[i] = Mathf.Lerp(holderA.TERRAIN_WetRefraction[i], holderB.TERRAIN_WetRefraction[i], t);
|
|
TERRAIN_Flow[i] = Mathf.Lerp(holderA.TERRAIN_Flow[i], holderB.TERRAIN_Flow[i], t);
|
|
TERRAIN_WetFlow[i] = Mathf.Lerp(holderA.TERRAIN_WetFlow[i], holderB.TERRAIN_WetFlow[i], t);
|
|
TERRAIN_WaterMetallic[i] = Mathf.Lerp(holderA.TERRAIN_WaterMetallic[i], holderB.TERRAIN_WaterMetallic[i], t);
|
|
TERRAIN_WetGloss[i] = Mathf.Lerp(holderA.TERRAIN_WetGloss[i], holderB.TERRAIN_WetGloss[i], t);
|
|
TERRAIN_WaterColor[i] = Color.Lerp(holderA.TERRAIN_WaterColor[i], holderB.TERRAIN_WaterColor[i], t);
|
|
TERRAIN_WaterEmission[i] = Mathf.Lerp(holderA.TERRAIN_WaterEmission[i], holderB.TERRAIN_WaterEmission[i], t);
|
|
_GlitterStrength[i] = Mathf.Lerp(holderA._GlitterStrength[i], holderB._GlitterStrength[i], t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ReturnToDefaults(string what = "", int layerIdx = -1)
|
|
{
|
|
if (what == string.Empty || what == "main")
|
|
{
|
|
ReliefTransform = new Vector4(3f, 3f, 0f, 0f);
|
|
distance_start = 5f;
|
|
distance_transition = 20f;
|
|
RTP_LightDefVector = new Vector4(0.05f, 0.5f, 0.5f, 25f);
|
|
ReliefBorderBlend = 6f;
|
|
LightmapShading = 0f;
|
|
RTP_MIP_BIAS = 0f;
|
|
RTP_AOsharpness = 1.5f;
|
|
RTP_AOamp = 0.1f;
|
|
_occlusionStrength = 1f;
|
|
MasterLayerBrightness = 1f;
|
|
MasterLayerSaturation = 1f;
|
|
EmissionRefractFiltering = 4f;
|
|
EmissionRefractAnimSpeed = 4f;
|
|
}
|
|
if (what == string.Empty || what == "perlin")
|
|
{
|
|
BumpMapGlobalScale = 0.1f;
|
|
_FarNormalDamp = 0.2f;
|
|
distance_start_bumpglobal = 30f;
|
|
distance_transition_bumpglobal = 30f;
|
|
rtp_perlin_start_val = 0f;
|
|
}
|
|
if (what == string.Empty || what == "global_color")
|
|
{
|
|
GlobalColorMapBlendValues = new Vector3(0.2f, 0.4f, 0.5f);
|
|
GlobalColorMapSaturation = 1f;
|
|
GlobalColorMapSaturationFar = 1f;
|
|
GlobalColorMapDistortByPerlin = 0.005f;
|
|
GlobalColorMapBrightness = 1f;
|
|
GlobalColorMapBrightnessFar = 1f;
|
|
_GlobalColorMapNearMIP = 0f;
|
|
trees_shadow_distance_start = 50f;
|
|
trees_shadow_distance_transition = 10f;
|
|
trees_shadow_value = 0.5f;
|
|
trees_pixel_distance_start = 500f;
|
|
trees_pixel_distance_transition = 10f;
|
|
trees_pixel_blend_val = 2f;
|
|
global_normalMap_multiplier = 1f;
|
|
global_normalMap_farUsage = 0f;
|
|
_Phong = 0f;
|
|
tessHeight = 300f;
|
|
_TessSubdivisions = 1f;
|
|
_TessSubdivisionsFar = 1f;
|
|
_TessYOffset = 0f;
|
|
_AmbientEmissiveMultiplier = 1f;
|
|
_AmbientEmissiveRelief = 0.5f;
|
|
}
|
|
if (what == string.Empty || what == "uvblend")
|
|
{
|
|
blendMultiplier = 1f;
|
|
}
|
|
if (what == string.Empty || what == "pom/pm")
|
|
{
|
|
ExtrudeHeight = 0.05f;
|
|
DIST_STEPS = 20f;
|
|
WAVELENGTH = 2f;
|
|
SHADOW_STEPS = 20f;
|
|
WAVELENGTH_SHADOWS = 2f;
|
|
SelfShadowStrength = 0.8f;
|
|
ShadowSmoothing = 1f;
|
|
ShadowSoftnessFade = 0.8f;
|
|
}
|
|
if (what == string.Empty || what == "snow")
|
|
{
|
|
_global_color_brightness_to_snow = 0.5f;
|
|
_snow_strength = 0f;
|
|
_snow_slope_factor = 2f;
|
|
_snow_edge_definition = 2f;
|
|
_snow_height_treshold = -200f;
|
|
_snow_height_transition = 1f;
|
|
_snow_color = Color.white;
|
|
_snow_gloss = 0.7f;
|
|
_snow_reflectivness = 0.7f;
|
|
_snow_deep_factor = 1.5f;
|
|
_snow_diff_fresnel = 0.5f;
|
|
_SnowGlitterColor = new Color(1f, 1f, 1f, 0.1f);
|
|
}
|
|
if (what == string.Empty || what == "superdetail")
|
|
{
|
|
_SuperDetailTiling = 8f;
|
|
}
|
|
if (what == string.Empty || what == "vertical")
|
|
{
|
|
VerticalTextureGlobalBumpInfluence = 0f;
|
|
VerticalTextureTiling = 50f;
|
|
}
|
|
if (what == string.Empty || what == "glitter")
|
|
{
|
|
_GlitterColor = new Color(1f, 1f, 1f, 0.1f);
|
|
_GlitterTiling = 1f;
|
|
_GlitterDensity = 0.1f;
|
|
_GlitterFilter = 0f;
|
|
_GlitterColorization = 0.5f;
|
|
}
|
|
if (what == string.Empty || what == "water")
|
|
{
|
|
TERRAIN_GlobalWetness = 1f;
|
|
TERRAIN_RippleScale = 4f;
|
|
TERRAIN_FlowScale = 1f;
|
|
TERRAIN_FlowSpeed = 0.5f;
|
|
TERRAIN_FlowCycleScale = 1f;
|
|
TERRAIN_RainIntensity = 1f;
|
|
TERRAIN_DropletsSpeed = 10f;
|
|
TERRAIN_mipoffset_flowSpeed = 1f;
|
|
TERRAIN_FlowMipOffset = 0f;
|
|
TERRAIN_WetDarkening = 0.5f;
|
|
TERRAIN_WetDropletsStrength = 0f;
|
|
TERRAIN_WetHeight_Treshold = -200f;
|
|
TERRAIN_WetHeight_Transition = 5f;
|
|
}
|
|
if (what == string.Empty || what == "caustics")
|
|
{
|
|
TERRAIN_CausticsAnimSpeed = 2f;
|
|
TERRAIN_CausticsColor = Color.white;
|
|
TERRAIN_CausticsWaterLevel = 30f;
|
|
TERRAIN_CausticsWaterLevelByAngle = 2f;
|
|
TERRAIN_CausticsWaterDeepFadeLength = 50f;
|
|
TERRAIN_CausticsWaterShallowFadeLength = 30f;
|
|
TERRAIN_CausticsTilingScale = 1f;
|
|
}
|
|
if (what == string.Empty || what == "layer")
|
|
{
|
|
int num = 0;
|
|
int num2 = ((numLayers >= 12) ? 12 : numLayers);
|
|
if (layerIdx >= 0)
|
|
{
|
|
num = layerIdx;
|
|
num2 = layerIdx + 1;
|
|
}
|
|
for (int i = num; i < num2; i++)
|
|
{
|
|
FarSpecCorrection[i] = 0f;
|
|
MIPmult[i] = 0f;
|
|
MixScale[i] = 0.2f;
|
|
MixBlend[i] = 0.5f;
|
|
MixSaturation[i] = 0.3f;
|
|
RTP_DiffFresnel[i] = 0f;
|
|
RTP_metallic[i] = 0f;
|
|
RTP_glossMin[i] = 0f;
|
|
RTP_glossMax[i] = 1f;
|
|
RTP_glitter[i] = 0f;
|
|
MixBrightness[i] = 2f;
|
|
MixReplace[i] = 0f;
|
|
LayerBrightness[i] = 1f;
|
|
LayerBrightness2Spec[i] = 0f;
|
|
LayerAlbedo2SpecColor[i] = 0f;
|
|
LayerSaturation[i] = 1f;
|
|
LayerEmission[i] = 0f;
|
|
LayerEmissionColor[i] = Color.black;
|
|
LayerEmissionRefractStrength[i] = 0f;
|
|
LayerEmissionRefractHBedge[i] = 0f;
|
|
GlobalColorPerLayer[i] = 1f;
|
|
GlobalColorBottom[i] = 0f;
|
|
GlobalColorTop[i] = 1f;
|
|
GlobalColorColormapLoSat[i] = 1f;
|
|
GlobalColorColormapHiSat[i] = 1f;
|
|
GlobalColorLayerLoSat[i] = 1f;
|
|
GlobalColorLayerHiSat[i] = 1f;
|
|
GlobalColorLoBlend[i] = 1f;
|
|
GlobalColorHiBlend[i] = 1f;
|
|
PER_LAYER_HEIGHT_MODIFIER[i] = 0f;
|
|
_SuperDetailStrengthMultA[i] = 0f;
|
|
_SuperDetailStrengthMultASelfMaskNear[i] = 0f;
|
|
_SuperDetailStrengthMultASelfMaskFar[i] = 0f;
|
|
_SuperDetailStrengthMultB[i] = 0f;
|
|
_SuperDetailStrengthMultBSelfMaskNear[i] = 0f;
|
|
_SuperDetailStrengthMultBSelfMaskFar[i] = 0f;
|
|
_SuperDetailStrengthNormal[i] = 0f;
|
|
_BumpMapGlobalStrength[i] = 0.3f;
|
|
_snow_strength_per_layer[i] = 1f;
|
|
VerticalTextureStrength[i] = 0.5f;
|
|
AO_strength[i] = 1f;
|
|
TERRAIN_LayerWetStrength[i] = 1f;
|
|
TERRAIN_WaterLevel[i] = 0.5f;
|
|
TERRAIN_WaterLevelSlopeDamp[i] = 0.5f;
|
|
TERRAIN_WaterEdge[i] = 2f;
|
|
TERRAIN_WaterGloss[i] = 0.1f;
|
|
TERRAIN_WaterGlossDamper[i] = 0f;
|
|
TERRAIN_Refraction[i] = 0.01f;
|
|
TERRAIN_WetRefraction[i] = 0.2f;
|
|
TERRAIN_Flow[i] = 0.3f;
|
|
TERRAIN_WetFlow[i] = 0.05f;
|
|
TERRAIN_WaterMetallic[i] = 0.1f;
|
|
TERRAIN_WetGloss[i] = 0.05f;
|
|
TERRAIN_WaterColor[i] = new Color(0.9f, 0.9f, 1f, 0.5f);
|
|
TERRAIN_WaterEmission[i] = 0f;
|
|
_GlitterStrength[i] = 0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool CheckAndUpdate(ref float[] aLayerPropArray, float defVal, int len)
|
|
{
|
|
if (aLayerPropArray == null || aLayerPropArray.Length < len)
|
|
{
|
|
aLayerPropArray = new float[len];
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
aLayerPropArray[i] = defVal;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool CheckAndUpdate(ref Color[] aLayerPropArray, Color defVal, int len)
|
|
{
|
|
if (aLayerPropArray == null || aLayerPropArray.Length < len)
|
|
{
|
|
aLayerPropArray = new Color[len];
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
aLayerPropArray[i] = defVal;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|