एंड्रॉइड बनावट क्षेत्र

Question

मैं एंड्रॉइड पर पृथ्वी ग्लोब बनाना चाहता हूं। इस बिंदु पर मुझे यूवी बनावट निर्देशांक के साथ मदद की ज़रूरत है। मैं इस धरती बनावट (kibotu.net/earth.jpg) का उपयोग कर रहा हूँ। वर्तमान में यह इस फ्रंट साइड (kibotu.net/earthsphere.png) जैसा दिखता है, लेकिन 9 0 डिग्री घुमाया गया यह इस तरह दिखता है (kibotu.net/earthsphere2.png)।

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

मेरा पहला दृष्टिकोण ब्लेंडर का उपयोग करना था और इसे ओबीजे फ़ाइल के रूप में निर्यात करना था और इसे मेरे आवेदन में लोड करना था। हालांकि 2 दुष्प्रभाव हैं: पूरी तरह अजीब दिखने वाले मानक (kibotu.net/sphere.png) और सबसे महत्वपूर्ण रूप से कोई बनावट निर्देशांक नहीं है। (इन ब्लेंडर निर्यात विकल्प मैं का उपयोग किया है [kibotu.net/blenderobjoptions.png])

मेरे दूसरे प्रयास freeglut पुस्तकालय का उपयोग करने के काम करने के लिए गया था। अब मुझे एक अच्छा दिखने वाला क्षेत्र मिला है (kibotu.net/sphere5.png)। हालांकि कोई बनावट निर्देशांक नहीं हैं। चूंकि यह अंतिम संस्करण 27 नवंबर 200 9 को जारी किया गया था, इसलिए मुझे बहुत संदेह है कि जल्द ही कोई अपडेट अपडेट होगा।

तो उसके बाद मैंने wiki approach to calculate sphere uvs लागू करने का प्रयास किया है। हालांकि यह इस kibotu.net/sphere2.png की तरह लग रहा था। मैं इस समस्या के बाद हर एक स्टैक ओवरफ्लो थ्रेड खोज रहा था और this uv approach पर आया था। हालांकि कोई अंतिम समाधान नहीं है। मैंने इसे फ्रीग्लूट कोड पर लागू किया है।

static private FloatBuffer sphereVertex; 
static private FloatBuffer sphereNormal; 
static private FloatBuffer sphereTexture; 
static float sphere_parms[]=new float[3]; 
private static void plotSpherePoints(float radius, int stacks, int slices) 
{ 
    sphereVertex = OpenGLUtils.allocateFloatBuffer(4* 6 * stacks * (slices+1)); 
    sphereNormal = OpenGLUtils.allocateFloatBuffer(4* 6 * stacks * (slices+1)); 
    sphereTexture = OpenGLUtils.allocateFloatBuffer(4* 4 * stacks * (slices+1)); 

    int i, j; 
    float slicestep, stackstep; 

    stackstep = ((float)Math.PI)/stacks; 
    slicestep = 2.0f * ((float)Math.PI)/slices; 

    int counter = 0; 

    for (i = 0; i < stacks; ++i) { 
     float a = i * stackstep; 
     float b = a + stackstep; 

     float s0 = (float)Math.sin(a); 
     float s1 = (float)Math.sin(b); 

     float c0 = (float)Math.cos(a); 
     float c1 = (float)Math.cos(b); 

     float nv,u,v,dx,dy,dz; 
     for (j = 0; j <= slices; ++j)  
     { 
      float c = j * slicestep; 
      float x = (float)Math.cos(c); 
      float y = (float)Math.sin(c); 

      nv=x * s0; 
      sphereNormal.put(nv); 
      sphereVertex.put(dx = nv * radius); 

      nv=y * s0; 
      sphereNormal.put(nv); 
      sphereVertex.put(dy = nv * radius); 

      nv=c0; 

      sphereNormal.put(nv); 
      sphereVertex.put(dz = nv * radius); 
      // uv 1 
      if (dz < 0) 
       u = (float) (1 + dx/Math.sqrt(dx*dx+dy*dy+dz*dz)/4); 
      else 
       u = (float) (1 - (1 + dx/Math.sqrt(dx*dx+dy*dy+dz*dz))/4); 

      v = (float) (0.5 + (-dy/Math.sqrt(dx*dx+dy*dy+dz*dz)) /2); 

      // u = (float) (dx/Math.sqrt(dx*dx + dy*dy +dz*dz)); 
      // v = (float) (dy/Math.sqrt(dx*dx + dy*dy +dz*dz)); 
      sphereTexture.put(u); 
      sphereTexture.put(v); 

      nv=x * s1; 

      sphereNormal.put(nv); 
      sphereVertex.put(dx = nv * radius); 

      nv=y * s1; 

      sphereNormal.put(nv); 
      sphereVertex.put(dy = nv * radius); 

      nv=c1; 

      sphereNormal.put(nv); 
      sphereVertex.put(dz = nv * radius); 

      // uv 2 
      if (dz < 0) 
       u = (float) (1 + dx/Math.sqrt(dx*dx+dy*dy+dz*dz)/4); 
      else 
       u = (float) (1 - (1 + dx/Math.sqrt(dx*dx+dy*dy+dz*dz))/4); 

      v = (float) (0.5 + (-dy/Math.sqrt(dx*dx+dy*dy+dz*dz)) /2); 

      sphereTexture.put(u); 
      sphereTexture.put(v); 
     } 
    } 
    sphereNormal.position(0); 
    sphereVertex.position(0); 
    sphereTexture.position(0); 
} 

और ड्राइंग एल्गोरिथ्म:

public static class SolidSphere{ 
    public static void draw(GL10 gl,float radius, int slices, int stacks) 
    { 
     int i, triangles; 

     if (sphereVertex!=null) 
     { 
      if (sphere_parms[0] != radius || sphere_parms[1] != slices || sphere_parms[2] != stacks) 
      { 
       sphereVertex=null; 
       sphereNormal=null; 
       sphereTexture = null; 

       gl.glVertexPointer(3, GL10.GL_FLOAT, 0, OpenGLUtils.allocateFloatBuffer(0)); 
       gl.glNormalPointer(GL10.GL_FLOAT, 0, OpenGLUtils.allocateFloatBuffer(0)); 
       gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, OpenGLUtils.allocateFloatBuffer(0)); 
      } 
     } 

     if (sphereVertex==null) 
     { 
      sphere_parms[0] = radius; 
      sphere_parms[1] = (float)slices; 
      sphere_parms[2] = (float)stacks; 

      plotSpherePoints(radius, stacks, slices); 
     } 

     gl.glVertexPointer(3, GL10.GL_FLOAT, 0, sphereVertex); 
     gl.glNormalPointer(GL10.GL_FLOAT, 0, sphereNormal); 
     gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, sphereTexture); 

     gl.glEnableClientState (GL10.GL_VERTEX_ARRAY); 
     gl.glEnableClientState (GL10.GL_NORMAL_ARRAY); 
     gl.glEnableClientState (GL10.GL_TEXTURE_COORD_ARRAY); 

     triangles = (slices + 1) * 2; 
     for(i = 0; i < stacks; i++) 
      gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, i * triangles, triangles); 

     gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); 
     gl.glDisableClientState(GL10.GL_NORMAL_ARRAY); 
     gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY); 
    } 
} 

किसी को भी मदद कर सकते हैं मुझे इस पता लगाना कृपया?

Answer 1

आपको एक (इकाई) क्षेत्र के लिए कोई त्रिभुज जाल लेने में सक्षम होना चाहिए और वर्टेक्स (एक्स, वाई, जेड) से (यूवी) में मैपिंग लागू करना चाहिए।

मैं आपके कोड के माध्यम से जाने के लिए बहुत आलसी/व्यस्त हूं (जो भी चाहें हटाएं), लेकिन आपको वाट & वाट के "उन्नत एनिमेशन और रेंडरिंग तकनीक" के अध्याय 6 में जवाब मिल सकता है। यह गोलाकारों के लिए उपयुक्त यूवी कॉर्ड बनाने के लिए कुछ सरल दृष्टिकोण देता है।

आईआईआरसी, ध्रुवों पर बहुत अधिक विरूपण से बचने के लिए, उनकी मैपिंग अक्षांश मैपिंग को निचोड़ने/खींचने के लिए साइन का उपयोग करती है।