procedurally एक क्षेत्र जाल

Question

मैं एक एल्गोरिथ्म (छद्म कोड में) रहा हूँ उत्पन्न उत्पन्न करता है कि एक क्षेत्र की 3 डी निर्देशांक इस तरह जाल:

क्षैतिज और पार्श्व स्लाइस की संख्या विन्यास होना चाहिए

Answer 1

अगर वहाँ अक्षांश के एम लाइनों (क्षैतिज) कर रहे हैं और देशांतर के एन लाइनों (ऊर्ध्वाधर), तो

(एक्स, वाई, जेड) पर डॉट्स डाल = (पाप (पी * एम/एम) cos (2 पीआई * एन/एन), पाप (पीआई * एम/एम) पाप (2 पीआई * एन/एन), कॉस (पीआई * एम/एम))

प्रत्येक मीटर के लिए {0, ..., एम} में और एन {0, ..., एन -1} में और डॉट्स के बीच रेखा खंड खींचें, तदनुसार।

संपादित करें: शायद, 1 या 2 के रूप में आवश्यक द्वारा एम समायोजित क्योंकि आप तय करना चाहिए या नहीं, डंडे

Answer 2

सिर्फ एक अनुमान, तो आप शायद एक क्षेत्र (0,0,0)

x²+y²+z²=1 

पर केन्द्रित करने के लिए सूत्र इस्तेमाल कर सकते हैं के लिए इस का समाधान एक्स, फिर लूप throuh y और z के लिए मानों का एक सेट throuh और उन्हें अपने गणना x के साथ साजिश।

Answer 3

यह सिर्फ परीक्षण के बिना मेरे सिर के ऊपर से है पर "अक्षांश लाइनों" गिनती करने के लिए। यह एक अच्छा प्रारंभिक बिंदु हो सकता है। यदि आप डबल का उपयोग करते हैं तो यह आपको सबसे सटीक और अनुकूलन योग्य परिणाम देगा।

public void generateSphere(3DPoint center, 3DPoint northPoint, int longNum, int latNum){ 
    //Find radius using simple length equation (distance between center and northPoint) 

    //Find southPoint using radius. 

    //Cut the line segment from northPoint to southPoint into the latitudinal number 
    //These will be the number of horizontal slices (ie. equator) 

    //Then divide 360 degrees by the longitudinal number to find the number of vertical slices. 

    //Use trigonometry to determine the angle and then the curcumference point for each circle starting from the top. 

    //Stores these points in however format you want and return the data structure. 

} 

Answer 4

यह ऊपर उत्तर के लिए एक काम कर रहे सी # कोड है:

using UnityEngine; 

[RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] 
public class ProcSphere : MonoBehaviour 
{ 

    private Mesh mesh; 
    private Vector3[] vertices; 

    public int horizontalLines, verticalLines; 
    public int radius; 

    private void Awake() 
    { 
     GetComponent<MeshFilter>().mesh = mesh = new Mesh(); 
     mesh.name = "sphere"; 
     vertices = new Vector3[horizontalLines * verticalLines]; 
     int index = 0; 
     for (int m = 0; m < horizontalLines; m++) 
     { 
      for (int n = 0; n < verticalLines - 1; n++) 
      { 
       float x = Mathf.Sin(Mathf.PI * m/horizontalLines) * Mathf.Cos(2 * Mathf.PI * n/verticalLines); 
       float y = Mathf.Sin(Mathf.PI * m/horizontalLines) * Mathf.Sin(2 * Mathf.PI * n/verticalLines); 
       float z = Mathf.Cos(Mathf.PI * m/horizontalLines); 
       vertices[index++] = new Vector3(x, y, z) * radius; 
      } 
     } 
     mesh.vertices = vertices; 
    } 

    private void OnDrawGizmos() 
    { 
     if (vertices == null) { 
      return; 
     } 
     for (int i = 0; i < vertices.Length; i++) { 
      Gizmos.color = Color.black; 
      Gizmos.DrawSphere(transform.TransformPoint(vertices[i]), 0.1f); 
     } 
    } 
}