एंडेंगाइन: बनावट के साथ कस्टम इलाके

यहां लोगों ने एंड्रॉइड के लिए एक गेम लिखना शुरू किया और एंडेंगी में सामना किया (जो नहीं जानता, यह एंड्रॉइड के लिए सबसे लोकप्रिय डेस्कटॉप है। 2 डी इंजन) इस कार्य के साथ: इंटरकनेक्टेड लाइनों का एक सेट है जो परिदृश्य का प्रतिनिधित्व करता है (कैसे उत्पन्न करें, आप यहां पढ़ सकते हैं - gameprogrammer.com/fractal.html )। यह कुछ इस तरह देखा गया:



लेकिन हमें एक "पुल" की आवश्यकता नहीं है, हमें एक सतह की आवश्यकता है, और यहां तक ​​कि एक बनावट के साथ, सामान्य रूप से, ताकि यह हमारे जैसा हो ...




एंडग्विन खोदना शुरू किया, यह बनावट के साथ निकला कि वह केवल दो त्रिकोणों के स्प्राइट्स के साथ काम कर सकता है। यह हमें किसी भी तरह से सूट नहीं कर सकता है, क्योंकि हम पहले से परिदृश्य के आकार को नहीं जानते हैं, और इसलिए यूवी 1: 1 के अनुपात हमें चैनल नहीं करते हैं। और सिद्धांत रूप में, यहां हमारे पास स्प्राइट नहीं है, लेकिन सतह एक गैर-उत्तल पॉलीहेड्रॉन है। इसलिए, हमें अपनी बाइक लिखना होगा, क्योंकि googling ने मुख्य andengine शाखा के लिए सामान्य परिणाम नहीं दिए। यह अच्छा है कि उसके पास पर्याप्त वर्ग इंटरफेस है और सब कुछ तार्किक है, आपको बस यह पता लगाने की आवश्यकता है। हमें त्रिकोण और उनके संबंधित यूवी निर्देशांक के लिए शीर्ष बफर के साथ हमारे अपने वर्ग की आवश्यकता है। मुझे तुरंत यह कहना होगा कि मैं इस बात की व्याख्या नहीं करूंगा कि कई कार्यों को ओवरलोड क्यों नहीं किया जाता है और परिभाषा में कुछ चीजें क्यों की जाती हैं। स्थानों में, andengine वास्तुकला के संदर्भ में एक पूरी तरह से बुना हुआ जंगल है और मैंने सिर्फ उन चीजों को छोड़ दिया है जिनमें यह काम करता है, क्योंकि पूरे इंजन इंजन को छांटने में 10 ऐसे लेख और जीवन के आधे साल लगेंगे।
आइए जाने ...

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

हम उस वर्ग का वर्णन करना शुरू करते हैं जो हमारी सतह का प्रतिनिधित्व करेगा:

private abstract class GroundShape extends Shape { 

सुविधा के लिए, प्रत्येक शीर्ष के लिए एक ऑब्जेक्ट बनाएं जो अंतरिक्ष और यूवी में अपने दो-आयामी निर्देशांक संग्रहीत करता है।

  protected class Vertex { float x, y; float u, v; }; protected class MorphVertexBuffer extends VertexBuffer { public MorphVertexBuffer(int capacity) { //    ,  . super(capacity, GL11.GL_STATIC_DRAW, true); } //        . public void update(Vertex[] vertexes) { int j = 0; final float[] bufferData = new float[vertexes.length*2]; for (int i = 0; i < vertexes.length; ++i) { bufferData[j++] = vertexes[i].x; bufferData[j++] = vertexes[i].y; } final FastFloatBuffer buffer = this.getFloatBuffer(); buffer.position(0); buffer.put(bufferData); buffer.position(0);//,       :) super.setHardwareBufferNeedsUpdate(); } } [vertexes.length *  protected class Vertex { float x, y; float u, v; }; protected class MorphVertexBuffer extends VertexBuffer { public MorphVertexBuffer(int capacity) { //    ,  . super(capacity, GL11.GL_STATIC_DRAW, true); } //        . public void update(Vertex[] vertexes) { int j = 0; final float[] bufferData = new float[vertexes.length*2]; for (int i = 0; i < vertexes.length; ++i) { bufferData[j++] = vertexes[i].x; bufferData[j++] = vertexes[i].y; } final FastFloatBuffer buffer = this.getFloatBuffer(); buffer.position(0); buffer.put(bufferData); buffer.position(0);//,       :) super.setHardwareBufferNeedsUpdate(); } } 

ऊपर वर्णित आंतरिक वर्ग कि कोने कि इंजन फ़ीड कर सकते हैं के साथ एक बफर का प्रतिनिधित्व करता है। हम मानक आर्किटेक्चर में रहने और अद्यतन () विधि का वर्णन करने के लिए वर्टेक्सबफ़र से विरासत में प्राप्त करते हैं, जो वर्टेक्स बफर को पॉप्युलेट करता है।
अगला कदम एक प्रकार बनाना है जो यूवी समन्वय डेटा और एक बनावट मानचित्रण विधि के साथ एक बफर का वर्णन करता है।

  protected class MorphTexture extends BufferObject { //ITexture  ,    . final ITexture mTexture; public MorphTexture(ITexture tex, int pCapacity) { super(pCapacity, GL11.GL_STATIC_DRAW, true); mTexture = tex; } public void ApplyUV(Vertex [] vertexes) { final float[] bufferData = new float[vertexes.length*2]; for (int i = 0, j = 0; i < vertexes.length; ++i) { bufferData[j++] = vertexes[i].u; bufferData[j++] = vertexes[i].v; } final FastFloatBuffer buffer = this.getFloatBuffer(); buffer.position(0); buffer.put(bufferData); buffer.position(0);//,       :) super.setHardwareBufferNeedsUpdate(); } ;  protected class MorphTexture extends BufferObject { //ITexture  ,    . final ITexture mTexture; public MorphTexture(ITexture tex, int pCapacity) { super(pCapacity, GL11.GL_STATIC_DRAW, true); mTexture = tex; } public void ApplyUV(Vertex [] vertexes) { final float[] bufferData = new float[vertexes.length*2]; for (int i = 0, j = 0; i < vertexes.length; ++i) { bufferData[j++] = vertexes[i].u; bufferData[j++] = vertexes[i].v; } final FastFloatBuffer buffer = this.getFloatBuffer(); buffer.position(0); buffer.put(bufferData); buffer.position(0);//,       :) super.setHardwareBufferNeedsUpdate(); } [vertexes.length *  protected class MorphTexture extends BufferObject { //ITexture  ,    . final ITexture mTexture; public MorphTexture(ITexture tex, int pCapacity) { super(pCapacity, GL11.GL_STATIC_DRAW, true); mTexture = tex; } public void ApplyUV(Vertex [] vertexes) { final float[] bufferData = new float[vertexes.length*2]; for (int i = 0, j = 0; i < vertexes.length; ++i) { bufferData[j++] = vertexes[i].u; bufferData[j++] = vertexes[i].v; } final FastFloatBuffer buffer = this.getFloatBuffer(); buffer.position(0); buffer.put(bufferData); buffer.position(0);//,       :) super.setHardwareBufferNeedsUpdate(); } 

फिर हमने फिर से एक बफर का गठन किया जिसे हम इंजन को खिला सकते हैं।
निम्नलिखित उस फ़ंक्शन का वर्णन करता है जो ऑब्जेक्ट पर बनावट को "लागू करता है" और यूवी के कोनों के पॉइंटर बफर को सेट करता है जिसे हम ApplyUV () में गठित करते हैं।

  public void onApply(final GL10 pGL) { this.mTexture.bind(pGL);//   ,    glBindTexture() if(GLHelper.EXTENSIONS_VERTEXBUFFEROBJECTS) { final GL11 gl11 = (GL11)pGL; selectOnHardware(gl11); GLHelper.texCoordZeroPointer(gl11); } else { GLHelper.texCoordPointer(pGL, getFloatBuffer()); } } } 

इसके बाद, हम ऊपर वर्णित वर्णित शीर्ष और यूवी समन्वय बफर वस्तुओं को शुरू करते हैं।

  MorphVertexBuffer m_Buffer; MorphTexture m_TextureRegion; int vertexesLimit; //    . protected BitmapTextureAtlas m_Texture;//,     

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

  public GroundShape(BitmapTextureAtlas texture) { super(0, 0); m_Texture = texture; } 

अगला, हम आरंभीकरण फ़ंक्शन का वर्णन करते हैं जिसे शीर्ष क्रम बफ़र्स और यूवी निर्देशांक को आरम्भ करने के लिए वंश में बुलाया जाना चाहिए।

  protected void Init() { Vertex[] vertexes = buildVertexBuffer();//    . if (vertexes == null) return; //  . vertexesLimit = vertexes.length; m_Buffer = new MorphVertexBuffer(vertexesLimit*2); m_Buffer.update(vertexes); m_TextureRegion = new MorphTexture(m_Texture, vertexesLimit*2); m_TextureRegion.ApplyUV(vertexes); } 

क्योंकि ग्राउंडशैप - अमूर्त, हम वंशजों में बिल्डवेरटेक्सबफ़र फ़ंक्शन को ओवरलोड करना होगा, जिसमें हमें वर्टिस की सूची (यूवी निर्देशांक के साथ) बनाने और उन्हें वापस करने की आवश्यकता है। यहाँ वह है

  protected abstract Vertex[] buildVertexBuffer(); 

अगला कदम यह बताने के लिए ग्राउंडशैप तरीकों के एक जोड़े को अधिभार देना है कि हमारी सतह पर क्या और कैसे पेंट किया जाए।

  @Override protected void doDraw(final GL10 pGL, final Camera pCamera) { //  m_TextureRegion.onApply(pGL); // super.doDraw(pGL, pCamera); } @Override protected void onInitDraw(final GL10 pGL) { //           UV . //GLHelper - . super.onInitDraw(pGL); GLHelper.enableTextures(pGL); GLHelper.enableTexCoordArray(pGL); } @Override protected void drawVertices(GL10 pGL, Camera arg1) { //   . pGL.glDrawArrays(GL10.GL_TRIANGLES, 0, vertexesLimit); } , अंतिम कैमरा pCamera)  @Override protected void doDraw(final GL10 pGL, final Camera pCamera) { //  m_TextureRegion.onApply(pGL); // super.doDraw(pGL, pCamera); } @Override protected void onInitDraw(final GL10 pGL) { //           UV . //GLHelper - . super.onInitDraw(pGL); GLHelper.enableTextures(pGL); GLHelper.enableTexCoordArray(pGL); } @Override protected void drawVertices(GL10 pGL, Camera arg1) { //   . pGL.glDrawArrays(GL10.GL_TRIANGLES, 0, vertexesLimit); } कैमरा ARG1)  @Override protected void doDraw(final GL10 pGL, final Camera pCamera) { //  m_TextureRegion.onApply(pGL); // super.doDraw(pGL, pCamera); } @Override protected void onInitDraw(final GL10 pGL) { //           UV . //GLHelper - . super.onInitDraw(pGL); GLHelper.enableTextures(pGL); GLHelper.enableTexCoordArray(pGL); } @Override protected void drawVertices(GL10 pGL, Camera arg1) { //   . pGL.glDrawArrays(GL10.GL_TRIANGLES, 0, vertexesLimit); } 

अगर हम onApply कॉल करके doRaw में उपयोग किए जाने वाले UV निर्देशांक के कोने को इंगित करते हैं, तो त्रिकोणों के कोने को स्वयं इंगित करने के लिए हमें अतिरिक्त कार्यों को करने की आवश्यकता नहीं है, लेकिन बस getVertexBuffer को अधिभारित करें और शीर्ष बफर को लौटाएं।

  @Override protected VertexBuffer getVertexBuffer() { return m_Buffer; } 

निम्नलिखित कार्यों का वर्णन है जो केवल डिफ़ॉल्ट रूप से अतिभारित हैं और हमारे लिए कोई अर्थ नहीं है, हालांकि, वे विरासत प्रक्रिया में एक अनिवार्य हिस्सा हैं।

  @Override public boolean collidesWith(IShape arg0) { return false; } @Override public float getBaseHeight() { return 0; } @Override public float getBaseWidth() { return 0; } @Override public float getHeight() { return 0; } @Override public float getWidth() { return 0; } @Override public boolean contains(float arg0, float arg1) { return false; } @Override protected boolean isCulled(Camera arg0) { return false; } @Override protected void onUpdateVertexBuffer() { } } 

ठीक है, हमने एक वर्ग को स्केच किया है कि एंडग्विन यह बताता है कि त्रिकोण से मिलकर किसी भी "मॉडल" को कैसे तैयार किया जाए और एक बनावट हो। हालांकि यह एक 2D इंजन है, यह अभी भी OpenGL के माध्यम से काम करता है, बस स्प्राइट्स को दो त्रिकोणों पर खींचा जाता है।
वैसे, ध्यान दें कि OGL में Android के तहत, GL_POLYGONS नहीं हैं, केवल GL_TRIANGSES हैं । जिनमें से सबसे तेज़ GL_TRIANGLE_STRIP है , उनके बारे में यहाँ पढ़ें - en.wikipedia.org/wiki/Triangle_strip हालांकि, उन्हें एक निश्चित अनुक्रम और परेशानियों की आवश्यकता होती है, जिसे हम नहीं करना चाहते थे, इसलिए हम GL_TRIANGLES (बाद के परीक्षणों में, प्रदर्शन की वृद्धि न्यूनतम थी) का उपयोग करेंगे। और इसलिए हमारी सतह, अगर आप इसे "त्रिकोण के माध्यम से" देखते हैं, तो शुरुआत की तुलना में इस तरह दिखना चाहिए:

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

 private class GroundSelf extends GroundShape { public GroundSelf(List<Section> sec, BitmapTextureAtlas texture) { super(texture); sections = sec;//    ,    . Init();//    GroundShape' } , BitmapTextureAtlas बनावट) private class GroundSelf extends GroundShape { public GroundSelf(List<Section> sec, BitmapTextureAtlas texture) { super(texture); sections = sec;//    ,    . Init();//    GroundShape' } 

और ग्राउंडशेप :: Init (), जैसा कि हम याद करते हैं, buildVertexBuffer () को कॉल करेगा, जिसे प्रत्येक वारिस को अधिभार देना होगा। इस समारोह में, हम प्रत्येक त्रिकोण के सभी कोने यूवी निर्देशांक का निर्माण और सेट करना होगा। यह विचार करने योग्य है कि हमारी बनावट चौकोर है, और पृथ्वी आम तौर पर एक गैर-उत्तल पॉलीहेड्रॉन है, और यदि हम 1: 1 के समन्वय अनुपात में सभी त्रिभुजों में एक बनावट को मूर्खता से खींचते हैं, तो हमने चित्रों की तरह बनावट को भी नहीं जीता है। हमें कारक, अतिरिक्त, सेट करने में सक्षम होने की आवश्यकता है, क्योंकि लंबाई ऊंचाई से अधिक है, यू निर्देशांक एक कारक से बड़ा होना चाहिए।
मैं अत्यधिक अनुशंसा करता हूं कि जब आप बनावट के साथ काम करते हैं, तो चित्र के रूप में कुछ कम्पास लें, ताकि आप बनावट निर्देशांक के उन्मुखीकरण को सही ढंग से निर्धारित कर सकें।
वास्तव में, buildVertexBuffer फ़ंक्शन में, आप अपनी वस्तु और उसके यूवी निर्देशांक के सभी त्रिकोणों को परिभाषित करते हैं।

  @Override protected Vertex[] buildVertexBuffer() { int vertexesCount = 0, i, j, k = 0; float hellY = 800.0f;//   "". final float maxU = 4.0f;//     U final float maxV = 2.0f;//  V float stepU; //       // -   ,    . //    V. float startV = sections.get(0).lines.get(0).line.getY1(); float valueV = hellY - sections.get(0).lines.get(0).line.getY1(); for (i = 0; i < sections.size(); ++i) vertexesCount += sections.get(i).lines.size()*6; Vertex[] res = new Vertex[vertexesCount]; Section tmpSection; Line tmpLine; for (i = 0; i < sections.size(); ++i) { tmpSection = sections.get(i); //         //.     . //  6 . for (j = 0; j < tmpSection.lines.size(); ++j) { tmpLine = tmpSection.lines.get(j).line; stepU = maxU/(float)tmpSection.lines.size(); res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = tmpLine.getY1(); res[k].u = (float)j*stepU; res[k++].v = maxV + ((startV - tmpLine.getY1())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = hellY; res[k].u = (float)(j + 1)*stepU; res[k++].v = 0.0f; } } //  ,  . return res; } List<Section> sections; } () *  @Override protected Vertex[] buildVertexBuffer() { int vertexesCount = 0, i, j, k = 0; float hellY = 800.0f;//   "". final float maxU = 4.0f;//     U final float maxV = 2.0f;//  V float stepU; //       // -   ,    . //    V. float startV = sections.get(0).lines.get(0).line.getY1(); float valueV = hellY - sections.get(0).lines.get(0).line.getY1(); for (i = 0; i < sections.size(); ++i) vertexesCount += sections.get(i).lines.size()*6; Vertex[] res = new Vertex[vertexesCount]; Section tmpSection; Line tmpLine; for (i = 0; i < sections.size(); ++i) { tmpSection = sections.get(i); //         //.     . //  6 . for (j = 0; j < tmpSection.lines.size(); ++j) { tmpLine = tmpSection.lines.get(j).line; stepU = maxU/(float)tmpSection.lines.size(); res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = tmpLine.getY1(); res[k].u = (float)j*stepU; res[k++].v = maxV + ((startV - tmpLine.getY1())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = hellY; res[k].u = (float)(j + 1)*stepU; res[k++].v = 0.0f; } } //  ,  . return res; } List<Section> sections; } जे)  @Override protected Vertex[] buildVertexBuffer() { int vertexesCount = 0, i, j, k = 0; float hellY = 800.0f;//   "". final float maxU = 4.0f;//     U final float maxV = 2.0f;//  V float stepU; //       // -   ,    . //    V. float startV = sections.get(0).lines.get(0).line.getY1(); float valueV = hellY - sections.get(0).lines.get(0).line.getY1(); for (i = 0; i < sections.size(); ++i) vertexesCount += sections.get(i).lines.size()*6; Vertex[] res = new Vertex[vertexesCount]; Section tmpSection; Line tmpLine; for (i = 0; i < sections.size(); ++i) { tmpSection = sections.get(i); //         //.     . //  6 . for (j = 0; j < tmpSection.lines.size(); ++j) { tmpLine = tmpSection.lines.get(j).line; stepU = maxU/(float)tmpSection.lines.size(); res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = tmpLine.getY1(); res[k].u = (float)j*stepU; res[k++].v = maxV + ((startV - tmpLine.getY1())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = tmpLine.getY2(); res[k].u = (float)(j + 1)*stepU; res[k++].v = maxV + ((startV - tmpLine.getY2())/valueV)*maxV; res[k] = new Vertex(); res[k].x = tmpLine.getX1(); res[k].y = hellY; res[k].u = (float)j*stepU; res[k++].v = 0.0f; res[k] = new Vertex(); res[k].x = tmpLine.getX2(); res[k].y = hellY; res[k].u = (float)(j + 1)*stepU; res[k++].v = 0.0f; } } //  ,  . return res; } List<Section> sections; } 

सतह बनाई। अब हमें इसे दुनिया से जोड़ने की जरूरत है। यह सामान्य रूप से अंडमान में किया जाता है:

 //  grndSelf = new GroundSelf(sections, EvoGlobal.getTextureCache().get(EvoTextureCache.tex_ground).texture); //  AndEngine EvoGlobal.getWorld().getScene().attachChild(grndSelf); 

परिणाम:


मुझे उम्मीद है कि जो कोई समाधान की तलाश में Google के माध्यम से यहां आया है वह संतुष्ट है।