एंड्रॉइड पर .3DS फाइलें डाउनलोड करें

यह लेख ग्लो इफ़ेक्ट पर मेरी पिछली पोस्ट का एक प्रकार है। मैंने यह बताने का वादा किया है कि कैसे .3ds फाइलें अपलोड की जाती हैं।

फ़ाइल प्रारूप के बारे में कुछ सामान्य जानकारी, उदाहरण के लिए, विकिपीडिया पर या Demo.design 3D प्रोग्रामिंग FAQ में पढ़ी जा सकती है, लेकिन यह सभी सिद्धांत है (और यह बिना त्रुटियों के लिखा गया था), लेकिन यहां हम जावा और एंड्रॉइड के संबंध में अभ्यास, इसके अलावा, के बारे में बात करेंगे।

यहां क्या होगा:

• पूरी फ़ाइल को पढ़ने में काफी तेज है (फोन पर एक दो-मेगाबाइट फ़ाइल कुछ सेकंड में भरी हुई है);
• पूरे मॉडल को लोड करना, मानदंडों की गणना करना, बनावट निर्देशांक लोड करना;
• सामग्री, प्रकाश स्रोतों के बारे में सभी जानकारी;
• वस्तुओं का एनीमेशन और पदानुक्रम लोड करना।

यहाँ क्या नहीं होगा:

• खुद को लोड करना (मुझे अभी तक इसकी आवश्यकता नहीं है, हालांकि इसे लागू करना आसान है);
• कैमरों के बारे में जानकारी डाउनलोड करें (फिर से, इसे जोड़ना आसान है, लेकिन यह उपयोगी नहीं था);
• मानदंडों की गणना के लिए चौरसाई समूहों का उपयोग करना (यह सुनिश्चित नहीं है कि यह बिल्कुल आवश्यक है) (यह अभी भी होगा);
• एनीमेशन के लिए विभाजन का उपयोग करें।

पिछली बार के रूप में पूरे स्रोत कोड को विस्तार से चबाएं, यहां मैं नहीं (यह एक हजार लाइनों से अधिक है), मैं केवल मुख्य बिंदुओं पर ध्यान केंद्रित करूंगा और पूर्ण स्रोत कोड (लेख के अंत में) लिंक प्रदान करूंगा। अभी भी दिलचस्पी है? तो चलिए जारी रखते हैं।

फ़ाइल पढ़ें

अजीब तरह से पर्याप्त है, यह एक फ़ाइल से संख्याओं का सबसे सरल पढ़ना था जो सबसे कठिन कार्यों में से एक था, जिसे पहले स्थान पर सामना करना पड़ा था। यहां दो रेक हैं: गति और शुद्धता। हम BufferedInputStream और विशेष रूप से अनुक्रमिक पढ़ने का उपयोग करके गति सुनिश्चित करेंगे, लेकिन सब कुछ सही होने के साथ और अधिक जटिल है: जावा का मानना ​​है कि फ़ाइल में सभी डेटा बड़े-एंडियन होने चाहिए, जबकि .3ds छोटे-एंडियन का उपयोग करता है। खैर ... हम एक साधारण आवरण का उपयोग करते हैं:

private BufferedInputStream file; private byte[] bytes = new byte[8]; private long filePos = 0; ... private void Skip(long count) throws IOException { file.skip(count); filePos += count; } private void Seek(long end) throws IOException { if (filePos < end) { Skip(end - filePos); filePos = end; } } private byte ReadByte() throws IOException { file.read(bytes, 0, 1); filePos++; return bytes[0]; } private int ReadUnsignedByte() throws IOException { file.read(bytes, 0, 1); filePos++; return (bytes[0]&0xff); } private int ReadUnsignedShort() throws IOException { file.read(bytes, 0, 2); filePos += 2; return ((bytes[1]&0xff) << 8 | (bytes[0]&0xff)); } private int ReadInt() throws IOException { file.read(bytes, 0, 4); filePos += 4; return (bytes[3]) << 24 | (bytes[2]&0xff) << 16 | (bytes[1]&0xff) << 8 | (bytes[0]&0xff); } private float ReadFloat() throws IOException { return Float.intBitsToFloat(ReadInt()); } 

एक अच्छे तरीके से, यह बफ़रड इनपुटस्ट्रीम से विरासत में मिला एक अलग वर्ग होना चाहिए था, लेकिन इस मामले में मेरे लिए ऐसा करना अधिक सुविधाजनक था।

अब आप हिस्सा पढ़ना शुरू कर सकते हैं। शुरुआत के लिए - मुख्य एक:

  private Scene3D ProcessFile(long fileLen) throws IOException { Scene3D scene = null; while (filePos < fileLen) { int chunkID = ReadUnsignedShort(); int chunkLen = ReadInt() - 6; switch (chunkID) { case CHUNK_MAIN: if (scene == null) scene = ChunkMain(chunkLen); else Skip(chunkLen); break; default: Skip(chunkLen); } } return scene; } private Scene3D ChunkMain(int len) throws IOException { Scene3D scene = new Scene3D(); scene.materials = new ArrayList<Material3D>(); scene.objects = new ArrayList<Object3D>(); scene.lights = new ArrayList<Light3D>(); scene.animations = new ArrayList<Animation>(); long end = filePos + len; while (filePos < end) { int chunkID = ReadUnsignedShort(); int chunkLen = ReadInt() - 6; switch (chunkID) { case CHUNK_OBJMESH: Chunk3DEditor(scene, chunkLen); break; case CHUNK_KEYFRAMER: ChunkKeyframer(scene, chunkLen); break; case CHUNK_BACKCOL: scene.background = new float[4]; ChunkColor(chunkLen, scene.background); break; case CHUNK_AMB: scene.ambient = new float[4]; ChunkColor(chunkLen, scene.ambient); break; default: Skip(chunkLen); } } Seek(end); scene.Compute(0); return scene; } 

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

सामग्री

सामग्री का ब्लॉक आमतौर पर पहले जाता है, क्योंकि तब त्रिकोण का ब्लॉक बाद में इसे संदर्भित करता है।

सामग्री में कई रंग (परिवेश, फैलाना, स्पेक्युलर) होते हैं, सामग्री का नाम, चकाचौंध का पैरामीटर, बनावट का नाम। जैसा कि ऊपर उल्लेख किया गया है, बनावट यहां लोड नहीं हैं, लेकिन यदि आवश्यक हो तो जोड़ना आसान है।

3 डी मॉडल

प्रत्येक 3D मॉडल (देखें ChunkTrimesh फ़ंक्शन) निम्न डेटा द्वारा परिभाषित किया गया है:

• शीर्ष निर्देशांक की सूची;
• त्रिकोण की सूची;
• बनावट निर्देशांक;
• स्थानीय समन्वय प्रणाली।

यदि पहले तीन बिंदुओं के साथ सब कुछ स्पष्ट है, तो अंतिम कुछ रहस्यमय दिखता है। आगे देखते हुए, मैं कहूंगा कि मेरे लिए यह एक समझ से बाहर की इकाई बना हुआ है, हालांकि मैंने अभी भी सीखा है कि इस डेटा को सही तरीके से कैसे लागू किया जाए।

हम एक सरणी फ्लोट में कोने के बारे में सभी जानकारी डंप करेंगे [], एक पंक्ति में प्रत्येक शीर्ष के लिए आठ वास्तविक संख्याओं को संग्रहीत करना (निर्देशांक और सामान्य द्वारा तीन, प्लस दो बनावट निर्देशांक)। पिछले लेख की कुछ पंक्तियों को बदलना होगा:

  GLES20.glVertexAttribPointer(maPosition, 3, GLES20.GL_FLOAT, false, 32, 0); GLES20.glVertexAttribPointer(maNormal, 3, GLES20.GL_FLOAT, false, 32, 12); 

यहां, संख्या 24 बदलकर 32 हो गई है, क्योंकि पहले कोई बनावट निर्देशांक नहीं थे, लेकिन अब यह है।

सभी निर्देशांक ChunkVector फ़ंक्शन के साथ लोड किए गए हैं, जो एक ही समय में Y और Z अक्षों को स्वैप करता है:

  private void ChunkVector(float[] vec, int offset) throws IOException { vec[offset + 0] = ReadFloat(); vec[offset + 2] = ReadFloat(); vec[offset + 1] = ReadFloat(); } 

खैर, सामान्य तौर पर, कुछ मानक प्रकारों के लिए, जैसे कि रंग या प्रतिशत, उनके कार्यों का उपयोग किया जाता है।

त्रिकोणों की सूची को एक विशेष तरीके से संसाधित किया जाना चाहिए: सबसे पहले, सामग्रियों को चेहरों पर लागू किया जाता है (और अनुलंबों के लिए नहीं), और दूसरी बात, कार्यक्षेत्रों के मानदंड चेहरों से निर्धारित किए जा सकते हैं। ऐसा करने के लिए, हम प्रत्येक चेहरे के लिए सामान्य की गणना करते हैं, इसे प्रत्येक तीन कोने में जोड़ते हैं, जिसके बाद (पहले से ही अंत में, सभी त्रिकोणों को लोड करने के बाद) हम सामान्य करते हैं। कार्यों का एक गुच्छा, थोड़ा गणित - और आप कर रहे हैं।

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

  mAmbient[0] = 0.587f; mAmbient[1] = 0.587f; mAmbient[2] = 0.587f; mAmbient[3] = 1.0f; mDiffuse[0] = 0.587f; mDiffuse[1] = 0.587f; mDiffuse[2] = 0.587f; mDiffuse[3] = 1.0f; mSpecular[0] = 0.896f; mSpecular[1] = 0.896f; mSpecular[2] = 0.896f; mSpecular[3] = 1.0f; ... int mats = obj.faceMats.size(); for (j = 0; j < mats; j++) { FaceMat mat = obj.faceMats.get(j); if (mat.material != null) { if (mat.material.ambient != null && scene.ambient != null) { for (k = 0; k < 3; k++) mAmbient[k] = mat.material.ambient[k] * scene.ambient[k]; GLES20.glUniform4fv(muAmbient, 1, mAmbient, 0); } else GLES20.glUniform4f(muAmbient, 0, 0, 0, 1); if (mat.material.diffuse != null) GLES20.glUniform4fv(muDiffuse, 1, mat.material.diffuse, 0); else GLES20.glUniform4fv(muDiffuse, 1, mDiffuse, 0); if (mat.material.specular != null) GLES20.glUniform4fv(muSpecular, 1, mat.material.specular, 0); else GLES20.glUniform4fv(muSpecular, 1, mSpecular, 0); GLES20.glUniform1f(muShininess, mat.material.shininess); } else { GLES20.glUniform4f(muAmbient, 0, 0, 0, 1); GLES20.glUniform4fv(muDiffuse, 1, mDiffuse, 0); GLES20.glUniform4fv(muSpecular, 1, mSpecular, 0); GLES20.glUniform1f(muShininess, 0); } GLES20.glDrawElements(GLES20.GL_TRIANGLES, mat.indexBuffer.length, GLES20.GL_UNSIGNED_SHORT, mat.bufOffset * 2); } 

देखा।

प्रकाश स्रोत

सर्वव्यापी और दिशात्मक हैं। दिशात्मक प्रकाश स्रोतों के बारे में, फिर से, जब तक हम बात नहीं करते हैं (हालांकि यह एक ऐसी छाया को लिखना मुश्किल नहीं है जो निर्देश को ध्यान में रखता है), मैं चकाचौंध के बारे में कुछ शब्द कहूंगा। पिछले लेख से मॉडल के लिए shader पर विचार करें, और इसमें कुछ पंक्तियाँ जोड़ें:

  private final String vertexShaderCode = "precision mediump float;\n" + "uniform mat4 uMVPMatrix;\n" + "uniform mat4 uMVMatrix;\n" + "uniform mat3 uNMatrix;\n" + "uniform vec4 uAmbient;\n" + "uniform vec4 uDiffuse;\n" + "uniform vec4 uSpecular;\n" + "uniform float uShininess;\n" + ... "vec4 light_point_view_local(vec3 epos, vec3 normal, int idx) {\n" + " vec3 vert2light = uLight[idx].position - epos;\n" + " vec3 ldir = normalize(vert2light);\n" + " vec3 vdir = vec3(0.0, 0.0, 1.0);\n" + " vec3 halfv = normalize(ldir + vdir);\n" + " float NdotL = dot(normal, ldir);\n" + " float NdotH = dot(normal, halfv);\n" + " vec4 outCol = vec4(0.0, 0.0, 0.0, 1.0);\n" + " if (NdotL > 0.0) {\n" + " outCol = uLight[idx].color * uDiffuse * NdotL;\n" + " if (NdotH > 0.0 && uShininess > 0) {\n" + " outCol += uSpecular * pow(NdotH, uShininess);\n" + " }\n" + " }\n" + " return outCol;\n" + "}\n"; 

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

एनीमेशन

.3ds प्रारूप में सबसे कठिन और दिलचस्प विषयों में से एक है। तथ्य यह है कि एनिमेटेड पटरियों के उपयोग के बिना, कुछ वस्तुओं को सही ढंग से प्रदर्शित नहीं किया जा सकता है। और अगर वस्तुएं एक दूसरे के क्लोन हैं, तो और भी अधिक ताकि वे प्रदर्शित न हों।

.3ds फ़ाइल में सभी ऑब्जेक्ट्स को एक श्रेणीबद्ध पेड़ में जोड़ा जाता है, और प्रत्येक "पूर्वज" के परिवर्तनों को "वंशज" पर लागू किया जाना चाहिए। पेड़ के कोने ऊपर से नीचे तक के क्रम में लिखे गए हैं, इसलिए परिवर्तनों के आवेदन को उसी क्रम में किया जा सकता है। यह उत्सुक है कि 3 डी मॉडल की .3ds फ़ाइल के दृष्टिकोण से, प्रकाश स्रोत और कैमरे समान ऑब्जेक्ट हैं जो एक पदानुक्रम में एक दूसरे के साथ जुड़े हो सकते हैं और एनीमेशन को उसी तरह लागू कर सकते हैं। हालांकि, अब तक हम केवल 3 डी-मॉडल में रुचि रखते हैं, और विशेष रूप से - उन में आंदोलन, घुमाव और स्केलिंग के ट्रैक।

प्रत्येक वस्तु संग्रहीत है:

• वस्तु का नाम;
• ऑब्जेक्ट की पहचानकर्ता स्वयं और उसके पूर्वज;
• धुरी बिंदु (धुरी, उस वस्तु का सशर्त केंद्र जिसके चारों ओर घुमाव बना होता है);
• शिफ्ट, रोटेशन, स्केलिंग के प्रमुख फ़्रेमों की सूची, साथ ही साथ कैमरा पैरामीटर (मैं उन्हें अनदेखा करता हूं, जैसे कैमरे खुद)।

डाउनलोडिंग ट्रैक उबाऊ है, तो चलिए बेहतर तरीके से बात करते हैं कि उनका उपयोग कैसे करें। तो हमारे पास है:

• पूर्वज परिवर्तन मैट्रिक्स (आगमनात्मक परिकल्पना);
• बदलाव;
• मोड़ की गठरी;
• स्केलिंग;
• वस्तु केंद्र;
• स्थानीय समन्वय प्रणाली (3D मॉडल का हिस्सा देखें)।

यह एक तैयार किए गए परिवर्तन मैट्रिक्स में यह सब इकट्ठा करने के लिए बनी हुई है। स्थानांतरण और स्केलिंग के साथ, सब कुछ अपेक्षाकृत सरल है: रैखिक प्रक्षेप बस दो फ़्रेमों के बीच लागू होता है, मान पूर्ण रूप से सेट होते हैं। लेकिन सभी क्रमानुसार लागू होने चाहिए! और मुख्य फ़्रेमों के बीच, हम उचित फ्रेम की उपयुक्त संख्या द्वारा अगले फ्रेम के रोटेशन को लागू करते हैं, इसे रैखिक रूप से प्रक्षेपित करते हैं।

एक और दिलचस्प बात यह है कि आपको दो मेट्रिक्स को ध्यान में रखने की आवश्यकता है: वंश के लिए परिवर्तन (परिणाम) और मॉडल (दुनिया) के लिए परिवर्तन। पहले का उपयोग पदानुक्रम श्रृंखला में किया जाता है, दूसरा - जब मॉडल का प्रतिपादन किया जाता है। यह सब किस क्रम में चल रहा है?

 result = parent.result * move * rotate * scale; world = result * Move(-pivot) * trmatrix; 

यह समझा जाता है कि ट्रांसफ़ॉर्म को शीर्ष पर "दाएं से बाएं" क्रम में लागू किया जाता है (जैसा कि ओपनजीएल में प्रथागत है)। यहां ट्रमेट्रिक्स 3 डी मॉडल के चंक में एक का उलटा है । कुल, एक निश्चित समय के लिए रूपांतरण गणना कोड (लोड करते समय, सभी फ्रेम नंबर 0 से 1 तक वास्तविक संख्या में बदल दिए गए थे):

  private void lerp3(float[] out, float[] from, float[] to, float t) { for (int i = 0; i < 3; i++) out[i] = from[i] + (to[i] - from[i]) * t; } private AnimKey findVec(AnimKey[] keys, float time) { AnimKey key = keys[keys.length - 1]; // We'll use either first, or last, or interpolated key for (int j = 0; j < keys.length; j++) { if (keys[j].time >= time) { if (j > 0) { float local = (time - keys[j - 1].time) / (keys[j].time - keys[j - 1].time); key = new AnimKey(); key.time = time; key.data = new float[3]; lerp3(key.data, keys[j - 1].data, keys[j].data, local); } else key = keys[j]; break; } } return key; } private void applyRot(float[] result, float[] data, float t) { if (Math.abs(data[3]) > 1.0e-7 && Math.hypot(Math.hypot(data[0], data[1]), data[2]) > 1.0e-7) Matrix.rotateM(result, 0, (float) (data[3] * t * 180 / Math.PI), data[0], data[1], data[2]); } public void Compute(float time) { int i, n = animations.size(); for (i = 0; i < n; i++) { Animation anim = animations.get(i); Object3D obj = anim.object; float[] result = new float[16]; Matrix.setIdentityM(result, 0); if (anim.position != null && anim.position.length > 0) { AnimKey key = findVec(anim.position, time); float[] pos = key.data; Matrix.translateM(result, 0, pos[0], pos[1], pos[2]); } if (anim.rotation != null && anim.rotation.length > 0) { // All rotations that are prior to the target time should be applied sequentially for (int j = anim.rotation.length - 1; j > 0; j--) { if (time >= anim.rotation[j].time) // rotation in the past, apply as is applyRot(result, anim.rotation[j].data, 1); else if (time > anim.rotation[j - 1].time) { // rotation between key frames, apply part of it float local = (time - anim.rotation[j - 1].time) / (anim.rotation[j].time - anim.rotation[j - 1].time); applyRot(result, anim.rotation[j].data, local); } // otherwise, it's a rotation in the future, skip it } // Always apply the first rotation applyRot(result, anim.rotation[0].data, 1); } if (anim.scaling != null && anim.scaling.length > 0) { AnimKey key = findVec(anim.scaling, time); float[] scale = key.data; Matrix.scaleM(result, 0, scale[0], scale[1], scale[2]); } if (anim.parent != null) Matrix.multiplyMM(anim.result, 0, anim.parent.result, 0, result, 0); else Matrix.translateM(anim.result, 0, result, 0, 0, 0, 0); if (obj != null && obj.trMatrix != null) { float[] pivot = new float[16]; Matrix.setIdentityM(pivot, 0); Matrix.translateM(pivot, 0, -anim.pivot[0], -anim.pivot[1], -anim.pivot[2]); Matrix.multiplyMM(result, 0, pivot, 0, obj.trMatrix, 0); } else { Matrix.setIdentityM(result, 0); Matrix.translateM(result, 0, -anim.pivot[0], -anim.pivot[1], -anim.pivot[2]); } Matrix.multiplyMM(anim.world, 0, anim.result, 0, result, 0); } } 

यह सब विशेष रूप से परिष्कृत उदाहरणों पर परीक्षण और त्रुटि के माध्यम से प्राप्त किया गया था, लेकिन मुझे पूर्ण सटीकता और वैसे भी शुद्धता से डर लगता है, यह सब बहुत शक्तिशाली है। और यह स्प्लिन का उपयोग किए बिना है!

इसके अलावा, पिछले लेख का मॉडल चक्र अब थोड़ा अलग दिखता है:

  num = scene.animations.size(); for (i = 0; i < num; i++) { Animation anim = scene.animations.get(i); Object3D obj = anim.object; if (obj == null) continue; Matrix.multiplyMM(mMVMatrix, 0, mVMatrix, 0, anim.world, 0); Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVMatrix, 0); // Apply a ModelView Projection transformation GLES20.glUniformMatrix4fv(muMVPMatrix, 1, false, mMVPMatrix, 0); GLES20.glUniformMatrix4fv(muMVMatrix, 1, false, mMVMatrix, 0); for (j = 0; j < 3; j++) for (k = 0; k < 3; k++) mNMatrix[k*3 + j] = mMVMatrix[k*4 + j]; GLES20.glUniformMatrix3fv(muNMatrix, 1, false, mNMatrix, 0); GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, obj.glVertices); GLES20.glVertexAttribPointer(maPosition, 3, GLES20.GL_FLOAT, false, 32, 0); GLES20.glVertexAttribPointer(maNormal, 3, GLES20.GL_FLOAT, false, 32, 12); GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, 0); ... 

इसके अलावा, सब कुछ पहले जैसा ही है।

निष्कर्ष

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

ठीक है, वास्तव में, वादा किए गए तैयार किए गए स्रोत: सीन 3 डी (डेटा संरचनाएं) और लोड 3 डीएस (लोडर)। कृपया ध्यान दें कि फाइलें मेमोरी कार्ड ("/ sdcard /") की जड़ से भरी हुई हैं, मैं दृढ़ता से इसे कुछ और उचित तरीके से बदलने की सलाह देता हूं।

अपडेट: चूंकि सामान्य के बारे में बहुत सारी प्रतियां टूटी हुई हैं, इसलिए मैंने स्रोत को चौरसाई समूहों के साथ काम करने के लिए कोड जोड़ा। इंडेक्स बफ़र्स 2-बाइट रहते हैं, इसलिए ओवरफ्लो से सावधान रहें!