public void RunNode() { var layer = (NodeVariables.Texture)GetValue(); if (layer == null) { return; } switch (layer.LandLayer) { case 0: MapManager.PaintConditional(LandLayers.Ground, TerrainSplat.TypeToIndex(layer.GroundTexture), conditions); break; case 1: MapManager.PaintConditional(LandLayers.Biome, TerrainBiome.TypeToIndex(layer.BiomeTexture), conditions); break; case 2: MapManager.PaintConditional(LandLayers.Alpha, layer.AlphaTexture, conditions); break; case 3: MapManager.PaintConditional(LandLayers.Topology, layer.TopologyTexture, conditions, layer.TopologyLayer); break; } }
public void RunNode() { var layer = (NodeVariables.Texture)GetValue(); if (layer == null) // Check for if the textures node is not connected. { return; } switch (layer.LandLayer) { case 0: MapManager.PaintLayer(LandLayers.Ground, TerrainSplat.TypeToIndex(layer.GroundTexture)); break; case 1: MapManager.PaintLayer(LandLayers.Biome, TerrainBiome.TypeToIndex(layer.BiomeTexture)); break; case 2: MapManager.PaintLayer(LandLayers.Alpha, layer.AlphaTexture); break; case 3: MapManager.PaintLayer(LandLayers.Topology, layer.TopologyTexture, layer.TopologyLayer); break; } }
private void OnGUI() { scrollPos = EditorGUILayout.BeginScrollView(scrollPos, false, false); GUIContent[] layersOptionsMenu = new GUIContent[4]; layersOptionsMenu[0] = new GUIContent("Ground"); layersOptionsMenu[1] = new GUIContent("Biome"); layersOptionsMenu[2] = new GUIContent("Alpha"); layersOptionsMenu[3] = new GUIContent("Topology"); EditorGUI.BeginChangeCheck(); layerIndex = GUILayout.Toolbar(layerIndex, layersOptionsMenu, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) TerrainManager.ChangeLayer((TerrainManager.LayerType)layerIndex, TerrainTopology.TypeToIndex((int)layers.Topologies)); if (layerIndex != (int)TerrainManager.CurrentLayerType) layerIndex = (int)TerrainManager.CurrentLayerType; switch ((TerrainManager.LayerType)layerIndex) { case TerrainManager.LayerType.Ground: Functions.TextureSelect(TerrainManager.CurrentLayerType, ref layers); Functions.AreaSelect(); Functions.LayerTools(TerrainManager.CurrentLayerType, TerrainSplat.TypeToIndex((int)layers.Ground)); Functions.RotateTools(TerrainManager.CurrentLayerType); Functions.RiverTools(TerrainManager.CurrentLayerType, TerrainSplat.TypeToIndex((int)layers.Ground), ref aboveTerrain); Functions.SlopeTools(TerrainManager.CurrentLayerType, TerrainSplat.TypeToIndex((int)layers.Ground), ref slopesInfo); Functions.HeightTools(TerrainManager.CurrentLayerType, TerrainSplat.TypeToIndex((int)layers.Ground), ref heightsInfo); break; case TerrainManager.LayerType.Biome: Functions.TextureSelect(TerrainManager.CurrentLayerType, ref layers); Functions.AreaSelect(); Functions.LayerTools(TerrainManager.CurrentLayerType, TerrainBiome.TypeToIndex((int)layers.Biome)); Functions.RotateTools(TerrainManager.CurrentLayerType); Functions.RiverTools(TerrainManager.CurrentLayerType, TerrainBiome.TypeToIndex((int)layers.Biome), ref aboveTerrain); Functions.SlopeTools(TerrainManager.CurrentLayerType, TerrainBiome.TypeToIndex((int)layers.Biome), ref slopesInfo); Functions.HeightTools(TerrainManager.CurrentLayerType, TerrainBiome.TypeToIndex((int)layers.Biome), ref heightsInfo); break; case TerrainManager.LayerType.Alpha: Functions.LayerTools((TerrainManager.LayerType)layerIndex, 0, 1); Functions.AreaSelect(); Functions.RotateTools((TerrainManager.LayerType)layerIndex); Functions.RiverTools((TerrainManager.LayerType)layerIndex, 0, ref aboveTerrain, 1); Functions.SlopeTools((TerrainManager.LayerType)layerIndex, 0, ref slopesInfo, 1); Functions.HeightTools((TerrainManager.LayerType)layerIndex, 0, ref heightsInfo, 1); break; case TerrainManager.LayerType.Topology: Functions.TopologyLayerSelect(ref layers); Functions.AreaSelect(); Functions.LayerTools(TerrainManager.CurrentLayerType, 0, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.RotateTools(TerrainManager.CurrentLayerType, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.TopologyTools(); Functions.RiverTools(TerrainManager.CurrentLayerType, 0, ref aboveTerrain, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.SlopeTools(TerrainManager.CurrentLayerType, 0, ref slopesInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.HeightTools(TerrainManager.CurrentLayerType, 0, ref heightsInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); break; } EditorGUILayout.EndScrollView(); }
public static void ConditionalPaintLayerSelect(ref Conditions cnds, ref Layers layers, ref int texture) { Elements.MiniBoldLabel(ToolTips.textureToPaintLabel); Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.layerSelect); layers.LandLayer = (LandLayers)Elements.ToolbarEnumPopup(layers.LandLayer); Elements.EndToolbarHorizontal(); switch (layers.LandLayer) { case LandLayers.Ground: Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.textureSelect); layers.Ground = (TerrainSplat.Enum)Elements.ToolbarEnumPopup(layers.Ground); texture = TerrainSplat.TypeToIndex((int)layers.Ground); Elements.EndToolbarHorizontal(); break; case LandLayers.Biome: Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.textureSelect); layers.Biome = (TerrainBiome.Enum)Elements.ToolbarEnumPopup(layers.Biome); texture = TerrainBiome.TypeToIndex((int)layers.Biome); Elements.EndToolbarHorizontal(); break; case LandLayers.Alpha: Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.textureSelect); layers.AlphaTexture = (AlphaTextures)Elements.ToolbarEnumPopup(layers.AlphaTexture); texture = (int)layers.AlphaTexture; Elements.EndToolbarHorizontal(); break; case LandLayers.Topology: Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.topologyLayerSelect); layers.Topologies = (TerrainTopology.Enum)Elements.ToolbarEnumPopup(layers.Topologies); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.textureSelect); layers.TopologyTexture = (TopologyTextures)Elements.ToolbarEnumPopup(layers.TopologyTexture); texture = (int)layers.TopologyTexture; Elements.EndToolbarHorizontal(); break; } Elements.BeginToolbarHorizontal(); if (Elements.ToolbarButton(ToolTips.paintConditional)) { MapManager.PaintConditional(layers.LandLayer, texture, cnds, TerrainTopology.TypeToIndex((int)layers.Topologies)); } Elements.EndToolbarHorizontal(); }
public Color GetColor(float normX, float normZ, int mask = -1) { float biome = this.biomeMap.GetBiome(normX, normZ, 1); float single = this.biomeMap.GetBiome(normX, normZ, 2); float biome1 = this.biomeMap.GetBiome(normX, normZ, 4); float single1 = this.biomeMap.GetBiome(normX, normZ, 8); int index = TerrainSplat.TypeToIndex(this.splatMap.GetSplatMaxType(normX, normZ, mask)); TerrainConfig.SplatType splats = this.config.Splats[index]; return((((biome * splats.AridColor) + (single * splats.TemperateColor)) + (biome1 * splats.TundraColor)) + (single1 * splats.ArcticColor)); }
public Color GetColor(float normX, float normZ, int mask = -1) { double biome1 = (double)this.biomeMap.GetBiome(normX, normZ, 1); float biome2 = this.biomeMap.GetBiome(normX, normZ, 2); float biome3 = this.biomeMap.GetBiome(normX, normZ, 4); float biome4 = this.biomeMap.GetBiome(normX, normZ, 8); TerrainConfig.SplatType splat = this.config.Splats[TerrainSplat.TypeToIndex(this.splatMap.GetSplatMaxType(normX, normZ, mask))]; Color aridColor = splat.AridColor; return(Color.op_Addition(Color.op_Addition(Color.op_Addition(Color.op_Multiply((float)biome1, aridColor), Color.op_Multiply(biome2, splat.TemperateColor)), Color.op_Multiply(biome3, splat.TundraColor)), Color.op_Multiply(biome4, splat.ArcticColor))); }
public static MapInfo EmptyMap(int size, float landHeight, TerrainSplat.Enum ground = TerrainSplat.Enum.Grass, TerrainBiome.Enum biome = TerrainBiome.Enum.Temperate) { MapInfo terrains = new MapInfo(); int splatRes = Mathf.Clamp(Mathf.NextPowerOfTwo((int)(size * 0.50f)), 512, 2048); List <PathData> paths = new List <PathData>(); List <PrefabData> prefabs = new List <PrefabData>(); terrains.pathData = paths.ToArray(); terrains.prefabData = prefabs.ToArray(); terrains.terrainRes = Mathf.Clamp(Mathf.NextPowerOfTwo(size), 512, 4096) + 1; terrains.size = new Vector3(size, 1000, size); terrains.land.heights = SetValues(new float[terrains.terrainRes, terrains.terrainRes], landHeight / 1000f, new Area(0, terrains.terrainRes, 0, terrains.terrainRes)); terrains.water.heights = SetValues(new float[terrains.terrainRes, terrains.terrainRes], 500f / 1000f, new Area(0, terrains.terrainRes, 0, terrains.terrainRes)); terrains.splatRes = splatRes; terrains.splatMap = new float[splatRes, splatRes, 8]; int gndIdx = TerrainSplat.TypeToIndex((int)ground); Parallel.For(0, splatRes, i => { for (int j = 0; j < splatRes; j++) { terrains.splatMap[i, j, gndIdx] = 1f; } }); terrains.biomeMap = new float[splatRes, splatRes, 4]; int biomeIdx = TerrainBiome.TypeToIndex((int)biome); Parallel.For(0, splatRes, i => { for (int j = 0; j < splatRes; j++) { terrains.biomeMap[i, j, biomeIdx] = 1f; } }); terrains.alphaMap = new bool[splatRes, splatRes]; Parallel.For(0, splatRes, i => { for (int j = 0; j < splatRes; j++) { terrains.alphaMap[i, j] = true; } }); terrains.topology = new TerrainMap <int>(new byte[(int)Mathf.Pow(splatRes, 2) * 4 * 1], 1); return(terrains); }
public void SetSplat(float normX, float normZ, int id, float opacity, float radius, float fade = 0f) { int index = TerrainSplat.TypeToIndex(id); Action <int, int, float> action = (int x, int z, float lerp) => { if (lerp > 0f) { float u003cu003e4_this = (float)this.dst[(index * this.res + z) * this.res + x]; float single = Mathf.Lerp(u003cu003e4_this, 1f, lerp * opacity); this.SetSplat(x, z, id, u003cu003e4_this, single); } }; base.ApplyFilter(normX, normZ, radius, fade, action); }
public void SetSplat(int x, int z, int id) { int index = TerrainSplat.TypeToIndex(id); for (int i = 0; i < this.num; i++) { if (i != index) { this.dst[(i * this.res + z) * this.res + x] = 0; } else { this.dst[(i * this.res + z) * this.res + x] = 255; } } }
public void AddSplat(float normX, float normZ, int id, float delta, float radius, float fade = 0.0f) { int idx = TerrainSplat.TypeToIndex(id); Action <int, int, float> action = (Action <int, int, float>)((x, z, lerp) => { if ((double)lerp <= 0.0) { return; } float old_val = (float)this.dst[(idx * this.res + z) * this.res + x]; float new_val = Mathf.Clamp01(old_val + lerp * delta); this.SetSplat(x, z, id, old_val, new_val); }); this.ApplyFilter(normX, normZ, radius, fade, action); }
public void SetSplat(int x, int z, int id) { int index1 = TerrainSplat.TypeToIndex(id); for (int index2 = 0; index2 < this.num; ++index2) { if (index2 == index1) { this.dst[(index2 * this.res + z) * this.res + x] = byte.MaxValue; } else { this.dst[(index2 * this.res + z) * this.res + x] = (byte)0; } } }
public float GetSplatMax(int x, int z, int mask = -1) { byte num = 0; for (int i = 0; i < this.num; i++) { if ((TerrainSplat.IndexToType(i) & mask) != 0) { byte num1 = this.src[(i * this.res + z) * this.res + x]; if (num1 >= num) { num = num1; } } } return(BitUtility.Byte2Float((int)num)); }
public float GetSplatMax(int x, int z, int mask = -1) { byte num1 = 0; for (int index = 0; index < this.num; ++index) { if ((TerrainSplat.IndexToType(index) & mask) != 0) { byte num2 = this.src[(index * this.res + z) * this.res + x]; if ((int)num2 >= (int)num1) { num1 = num2; } } } return(BitUtility.Byte2Float((int)num1)); }
public float GetSplat(int x, int z, int mask) { if (Mathf.IsPowerOfTwo(mask)) { return(BitUtility.Byte2Float(this.src[(TerrainSplat.TypeToIndex(mask) * this.res + z) * this.res + x])); } int num = 0; for (int i = 0; i < this.num; i++) { if ((TerrainSplat.IndexToType(i) & mask) != 0) { num += this.src[(i * this.res + z) * this.res + x]; } } return(Mathf.Clamp01(BitUtility.Byte2Float(num))); }
public int GetSplatMaxIndex(int x, int z, int mask = -1) { byte num1 = 0; int num2 = 0; for (int index = 0; index < this.num; ++index) { if ((TerrainSplat.IndexToType(index) & mask) != 0) { byte num3 = this.src[(index * this.res + z) * this.res + x]; if ((int)num3 >= (int)num1) { num1 = num3; num2 = index; } } } return(num2); }
public int GetSplatMaxIndex(int x, int z, int mask = -1) { byte num = 0; int num1 = 0; for (int i = 0; i < this.num; i++) { if ((TerrainSplat.IndexToType(i) & mask) != 0) { byte num2 = this.src[(i * this.res + z) * this.res + x]; if (num2 >= num) { num = num2; num1 = i; } } } return(num1); }
private void SetSplat(int x, int z, int id, float old_val, float new_val) { int index1 = TerrainSplat.TypeToIndex(id); if ((double)old_val >= 1.0) { return; } float num = (float)((1.0 - (double)new_val) / (1.0 - (double)old_val)); for (int index2 = 0; index2 < this.num; ++index2) { if (index2 == index1) { this.dst[(index2 * this.res + z) * this.res + x] = BitUtility.Float2Byte(new_val); } else { this.dst[(index2 * this.res + z) * this.res + x] = BitUtility.Float2Byte(num * BitUtility.Byte2Float((int)this.dst[(index2 * this.res + z) * this.res + x])); } } }
private void SetSplat(int x, int z, int id, float old_val, float new_val) { int index = TerrainSplat.TypeToIndex(id); if (old_val >= 1f) { return; } float newVal = (1f - new_val) / (1f - old_val); for (int i = 0; i < this.num; i++) { if (i != index) { this.dst[(i * this.res + z) * this.res + x] = BitUtility.Float2Byte(newVal * BitUtility.Byte2Float(this.dst[(i * this.res + z) * this.res + x])); } else { this.dst[(i * this.res + z) * this.res + x] = BitUtility.Float2Byte(new_val); } } }
public void RunNode() { var layer = (NodeVariables.Texture)GetValue(); switch (layer.LandLayer) { case 0: MapManager.PaintRiver(LandLayers.Ground, aboveTerrain, TerrainSplat.TypeToIndex(layer.GroundTexture)); break; case 1: MapManager.PaintRiver(LandLayers.Biome, aboveTerrain, TerrainBiome.TypeToIndex(layer.BiomeTexture)); break; case 2: MapManager.PaintRiver(LandLayers.Alpha, aboveTerrain, layer.AlphaTexture); break; case 3: MapManager.PaintRiver(LandLayers.Topology, aboveTerrain, layer.TopologyTexture, layer.TopologyLayer); break; } }
public static void NewMapOptions(ref int mapSize, ref float landHeight, ref Layers layers, CreateMapWindow window) { mapSize = Elements.ToolbarIntSlider(ToolTips.mapSize, mapSize, 1000, 6000); landHeight = Elements.ToolbarSlider(ToolTips.newMapHeight, landHeight, 0, 1000); Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.newMapGround); layers.Ground = (TerrainSplat.Enum)Elements.ToolbarEnumPopup(layers.Ground); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.newMapBiome); layers.Biome = (TerrainBiome.Enum)Elements.ToolbarEnumPopup(layers.Biome); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); if (Elements.ToolbarButton(ToolTips.createMap)) { window.Close(); int newMap = EditorUtility.DisplayDialogComplex("Warning", "Creating a new map will remove any unsaved changes to your map.", "Create New Map", "Close", "Save and Create New Map"); switch (newMap) { case 1: return; case 2: SaveMapPanel(); break; } MapManager.CreateMap(mapSize, TerrainSplat.TypeToIndex((int)layers.Ground), TerrainBiome.TypeToIndex((int)layers.Biome), landHeight); } if (Elements.ToolbarButton(ToolTips.cancel)) { window.Close(); } Elements.EndToolbarHorizontal(); }
public void OnGUI() { scrollPos = EditorGUILayout.BeginScrollView(scrollPos, false, false); GUIContent[] mainMenu = new GUIContent[6]; mainMenu[0] = new GUIContent("File"); mainMenu[1] = new GUIContent("Settings"); mainMenu[2] = new GUIContent("Prefabs"); mainMenu[3] = new GUIContent("Layers"); mainMenu[4] = new GUIContent("Generator"); mainMenu[5] = new GUIContent("Advanced"); mainMenuOptions = GUILayout.Toolbar(mainMenuOptions, mainMenu, EditorStyles.toolbarButton); Functions.SaveSettings(); #region Menu switch (mainMenuOptions) { #region File case 0: Functions.EditorIO(); Functions.NewMapOptions(ref mapSize, ref landHeight, ref layers); Functions.MapInfo(); break; #endregion #region Prefabs case 1: Functions.EditorSettings(); Functions.EditorInfo(); Functions.EditorLinks(); break; case 2: Functions.Replacer(ref replacer, ref replacerPresetIndex, ref replacerList); break; #endregion case 3: GUIContent[] layersMenu = new GUIContent[4]; layersMenu[0] = new GUIContent("Ground"); layersMenu[1] = new GUIContent("Biome"); layersMenu[2] = new GUIContent("Alpha"); layersMenu[3] = new GUIContent("Topology"); EditorGUI.BeginChangeCheck(); layerIndex = GUILayout.Toolbar(layerIndex, layersMenu, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { Functions.SetLandLayer((LandLayers)layerIndex, TerrainTopology.TypeToIndex((int)layers.Topologies)); } switch (TerrainManager.LandLayer) { case LandLayers.Ground: Functions.TextureSelect((LandLayers)layerIndex, ref layers); Functions.LayerTools(TerrainManager.LandLayer, TerrainSplat.TypeToIndex((int)layers.Ground)); crazing = SettingsManager.crazing; crazing.splatLayer = TerrainTopology.TypeToIndex((int)layers.Ground); Functions.Crazing(ref crazing); perlinSplat = SettingsManager.perlinSplat; perlinSplat.splatLayer = TerrainTopology.TypeToIndex((int)layers.Ground); Functions.PerlinSplat(ref perlinSplat); Functions.HeightTools(TerrainManager.LandLayer, TerrainSplat.TypeToIndex((int)layers.Ground), ref heightsInfo); Functions.SlopeTools(TerrainManager.LandLayer, TerrainSplat.TypeToIndex((int)layers.Ground), ref slopesInfo); Functions.RiverTools(TerrainManager.LandLayer, TerrainSplat.TypeToIndex((int)layers.Ground), ref aboveTerrain); break; case LandLayers.Biome: Functions.TextureSelect((LandLayers)layerIndex, ref layers); Functions.LayerTools(TerrainManager.LandLayer, TerrainBiome.TypeToIndex((int)layers.Biome)); Functions.HeightTools(TerrainManager.LandLayer, TerrainBiome.TypeToIndex((int)layers.Biome), ref heightsInfo); Functions.SlopeTools(TerrainManager.LandLayer, TerrainBiome.TypeToIndex((int)layers.Biome), ref slopesInfo); break; case LandLayers.Alpha: Functions.LayerTools(TerrainManager.LandLayer, 0, 1); break; case LandLayers.Topology: Functions.TopologyTools(); Functions.TopologyLayerSelect(ref layers); Functions.LayerTools(TerrainManager.LandLayer, 0, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.HeightTools(TerrainManager.LandLayer, 0, ref heightsInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.SlopeTools(TerrainManager.LandLayer, 0, ref slopesInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.Combinator(ref layers, ref sourceLayers, ref tttWeight, ref thicc); Functions.RiverTools(TerrainManager.LandLayer, 0, ref aboveTerrain, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.LakeOcean(ref layers); break; } switch (mapToolsOptions) { /* #region HeightMap * case 0: * GUIContent[] heightMapMenu = new GUIContent[2]; * heightMapMenu[0] = new GUIContent("Heights"); * heightMapMenu[1] = new GUIContent("Filters"); * heightMapOptions = GUILayout.Toolbar(heightMapOptions, heightMapMenu, EditorStyles.toolbarButton); * * switch (heightMapOptions) * { * case 0: * Elements.BoldLabel(ToolTips.heightsLabel); * Functions.OffsetMap(ref offset, ref clampOffset); * Functions.SetHeight(ref heightSet); * Functions.ClampHeight(ref heightLow, ref heightHigh); * Elements.BoldLabel(ToolTips.miscLabel); * Functions.InvertMap(); * break; * case 1: * Functions.NormaliseMap(ref normaliseLow, ref normaliseHigh, ref autoUpdate); * Functions.SmoothMap(ref filterStrength, ref blurDirection, ref smoothPasses); * Functions.TerraceMap(ref terraceErodeFeatureSize, ref terraceErodeInteriorCornerWeight); * break; * } * break; #endregion * #region Textures * case 0: * Functions.ConditionalPaint(ref conditionalPaintOptions, ref texture, ref conditions, ref layers); * break; #endregion * #region Misc * case 2: * Functions.RotateMap(ref rotateSelection); * break; #endregion */ } break; case 4: GUIContent[] generatorMenu = new GUIContent[3]; generatorMenu[0] = new GUIContent("Heightmap"); generatorMenu[1] = new GUIContent("Geology"); generatorMenu[2] = new GUIContent("Monuments"); generatorOptions = GUILayout.Toolbar(generatorOptions, generatorMenu, EditorStyles.toolbarButton); switch (generatorOptions) { case 0: Functions.SetHeight(ref heightSet); Functions.OffsetMap(ref offset, ref clampOffset); perlin = SettingsManager.perlin; Functions.PerlinTerrain(ref perlin); Functions.NormaliseMap(ref normaliseLow, ref normaliseHigh, ref autoUpdate); ocean = SettingsManager.ocean; Functions.Ocean(ref ocean); ripple = SettingsManager.ripple; Functions.Ripple(ref ripple); terracing = SettingsManager.terracing; Functions.RandomTerracing(ref terracing); break; case 1: Functions.Geology(ref activePreset, ref presetIndex, ref geologyList, ref macroIndex, ref macroList, ref macroTitle, ref macroDisplay, ref layers); break; case 2: city = SettingsManager.city; Functions.RustCity(ref city); break; } break; case 5: Functions.Merger(ref zOffset); break; } #endregion EditorGUILayout.EndScrollView(); }
warp_Object CreateTerrain(WarpRenderer renderer, bool textureTerrain) { ITerrainChannel terrain = m_scene.RequestModuleInterface <ITerrainChannel> (); float diffX = 1.0f; //(float) m_scene.RegionInfo.RegionSizeX/(float) Constants.RegionSize; float diffY = 1.0f; //(float) m_scene.RegionInfo.RegionSizeY/(float) Constants.RegionSize; int newRsX = m_scene.RegionInfo.RegionSizeX / (int)diffX; int newRsY = m_scene.RegionInfo.RegionSizeY / (int)diffY; warp_Object obj = new warp_Object(newRsX * newRsY, ((newRsX - 1) * (newRsY - 1) * 2)); for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diffY) { for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diffX) { float t_height = terrain [(int)x, (int)y]; float waterHeight = (float)m_scene.RegionInfo.RegionSettings.WaterHeight; //clamp to eliminate artifacts t_height = Utils.Clamp(t_height, waterHeight - 0.5f, waterHeight + 0.5f); if (t_height < 0.0f) { t_height = 0.0f; } warp_Vector pos = ConvertVector(x / diffX, y / diffY, t_height); obj.addVertex( new warp_Vertex(pos, x / m_scene.RegionInfo.RegionSizeX, (m_scene.RegionInfo.RegionSizeY - y) / (m_scene.RegionInfo.RegionSizeY))); } } const float normal_map_reduction = 2.0f; //2.0f-2.5f is the sweet spot for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diffY) { for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diffX) { float newX = x / diffX; float newY = y / diffY; if (newX < newRsX - 1 && newY < newRsY - 1) { int v = (int)(newY * newRsX + newX); // Normal Vector3 v1 = new Vector3(newX, newY, (terrain [(int)x, (int)y]) / normal_map_reduction); Vector3 v2 = new Vector3(newX + 1, newY, (terrain [(int)x + 1, (int)y]) / normal_map_reduction); Vector3 v3 = new Vector3(newX, newY + 1, (terrain [(int)x, (int)(y + 1)]) / normal_map_reduction); warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3)); norm = norm.reverse(); obj.vertex(v).n = norm; // Triangle 1 obj.addTriangle( v, v + 1, v + newRsX); // Triangle 2 obj.addTriangle( v + newRsX + 1, v + newRsX, v + 1); } } } renderer.Scene.addObject("Terrain", obj); renderer.Scene.sceneobject("Terrain").setPos(0.0f, 0.0f, 0.0f); UUID [] textureIDs = new UUID [4]; float [] startHeights = new float [4]; float [] heightRanges = new float [4]; RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings; textureIDs [0] = regionInfo.TerrainTexture1; textureIDs [1] = regionInfo.TerrainTexture2; textureIDs [2] = regionInfo.TerrainTexture3; textureIDs [3] = regionInfo.TerrainTexture4; startHeights [0] = (float)regionInfo.Elevation1SW; startHeights [1] = (float)regionInfo.Elevation1NW; startHeights [2] = (float)regionInfo.Elevation1SE; startHeights [3] = (float)regionInfo.Elevation1NE; heightRanges [0] = (float)regionInfo.Elevation2SW; heightRanges [1] = (float)regionInfo.Elevation2NW; heightRanges [2] = (float)regionInfo.Elevation2SE; heightRanges [3] = (float)regionInfo.Elevation2NE; uint globalX, globalY; Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY); Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges, new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain); warp_Texture texture = new warp_Texture(image); warp_Material material = new warp_Material(texture); material.setReflectivity(0); // reduces tile seams a bit thanks lkalif renderer.Scene.addMaterial("TerrainColor", material); renderer.SetObjectMaterial("Terrain", "TerrainColor"); image.Dispose(); return(obj); }
public void OnGUI() { scrollPos = EditorGUILayout.BeginScrollView(scrollPos, false, false); GUIContent[] mainMenu = new GUIContent[4]; mainMenu[0] = new GUIContent("File"); mainMenu[1] = new GUIContent("Prefabs"); mainMenu[2] = new GUIContent("Layers"); mainMenu[3] = new GUIContent("Advanced"); EditorGUI.BeginChangeCheck(); mainMenuOptions = GUILayout.Toolbar(mainMenuOptions, mainMenu, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck() && mainMenuOptions == 2) { Functions.SetLandLayer((LandLayers)layerIndex); } #region Menu switch (mainMenuOptions) { #region File case 0: Functions.EditorIO(); Functions.EditorInfo(); Functions.MapInfo(); Functions.EditorLinks(); Functions.EditorSettings(); break; #endregion #region Prefabs case 1: GUIContent[] prefabsOptionsMenu = new GUIContent[2]; prefabsOptionsMenu[0] = new GUIContent("Asset Bundle"); prefabsOptionsMenu[1] = new GUIContent("Prefab Tools"); prefabOptions = GUILayout.Toolbar(prefabOptions, prefabsOptionsMenu, EditorStyles.toolbarButton); switch (prefabOptions) { case 0: Functions.AssetBundle(); break; case 1: Functions.PrefabTools(ref deletePrefabs, prefabSaveFile, mapPrefabSaveFile); break; } break; #endregion #region Layers case 2: GUIContent[] layersOptionsMenu = new GUIContent[4]; layersOptionsMenu[0] = new GUIContent("Ground"); layersOptionsMenu[1] = new GUIContent("Biome"); layersOptionsMenu[2] = new GUIContent("Alpha"); layersOptionsMenu[3] = new GUIContent("Topology"); EditorGUI.BeginChangeCheck(); layerIndex = GUILayout.Toolbar(layerIndex, layersOptionsMenu, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck()) { Functions.SetLandLayer((LandLayers)layerIndex, TerrainTopology.TypeToIndex((int)layers.Topologies)); } switch (layerIndex) { case 0: Functions.TextureSelect((LandLayers)layerIndex, ref layers); Functions.AreaSelect(); Functions.LayerTools((LandLayers)layerIndex, TerrainSplat.TypeToIndex((int)layers.Ground)); Functions.RotateTools((LandLayers)layerIndex); Functions.RiverTools((LandLayers)layerIndex, TerrainSplat.TypeToIndex((int)layers.Ground), ref aboveTerrain); Functions.SlopeTools((LandLayers)layerIndex, TerrainSplat.TypeToIndex((int)layers.Ground), ref slopesInfo); Functions.HeightTools((LandLayers)layerIndex, TerrainSplat.TypeToIndex((int)layers.Ground), ref heightsInfo); break; case 1: Functions.TextureSelect((LandLayers)layerIndex, ref layers); Functions.AreaSelect(); Functions.LayerTools((LandLayers)layerIndex, TerrainBiome.TypeToIndex((int)layers.Biome)); Functions.RotateTools((LandLayers)layerIndex); Functions.RiverTools((LandLayers)layerIndex, TerrainBiome.TypeToIndex((int)layers.Biome), ref aboveTerrain); Functions.SlopeTools((LandLayers)layerIndex, TerrainBiome.TypeToIndex((int)layers.Biome), ref slopesInfo); Functions.HeightTools((LandLayers)layerIndex, TerrainBiome.TypeToIndex((int)layers.Biome), ref heightsInfo); break; case 2: Functions.LayerTools((LandLayers)layerIndex, 0, 1); Functions.AreaSelect(); Functions.RotateTools((LandLayers)layerIndex); Functions.RiverTools((LandLayers)layerIndex, 0, ref aboveTerrain, 1); Functions.SlopeTools((LandLayers)layerIndex, 0, ref slopesInfo, 1); Functions.HeightTools((LandLayers)layerIndex, 0, ref heightsInfo, 1); break; case 3: Functions.TopologyLayerSelect(ref layers); Functions.AreaSelect(); Functions.LayerTools((LandLayers)layerIndex, 0, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.RotateTools((LandLayers)layerIndex, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.TopologyTools(); Functions.RiverTools((LandLayers)layerIndex, 0, ref aboveTerrain, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.SlopeTools((LandLayers)layerIndex, 0, ref slopesInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); Functions.HeightTools((LandLayers)layerIndex, 0, ref heightsInfo, 1, TerrainTopology.TypeToIndex((int)layers.Topologies)); break; } break; #endregion #region Advanced case 3: GUIContent[] advancedOptionsMenu = new GUIContent[2]; advancedOptionsMenu[0] = new GUIContent("Generation"); advancedOptionsMenu[1] = new GUIContent("Map Tools"); EditorGUI.BeginChangeCheck(); advancedOptions = GUILayout.Toolbar(advancedOptions, advancedOptionsMenu, EditorStyles.toolbarButton); if (EditorGUI.EndChangeCheck() && advancedOptions == 0) { MapManager.RefreshPresetsList(); } switch (advancedOptions) { #region Generation case 0: Functions.NodePresets(presetScrollPos); break; #endregion #region Map Tools case 1: GUIContent[] mapToolsMenu = new GUIContent[3]; mapToolsMenu[0] = new GUIContent("HeightMap"); mapToolsMenu[1] = new GUIContent("Textures"); mapToolsMenu[2] = new GUIContent("Misc"); mapToolsOptions = GUILayout.Toolbar(mapToolsOptions, mapToolsMenu, EditorStyles.toolbarButton); switch (mapToolsOptions) { #region HeightMap case 0: GUIContent[] heightMapMenu = new GUIContent[2]; heightMapMenu[0] = new GUIContent("Heights"); heightMapMenu[1] = new GUIContent("Filters"); heightMapOptions = GUILayout.Toolbar(heightMapOptions, heightMapMenu, EditorStyles.toolbarButton); switch (heightMapOptions) { case 0: Elements.BoldLabel(ToolTips.heightsLabel); Functions.OffsetMap(ref offset, ref clampOffset); Functions.SetHeight(ref heightSet); Functions.ClampHeight(ref heightLow, ref heightHigh); Elements.BoldLabel(ToolTips.miscLabel); Functions.InvertMap(); break; case 1: Functions.NormaliseMap(ref normaliseLow, ref normaliseHigh, ref autoUpdate); Functions.SmoothMap(ref filterStrength, ref blurDirection, ref smoothPasses); Functions.TerraceMap(ref terraceErodeFeatureSize, ref terraceErodeInteriorCornerWeight); break; } break; #endregion #region Textures case 1: Functions.ConditionalPaint(ref conditionalPaintOptions, ref texture, ref conditions, ref layers); break; #endregion #region Misc case 2: Functions.RotateMap(ref rotateSelection); break; #endregion } break; #endregion } break; #endregion } #endregion EditorGUILayout.EndScrollView(); }
private void CreateTerrain(WarpRenderer renderer, bool textureTerrain) { ITerrainChannel terrain = m_scene.RequestModuleInterface <ITerrainChannel>(); warp_Object obj = new warp_Object(m_scene.RegionInfo.RegionSizeX * m_scene.RegionInfo.RegionSizeY, (m_scene.RegionInfo.RegionSizeX - 1) * (m_scene.RegionInfo.RegionSizeY - 1) * 2); for (int y = 0; y < m_scene.RegionInfo.RegionSizeY; y++) { for (int x = 0; x < m_scene.RegionInfo.RegionSizeX; x++) { float height = terrain[x, y]; warp_Vector pos = ConvertVector(new Vector3(x, y, height)); obj.addVertex(new warp_Vertex(pos, (float)x / (m_scene.RegionInfo.RegionSizeX - 1), (float)((m_scene.RegionInfo.RegionSizeX - 1) - y) / (m_scene.RegionInfo.RegionSizeX - 1))); } } for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += 1) { for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += 1) { if (x < m_scene.RegionInfo.RegionSizeX - 1 && y < m_scene.RegionInfo.RegionSizeY - 1) { float v = y * m_scene.RegionInfo.RegionSizeX + x; // Normal warp_Vector norm = new warp_Vector(x, y, terrain.GetNormalizedGroundHeight((int)x, (int)y)); norm = norm.reverse(); obj.vertex((int)v).n = norm; // Triangle 1 obj.addTriangle( (int)v, (int)v + 1, (int)v + m_scene.RegionInfo.RegionSizeX); // Triangle 2 obj.addTriangle( (int)v + m_scene.RegionInfo.RegionSizeX + 1, (int)v + m_scene.RegionInfo.RegionSizeX, (int)v + 1); } } } renderer.Scene.addObject("Terrain", obj); UUID[] textureIDs = new UUID[4]; float[] startHeights = new float[4]; float[] heightRanges = new float[4]; RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings; textureIDs[0] = regionInfo.TerrainTexture1; textureIDs[1] = regionInfo.TerrainTexture2; textureIDs[2] = regionInfo.TerrainTexture3; textureIDs[3] = regionInfo.TerrainTexture4; startHeights[0] = (float)regionInfo.Elevation1SW; startHeights[1] = (float)regionInfo.Elevation1NW; startHeights[2] = (float)regionInfo.Elevation1SE; startHeights[3] = (float)regionInfo.Elevation1NE; heightRanges[0] = (float)regionInfo.Elevation2SW; heightRanges[1] = (float)regionInfo.Elevation2NW; heightRanges[2] = (float)regionInfo.Elevation2SE; heightRanges[3] = (float)regionInfo.Elevation2NE; uint globalX, globalY; Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY); Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges, new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain); warp_Texture texture = new warp_Texture(image); warp_Material material = new warp_Material(texture); material.setReflectivity(50); renderer.Scene.addMaterial("TerrainColor", material); renderer.SetObjectMaterial("Terrain", "TerrainColor"); }
private warp_Object CreateTerrain(WarpRenderer renderer, bool textureTerrain) { ITerrainChannel terrain = m_scene.RequestModuleInterface <ITerrainChannel>(); float diff = (float)m_scene.RegionInfo.RegionSizeY / (float)Constants.RegionSize; warp_Object obj = new warp_Object(Constants.RegionSize * Constants.RegionSize, ((Constants.RegionSize - 1) * (Constants.RegionSize - 1) * 2)); for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff) { for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff) { warp_Vector pos = ConvertVector(x, y, terrain[(int)x, (int)y]); obj.addVertex(new warp_Vertex(pos, x / (float)(m_scene.RegionInfo.RegionSizeX), (((float)m_scene.RegionInfo.RegionSizeX) - y) / (m_scene.RegionInfo.RegionSizeX))); } } for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff) { for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff) { float newX = x / diff; float newY = y / diff; if (newX < Constants.RegionSize - 1 && newY < Constants.RegionSize - 1) { int v = (int)(newY * Constants.RegionSize + newX); // Normal Vector3 v1 = new Vector3(newX, newY, (terrain[(int)x, (int)y]) / Constants.TerrainCompression); Vector3 v2 = new Vector3(newX + 1, newY, (terrain[(int)x + 1, (int)y]) / Constants.TerrainCompression); Vector3 v3 = new Vector3(newX, newY + 1, (terrain[(int)x, (int)(y + 1)]) / Constants.TerrainCompression); warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3)); norm = norm.reverse(); obj.vertex(v).n = norm; // Triangle 1 obj.addTriangle( v, v + 1, v + Constants.RegionSize); // Triangle 2 obj.addTriangle( v + Constants.RegionSize + 1, v + Constants.RegionSize, v + 1); } } } renderer.Scene.addObject("Terrain", obj); UUID[] textureIDs = new UUID[4]; float[] startHeights = new float[4]; float[] heightRanges = new float[4]; RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings; textureIDs[0] = regionInfo.TerrainTexture1; textureIDs[1] = regionInfo.TerrainTexture2; textureIDs[2] = regionInfo.TerrainTexture3; textureIDs[3] = regionInfo.TerrainTexture4; startHeights[0] = (float)regionInfo.Elevation1SW; startHeights[1] = (float)regionInfo.Elevation1NW; startHeights[2] = (float)regionInfo.Elevation1SE; startHeights[3] = (float)regionInfo.Elevation1NE; heightRanges[0] = (float)regionInfo.Elevation2SW; heightRanges[1] = (float)regionInfo.Elevation2NW; heightRanges[2] = (float)regionInfo.Elevation2SE; heightRanges[3] = (float)regionInfo.Elevation2NE; uint globalX, globalY; Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY); Bitmap image = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges, new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain); warp_Texture texture = new warp_Texture(image); warp_Material material = new warp_Material(texture); material.setReflectivity(0); // reduces tile seams a bit thanks lkalif renderer.Scene.addMaterial("TerrainColor", material); renderer.SetObjectMaterial("Terrain", "TerrainColor"); return(obj); }
public int GetSplatMaxType(int x, int z, int mask = -1) { return(TerrainSplat.IndexToType(this.GetSplatMaxIndex(x, z, mask))); }
public int GetSplatMaxType(float normX, float normZ, int mask = -1) { return(TerrainSplat.IndexToType(this.GetSplatMaxIndex(normX, normZ, mask))); }
public int GetSplatMaxType(Vector3 worldPos, int mask = -1) { return(TerrainSplat.IndexToType(this.GetSplatMaxIndex(worldPos, mask))); }
public static void ConditionalPaintConditions(ref Conditions cnds, ref int cndsOptions) { Elements.BoldLabel(ToolTips.conditionalPaintLabel); GUIContent[] conditionalPaintMenu = new GUIContent[5]; conditionalPaintMenu[0] = new GUIContent("Ground"); conditionalPaintMenu[1] = new GUIContent("Biome"); conditionalPaintMenu[2] = new GUIContent("Alpha"); conditionalPaintMenu[3] = new GUIContent("Topology"); conditionalPaintMenu[4] = new GUIContent("Terrain"); cndsOptions = GUILayout.Toolbar(cndsOptions, conditionalPaintMenu, EditorStyles.toolbarButton); Elements.MiniBoldLabel(ToolTips.conditionsLabel); switch (cndsOptions) { case 0: // Ground Elements.BeginToolbarHorizontal(); cnds.GroundConditions.CheckLayer[TerrainSplat.TypeToIndex((int)cnds.GroundConditions.Layer)] = Elements.ToolbarToggle(ToolTips.checkTexture, cnds.GroundConditions.CheckLayer[TerrainSplat.TypeToIndex((int)cnds.GroundConditions.Layer)]); cnds.GroundConditions.Layer = (TerrainSplat.Enum)Elements.ToolbarEnumPopup(cnds.GroundConditions.Layer); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); cnds.GroundConditions.Weight[TerrainSplat.TypeToIndex((int)cnds.GroundConditions.Layer)] = Elements.ToolbarSlider(ToolTips.conditionalTextureWeight, cnds.GroundConditions.Weight[TerrainSplat.TypeToIndex((int)cnds.GroundConditions.Layer)], 0.01f, 1f); Elements.EndToolbarHorizontal(); break; case 1: // Biome Elements.BeginToolbarHorizontal(); cnds.BiomeConditions.CheckLayer[TerrainBiome.TypeToIndex((int)cnds.BiomeConditions.Layer)] = Elements.ToolbarToggle(ToolTips.checkTexture, cnds.BiomeConditions.CheckLayer[TerrainBiome.TypeToIndex((int)cnds.BiomeConditions.Layer)]); cnds.BiomeConditions.Layer = (TerrainBiome.Enum)Elements.ToolbarEnumPopup(cnds.BiomeConditions.Layer); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); cnds.BiomeConditions.Weight[TerrainBiome.TypeToIndex((int)cnds.BiomeConditions.Layer)] = Elements.ToolbarSlider(ToolTips.conditionalTextureWeight, cnds.BiomeConditions.Weight[TerrainBiome.TypeToIndex((int)cnds.BiomeConditions.Layer)], 0.01f, 1f); Elements.EndToolbarHorizontal(); break; case 2: // Alpha Elements.BeginToolbarHorizontal(); cnds.AlphaConditions.CheckAlpha = Elements.ToolbarToggle(ToolTips.checkTexture, cnds.AlphaConditions.CheckAlpha); cnds.AlphaConditions.Texture = (AlphaTextures)Elements.ToolbarEnumPopup(cnds.AlphaConditions.Texture); Elements.EndToolbarHorizontal(); break; case 3: // Topology Elements.BeginToolbarHorizontal(); cnds.TopologyConditions.CheckLayer[TerrainTopology.TypeToIndex((int)cnds.TopologyConditions.Layer)] = Elements.ToolbarToggle(ToolTips.checkTopologyLayer, cnds.TopologyConditions.CheckLayer[TerrainTopology.TypeToIndex((int)cnds.TopologyConditions.Layer)]); cnds.TopologyConditions.Layer = (TerrainTopology.Enum)Elements.ToolbarEnumPopup(cnds.TopologyConditions.Layer); Elements.EndToolbarHorizontal(); Elements.BeginToolbarHorizontal(); Elements.ToolbarLabel(ToolTips.checkTexture); cnds.TopologyConditions.Texture[TerrainTopology.TypeToIndex((int)cnds.TopologyConditions.Layer)] = (TopologyTextures)Elements.ToolbarEnumPopup(cnds.TopologyConditions.Texture[TerrainTopology.TypeToIndex((int)cnds.TopologyConditions.Layer)]); Elements.EndToolbarHorizontal(); break; case 4: // Terrain float tempSlopeLow = cnds.TerrainConditions.Slopes.SlopeLow, tempSlopeHigh = cnds.TerrainConditions.Slopes.SlopeHigh; cnds.TerrainConditions.CheckSlopes = Elements.ToolbarToggleMinMax(ToolTips.checkSlopes, ToolTips.rangeLow, ToolTips.rangeHigh, cnds.TerrainConditions.CheckSlopes, ref tempSlopeLow, ref tempSlopeHigh, 0f, 90f); cnds.TerrainConditions.Slopes.SlopeLow = tempSlopeLow; cnds.TerrainConditions.Slopes.SlopeHigh = tempSlopeHigh; float tempHeightLow = cnds.TerrainConditions.Heights.HeightLow, tempHeightHigh = cnds.TerrainConditions.Heights.HeightHigh; cnds.TerrainConditions.CheckHeights = Elements.ToolbarToggleMinMax(ToolTips.checkHeights, ToolTips.rangeLow, ToolTips.rangeHigh, cnds.TerrainConditions.CheckHeights, ref tempHeightLow, ref tempHeightHigh, 0f, 1000f); cnds.TerrainConditions.Heights.HeightLow = tempHeightLow; cnds.TerrainConditions.Heights.HeightHigh = tempHeightHigh; break; } }
public SplatMask(IConverter <Vector2Int, Vector3> coordinateConverter, int splatIndex) { _coordinateConverter = coordinateConverter; _splatType = TerrainSplat.IndexToType(splatIndex); }