यूनिटी 3 डी

Question

में प्रक्रियात्मक इलाके प्रोग्रामिंग मैं प्रक्रियात्मक पीढ़ी के साथ मिलकर प्रयास करने की कोशिश कर रहा हूं, मैं निश्चित रूप से एकता में समर्थक नहीं हूं, हालांकि मैं इस गाइड का पालन कर रहा था: click और कुछ परिणाम प्राप्त हुए। अभी के लिए मुझे 2 समस्याएं हैं, मेरे पास कुछ बुनियादी विचार है कि उन्हें कैसे हल किया जाए, हालांकि मैं कुछ और राय सुनना चाहता हूं।

(मैंने पहले ही इस सवाल को एकता जवाब पर पोस्ट कर दिया है, हालांकि मुझे कुछ जवाब नहीं मिला है, अगर कुछ गुम जानकारी है या कुछ शब्दों में व्याख्या करना असंभव है, तो कृपया मुझे बताएं या कुछ सलाह दें मात्रा के बीच अंतराल: यह जानकारी प्राप्त करने के लिए)

मुख्य मुद्दा है

वे थोड़े गायब हो जाते हैं अगर मैं ज़ूम जाएगा, हालांकि बनावट अयोग्य रहते हैं और यह उल्लेखनीय है।

दूसरा, जैसा कि आप देख सकते हैं कि मुझे लाल रंग में समस्या है (मुझे वास्तव में यह नहीं पता कि इसे कैसे कॉल करें) जमीन पर अंक। मैंने गाइड से सामग्री का उपयोग करने की कोशिश की है, लेकिन एक ही प्रभाव मिला है।

इसके अलावा, पर्लिन शोर (मुझे पता है कि मैं डायमंड स्क्वायर या सरल का उपयोग कर सकता हूं) छद्म-यादृच्छिक एल्गोरिदम है, इसलिए यह उसी इनपुट पैरामीटर के लिए समान मान वापस कर देगा, तो इसका मतलब यह है कि मेरे भाग हमेशा रहेगा वही?

मेरे कोड (मैं गाइड से LibNoise पुस्तकालय का उपयोग कर रहा):

void Awake() 
    { 
     var settings = new TerrainChunkSettings(129, 129, 100, 40, FlatTexture, SteepTexture, TerrainMaterial); 
     var noiseProvider = new NoiseProvider(); 
     for (var i = 0; i < 4; i++) 
      for (var j = 0; j < 4; j++) 
       new TerrainChunk(settings, noiseProvider, i, j).CreateTerrain(); 
    } 
public class TerrainChunkSettings 
{ 
    public int HeightmapResolution { get; private set; } 

    public int AlphamapResolution { get; private set; } 

    public int Length { get; private set; } 

    public int Height { get; private set; } 

    public Texture2D FlatTexture { get; private set; } 

    public Texture2D SteepTexture { get; private set; } 

    public Material TerrainMaterial { get; private set; } 

    public TerrainChunkSettings(int heightmapResolution, int alphamapResolution, int length, int height, Texture2D flatTexture, Texture2D steepTexture, Material terrainMaterial) 
    { 
     HeightmapResolution = heightmapResolution; 
     AlphamapResolution = alphamapResolution; 
     Length = length; 
     Height = height; 
     FlatTexture = flatTexture; 
     SteepTexture = steepTexture; 
     TerrainMaterial = terrainMaterial; 
    } 
} 

public class TerrainChunk 
{ 
    private Terrain Terrain { get; set; } 

    private TerrainChunkSettings Settings { get; set; } 

    private NoiseProvider NoiseProvider { get; set; } 

    public int X { get; private set; } 

    public int Z { get; private set; } 

    private TerrainData Data { get; set; } 

    private float[,] Heightmap { get; set; } 
    public TerrainChunk(TerrainChunkSettings settings, NoiseProvider noiseProvider, int x, int z) 
    { 
     X = x; 
     Z = z; 
     Settings = settings; 
     NoiseProvider = noiseProvider; 
    } 

    public void CreateTerrain() 
    { 
     var terrainData = new TerrainData(); 
     terrainData.heightmapResolution = Settings.HeightmapResolution; 
     terrainData.alphamapResolution = Settings.AlphamapResolution; 

     var heightmap = GetHeightmap(); 
     terrainData.SetHeights(0, 0, heightmap); 
     ApplyTextures(terrainData); 
     terrainData.size = new Vector3(Settings.Length, Settings.Height, Settings.Length); 

     var newTerrainGameObject = Terrain.CreateTerrainGameObject(terrainData); 
     newTerrainGameObject.transform.position = new Vector3(X * Settings.Length, 0, Z * Settings.Length); 
     Terrain = newTerrainGameObject.GetComponent<Terrain>(); 
     Terrain.Flush(); 
    } 

    private float[,] GetHeightmap() 
    { 
     var heightmap = new float[Settings.HeightmapResolution, Settings.HeightmapResolution]; 

     for (var zRes = 0; zRes < Settings.HeightmapResolution; zRes++) 
     { 
      for (var xRes = 0; xRes < Settings.HeightmapResolution; xRes++) 
      { 
       var xCoordinate = X + (float)xRes/(Settings.HeightmapResolution - 1); 
       var zCoordinate = Z + (float)zRes/(Settings.HeightmapResolution - 1); 

       heightmap[zRes, xRes] = NoiseProvider.GetValue(xCoordinate, zCoordinate); 
      } 
     } 

     return heightmap; 
    } 

    private void ApplyTextures(TerrainData terrainData) 
    { 
     var flatSplat = new SplatPrototype(); 
     var steepSplat = new SplatPrototype(); 

     flatSplat.texture = Settings.FlatTexture; 
     steepSplat.texture = Settings.SteepTexture; 

     terrainData.splatPrototypes = new SplatPrototype[] 
     { 
      flatSplat, 
      steepSplat 
     }; 

     terrainData.RefreshPrototypes(); 

     var splatMap = new float[terrainData.alphamapResolution, terrainData.alphamapResolution, 2]; 

     for (var zRes = 0; zRes < terrainData.alphamapHeight; zRes++) 
     { 
      for (var xRes = 0; xRes < terrainData.alphamapWidth; xRes++) 
      { 
       var normalizedX = (float)xRes/(terrainData.alphamapWidth - 1); 
       var normalizedZ = (float)zRes/(terrainData.alphamapHeight - 1); 

       var steepness = terrainData.GetSteepness(normalizedX, normalizedZ); 
       var steepnessNormalized = Mathf.Clamp(steepness/1.5f, 0, 1f); 

       splatMap[zRes, xRes, 0] = 1f - steepnessNormalized; 
       splatMap[zRes, xRes, 1] = steepnessNormalized; 
      } 
     } 

     terrainData.SetAlphamaps(0, 0, splatMap); 
    } 
} 

public interface INoiseProvider 
{ 
    float GetValue(float x, float z); 
} 
public class NoiseProvider : INoiseProvider 
{ 
    private Perlin PerlinNoiseGenerator; 

    public NoiseProvider() 
    { 
     PerlinNoiseGenerator = new Perlin(); 
    } 

    public float GetValue(float x, float z) 
    { 
     return (float)(PerlinNoiseGenerator.GetValue(x, 0, z)/2f) + 0.5f; 
    } 
} 

Answer 1

1) मुख्य मुद्दा है: मात्रा

आप इलाके एक साथ सिलाई कर सकते हैं के बीच अंतराल वे SetNeighbors(Terrain left, Terrain top, Terrain right, Terrain bottom);

documentation:

से साथ एक ही LOD यह सुनिश्चित करने के लिए आप सेटअप की सुविधा देता है पड़ोसी इलाकों के बीच कनेक्शन।

यह सुनिश्चित करता है कि एलओडी पड़ोसी इलाकों पर मेल खाता है। ध्यान दें कि यह है जो इस फ़ंक्शन को एक टेरेन पर कॉल करने के लिए पर्याप्त नहीं है, आपको प्रत्येक इलाके के पड़ोसियों को सेट करने की आवश्यकता है।

2) दूसरा: जमीन

यह समस्या बनावट आप अपने इलाके वस्तु में उपयोग कर रहे हैं द्वारा की जानी चाहिए पर लाल निशान।

Answer 2

अंतराल होता है क्योंकि आप अलग अलग इलाके वस्तुओं बना रहे हैं। इलाकों का उपयोग करने का मुख्य बिंदु जाल का एक प्रक्रियात्मक टुकड़ा है जिसे आप फिट बैठते समय ऑप्टिमाइज़ कर सकते हैं।

इंजन अपने एलओडी को जितना दूर से कम कर देता है, उससे इलाकों को अनुकूलित करता है। इसका मतलब है कि दो पड़ोसी हिस्सों को दो अलग-अलग एलओडी मिल सकते हैं, प्रभावी रूप से इसका अर्थ है कि किसी के पास दूसरे के आधे कशेरुक संकल्प हैं, जो अंतराल का कारण बनता है। यदि आप नज़दीक ध्यान देते हैं तो आप देखेंगे कि वे हर दूसरे कशेरुक के साथ कैसे होते हैं। यह भी बंद हो जाता है क्योंकि आप किसी भी एलओडी को बंद नहीं करते हैं।

इंजन जिस तरह से हल करता है वह अतिरिक्त कशेरुक को इलाके के निचले-रिज़ॉल्यूशन हिस्से में सिलाई करके होता है। यह आपके मामले में ऐसा नहीं कर सकता है, हालांकि, क्योंकि अलग-अलग इलाके की वस्तुएं हैं और वे एक-दूसरे के अस्तित्व से अनजान हैं। समस्या को हल करने के लिए आप शायद क्या करना चाहते हैं, सभी छोटे इलाके वस्तुओं को एक बड़े इलाके में विलय करना है।