एक समय में, यूनिटी 3 डी पर एक दो-आयामी गेम के विकास की शुरुआत में, मुझे इस विषय पर प्रलेखन, साइटों, अध्ययन उत्तरों. unity3d.com और forum.unity3d.com के एक समूह के माध्यम से खुदाई करनी थी: इस 3 डी इंजन पर 2 डी गेम कैसे बनाया जाए। बहुत पहले सवाल थे: कैमरे को ठीक से कैसे कॉन्फ़िगर किया जाए, 2 डी स्प्राइट कैसे बनाया जाए ताकि यह पिक्सेल-टू-पिक्सेल बनावट प्रदर्शित करे। उस समय, SpriteManager (बाद में SM के रूप में संदर्भित ) और यहां तक ​​कि SM2 पहले से ही अपने शक्तिशाली संपादक समर्थन के साथ मौजूद था। भाग्य ऐसा था कि मैं इसे खरीद नहीं सकता था, और कोई परीक्षण संस्करण नहीं था। नतीजतन, मुझे यूनिटी 3 डी पर 2 डी को लागू करने के लिए खुद कुछ उपयोगी स्क्रिप्ट लिखना पड़ा। यह कैसे करें इस लेख में चर्चा की जाएगी।

"

जानकारी के स्रोत

तुरंत मैं उन सभी के लिए यूनिटी 3 डी पर जानकारी के कुछ उपयोगी स्रोतों के बारे में लिखूंगा, जो इंजन से बिल्कुल भी परिचित नहीं हैं, या बस इसे जानना शुरू कर रहे हैं।

• Unity3d.com - आधिकारिक इंजन साइट। यहाँ उपयोगी पृष्ठ हैं:
  
  • एकता उपयोगकर्ता मैनुअल - आधिकारिक उपयोगकर्ता गाइड। यहां खोज शुरू करें।
  • एकता संदर्भ मैनुअल - एक अधिक गहन अध्ययन।
  • स्क्रिप्टिंग संदर्भ - यहां सभी तीन समर्थित भाषाओं (बू, जावास्क्रिप्ट और सी #) के लिए यूनिटी 3 डी लाइब्रेरी के बारे में है।
  • एकता संसाधन - यहां आप वीडियो ट्यूटोरियल, उदाहरण, प्रस्तुतियां पा सकते हैं।
  • एकता उत्तर - यहां आप अपने सवालों के जवाब देंगे, या आप एक तैयार उत्तर पा सकते हैं। अक्सर इस संसाधन का उपयोग किया।
  • एकता सामुदायिक मंच।
• रूसी में यूनिटी 3 डी - रूसी में यूनिटी 3 डी के लिए डेवलपर्स की साइट। यदि आप अंग्रेजी की परवाह नहीं करते हैं, तो रूसी में मैनुअल हैं, और मंच पर आप रुचि के सवालों के जवाब पा सकते हैं।
• यूनिटी 3 डी विकी एक बहुत ही उपयोगी संसाधन है। यहां बहुत सारी सिफारिशें हैं, मुफ्त उपयोगी स्क्रिप्ट हैं।

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

क्या जरूरत है?

उपयोग किए गए इंजन का संस्करण 3.3 है, सभी कोड C # में लिखे गए हैं और सभी एकता लाइसेंस पर काम करेंगे। बस एकता का मुफ्त संस्करण डाउनलोड करें । शामिल है MonoDevelop - .NET के लिए एक मुफ्त विकास वातावरण (यदि आपके पास Visual Studio नहीं है)। पर्यावरण आसानी से आप के लिए "अनुकूलन" है, इसमें आपके पास विकास के लिए आवश्यक सब कुछ है, ऐसे सुविधाजनक कार्यों का समर्थन करता है जैसे कि ऑटो-पूर्ति, कोड प्रतिस्थापन पैटर्न, और बहुत कुछ। मैं खुद Resharper के साथ मिलकर विज़ुअल स्टूडियो का उपयोग करता हूं - यह अधिक सुविधाजनक है। एकता संपादक दोनों वातावरणों का समर्थन करता है।

कोड की शर्तें

मैंने स्क्रैच से कोड लिखा, राइटिंग के समय, इसलिए आपको मेरे चरणों को दोहराने में कोई समस्या नहीं होनी चाहिए। कोड का स्वतंत्र रूप से उपयोग, संपादन, सुधार किया जा सकता है।

केवल एक ही शर्त है : एक व्यावसायिक परियोजना में कोड (संशोधित एक सहित) का उपयोग करते समय, आपको लेखक (यानी फिशर - मुझे) के लिए एक लिंक निर्दिष्ट करना होगा।

लेख में उपयोग किए गए उदाहरण के लिए कोड यहाँ से डाउनलोड किया जा सकता है ।

कैमरा सेटअप

सबसे पहले, कोई ऑब्जेक्ट नहीं के साथ एक खाली दृश्य बनाएं। डिफ़ॉल्ट MainCamera ऑब्जेक्ट निकालें।

आपको कैमरे को कॉन्फ़िगर करने की आवश्यकता है ताकि यह 2d के लिए "उपयुक्त" हो जाए। यूनिटी में, एक कैमरा कैमरा क्लास को संदर्भित करता है। इसका उपयोग करने के लिए, आपको आवश्यकता है:

1. एक खाली ऑब्जेक्ट बनाएं ( GameObject -> क्रिएट खाली )।
2. इसे चुनें और इसमें कैमरा घटक जोड़ें ( घटक -> प्रतिपादन -> कैमरा )।

प्रारंभ में, कैमरा XOY विमान के लंबवत है और सकारात्मक दिशा में Z अक्ष के साथ निर्देशित है। भविष्य में, सादगी के लिए, स्प्राइट्स XOY विमान में और कैमरे की ओर स्थित होंगे, इसलिए कैमरे को निर्देशांक के केंद्र में रखें और इसे Z अक्ष के साथ नकारात्मक आधे-स्थान में घुमाएं (बिंदु 0, 0, -100 पर)।

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



अब कैमरे को कॉन्फ़िगर करें ताकि स्क्रीन पर प्रत्येक पिक्सेल यूनिटी में अंतरिक्ष की एक इकाई से मेल खाती हो। भविष्य में, यह सुविधाजनक होगा जब स्प्राइट को स्थानांतरित करना और पिक्सेल में उनके आकार स्थापित करना होगा। ऐसा करने के लिए, ऑर्थोगोनल कैमरा ( आकार पैरामीटर) का आकार पिक्सेल में स्क्रीन की आधी ऊंचाई के बराबर होना चाहिए। उदाहरण के लिए, अगर यह पोर्ट्रेट मोड में iPhone 3 जी स्क्रीन है, जिसका स्क्रीन रिज़ॉल्यूशन 320x480 है, तो आकार = एच / 2 = 480/2 = 240 ।

प्रत्येक बार मैन्युअल रूप से यह सब न करने के लिए, हम एक स्क्रिप्ट लिखेंगे:

using UnityEngine; [ExecuteInEditMode] [RequireComponent(typeof(Camera))] internal class Ortho2dCamera : MonoBehaviour { [SerializeField] private bool uniform = true; [SerializeField] private bool autoSetUniform = false; private void Awake() { camera.orthographic = true; if (uniform) SetUniform(); } private void LateUpdate() { if (autoSetUniform && uniform) SetUniform(); } private void SetUniform() { float orthographicSize = camera.pixelHeight/2; if (orthographicSize != camera.orthographicSize) camera.orthographicSize = orthographicSize; } } 

यदि आप इस स्क्रिप्ट को किसी गेम ऑब्जेक्ट ( GameObject ) में जोड़ते हैं , तो:

1. कैमरा ऑब्जेक्ट स्वचालित रूप से इस ऑब्जेक्ट में जोड़ा जाएगा। इसके लिए NeedComponent विशेषता जिम्मेदार है।
2. अवेक फंक्शन चलेगा। विशेषता ExecuteInEditMode इसके लिए जिम्मेदार है, जो स्क्रिप्ट को सीधे संपादक में निष्पादित करने के लिए मजबूर करता है।
3. इस फ़ंक्शन को कॉल करने के परिणामस्वरूप, कैमरा ऑर्थोगोनल हो जाएगा।
4. इसका आकार सेट किया जाएगा ताकि स्क्रीन पर एक पिक्सेल एक एकता इकाई ( सेटयूनीफॉर्म फ़ंक्शन को कॉल करते हुए ) से मेल खाती हो। यह किसी भी स्क्रीन के लिए स्वचालित रूप से किया जाएगा।

कैमरा अब इस तरह दिखना चाहिए:

सुधार

1. यदि स्क्रीन का आकार रनटाइम में बदल सकता है (स्मार्टफोन की स्क्रीन को बदलकर, उपयोगकर्ता द्वारा रिज़ॉल्यूशन बदलकर), तो कैमरे को स्वचालित रूप से आकार देना अच्छा होगा। यह लेटयुपडेट फ़ंक्शन में किया जा सकता है।
2. यदि प्रकाश का उपयोग नहीं किया जाएगा (जैसा कि अधिकांश 2 डी गेम में होता है), मैं अनुशंसा करता हूं कि आप प्रोजेक्ट सेटिंग्स में वर्टेक्स लिट को रेंडरिंग पथ पैरामीटर सेट करें ( फ़ाइल-> सेटिंग बनाएँ-> प्लेयर सेटिंग्स-> अन्य सेटिंग्स )। यह अधिकांश उपकरणों द्वारा समर्थित वस्तुओं (सभी प्रकाश स्रोतों के लिए एक कदम में प्रत्येक वस्तु) को खींचने का सबसे आसान तरीका है। IOS उपकरणों के लिए मेरे मामले में, इसने प्रदर्शन में एक छलांग दी। वही एक विशिष्ट कैमरे के लिए किया जा सकता है। डिफ़ॉल्ट रूप से, कैमरा प्लेयर सेटिंग्स से मूल्य का उपयोग करता है।

प्रेत

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

संकेत : स्प्राइट देखने के लिए इसे आसान बनाने के लिए, आप दृश्य के अक्षों पर क्लिक करके समन्वय अक्ष को घुमा सकते हैं, शीर्ष दाईं ओर, जब तक वे उचित रूप नहीं लेते (हमारे मामले में, पीछे की स्थिति)।



स्प्राइट कई मापदंडों द्वारा निर्धारित किया जाएगा:

  [SerializeField] private Vector2 size = Vector2.one; [SerializeField] private Vector2 zero = Vector2.one / 2; [SerializeField] private Rect textureCoords = Rect.MinMaxRect(0, 0, 1, 1); [SerializeField] private bool pixelCorrect = true; 

उन्हें निर्णय लें:

• शून्य - इसके निचले बाएं कोने के सापेक्ष स्प्राइट के शून्य बिंदु की स्थिति। इसे स्प्राइट के अंशों में मापा जाता है, अर्थात (0.5, 0.5) स्प्राइट का केंद्र है। यह स्प्राइट के सही विस्थापन के लिए आवश्यक है, इसकी परवाह किए बिना कि यह बनावट पर कैसे स्थित है।
  संकेत : शून्य बिंदु पर संपादक में रोटेशन / विस्थापन कुल्हाड़ियों को देखने के लिए, और केंद्र में नहीं (डिफ़ॉल्ट रूप से), आपको टूलबार के ट्रांसफ़ॉर्म गिज़्मो टॉगल नियंत्रण पर पिवट का चयन करने की आवश्यकता है।
  
  
• बनावट-बनावट - बनावट निर्देशांक। वे ऊपरी बाएं कोने और बनावट पर क्षेत्र के आकार के निर्देशांक हैं। उन्हें उसी तरह से मापा जाता है जैसे कि ओपनजीएल में - बनावट के अंशों में। प्रत्येक बनावट के लिए, एक पैरामीटर सेट किया जाता है जो इंगित करता है कि [0, 1] सेगमेंट को छोड़ते समय निर्देशांक क्रॉप हो जाएगा, या क्या बनावट दोहराई जाएगी ( Wrap Mode बनावट आयात पैरामीटर)।
• पिक्सेलकोर सही बूलियन मान है, चाहे स्प्राइट को "पिक्सेल से पिक्सेल" प्रदर्शित किया जाएगा ताकि स्प्राइट पर प्रत्येक पिक्सेल स्क्रीन पर एक पिक्सेल से मेल खाती हो।

आयत को प्रदर्शित करने के लिए हम मेष वर्ग की एक वस्तु का उपयोग करेंगे। सरलतम मामले में, यह आरंभिक है:

1. चोटियों की सूची
2. आयतों को बनाने वाले त्रिभुजों के शीर्षों की सूची, जो आयत बनाते हैं,
3. बनावट की एक सूची कोने के अनुरूप है।

ऊपर बताए गए स्प्राइट मापदंडों को ध्यान में रखते हुए, हम इस तरह से मेष वर्ग की एक वस्तु बनाएंगे:

  private static Mesh CreateMesh(Vector2 size, Vector2 zero, Rect textureCoords) { var vertices = new[] { new Vector3(0, 0, 0), // 1 ___ 2 new Vector3(0, size.y, 0), // | | new Vector3(size.x, size.y, 0),// | | new Vector3(size.x, 0, 0) // 0 ---- 3 }; Vector3 shift = Vector2.Scale(zero, size); for (int i = 0; i < vertices.Length; i++) { vertices[i] -= shift; } var uv = new[] { new Vector2(textureCoords.xMin, 1 - textureCoords.yMax), new Vector2(textureCoords.xMin, 1 - textureCoords.yMin), new Vector2(textureCoords.xMax, 1 - textureCoords.yMin), new Vector2(textureCoords.xMax, 1 - textureCoords.yMax) }; var triangles = new[] { 0, 1, 2, 0, 2, 3 }; return new Mesh { vertices = vertices, uv = uv, triangles = triangles }; } 

एक जाल खींचने के लिए, आपको मेशरेंडर और मेशफिल्टर घटकों की आवश्यकता होती है । पहले घटक में स्प्राइट के लिए बनावट सामग्री के लिंक होते हैं। दूसरे वाले में MeshFilter.mesh ऑब्जेक्ट है, जिसे वह ड्रॉ करता है। स्प्राइट को बदलने के लिए, आपको तदनुसार इस ऑब्जेक्ट को संशोधित करना होगा। स्प्राइट को ही सैंपसप्राइट घटक के माध्यम से कार्यान्वित किया जाता है। स्प्राइट के लिए हमेशा इन दो घटकों को रखने के लिए, इसमें इसके लिए आवश्यक आवश्यकताएँ जोड़ें:

 using UnityEngine; [ExecuteInEditMode] [AddComponentMenu("Sprites/Sample Sprite")] [RequireComponent (typeof(MeshFilter))] [RequireComponent (typeof(MeshRenderer))] public class SampleSprite : MonoBehaviour { … } 

AddComponentMenu विशेषता संपादक के घटक मेनू में स्प्राइट्स-> नमूना स्प्राइट जोड़ता है। इसका उपयोग करते हुए, आप किसी भी एकता ऑब्जेक्ट के लिए हमारा नमूनास्रोइट घटक जोड़ सकते हैं।



संपादन के दौरान स्प्राइट को देखने में सक्षम होने के लिए, ExecuteInEditMode विशेषता आपको संपादक में सीधे नमूनाप्रक्रिया वर्ग के सजग और प्रारंभ कार्यों को कॉल करने की अनुमति देती है। इन कार्यों के अंदर एक जाली बनाई जाती है:

  private MeshFilter meshFilter; private MeshRenderer meshRenderer; #region Unity messages // Use this for initialization private void Awake() { meshFilter = GetComponent<MeshFilter>(); meshRenderer = GetComponent<MeshRenderer>(); } private void Start() { // NOTE: initializing mesh here because our camera is initialized in Awake() InitializeMesh(); } #endregion 

मेष को इनिशियलाइज़ करते समय, पिक्सेलक्रॉयर फ्लैग पर विचार करना चाहिए। हम यह जांचते हैं कि स्क्रीन की ऊँचाई कितनी बार कैमरे के आकार से भिन्न होती है - कितनी बार आपको मेष को बढ़ाने की आवश्यकता होती है, यह देखते हुए कि सामान्य संस्करण में (स्क्रीन की ऊँचाई ऑर्थोगोनल कैमरे के दोगुने के बराबर होती है) मेष का आकार स्प्राइट के लिए बनावट क्षेत्र के आकार के बराबर होता है:

  private void InitializeMesh() { Camera cam = Camera.main; if (pixelCorrect && cam != null) { float ratio = cam.pixelHeight / (2 * cam.orthographicSize); size.x = NonNormalizedTextureCoords.width * ratio; size.y = NonNormalizedTextureCoords.height * ratio; } meshFilter.mesh = CreateMesh(size, zero, textureCoords); } 

NonNormalizedTextureCurds - बनावट पिक्सेल में निर्देशांक है। सामान्यीकृत बनावट निर्देशांक (स्प्राइट पैरामीटर) और बनावट के आकार के आकार के माध्यम से परिभाषित किया गया है:

  private Rect NonNormalizedTextureCoords { get { Rect coords = textureCoords; Vector2 texSize = TextureSize; if (texSize != Vector2.zero) { coords.xMin *= texSize.x; coords.xMax *= texSize.x; coords.yMin *= texSize.y; coords.yMax *= texSize.y; } return coords; } } private Vector2 TextureSize { get { if (meshRenderer == null) return Vector2.zero; Material mat = meshRenderer.sharedMaterial; if (mat == null) return Vector2.zero; Texture tex = mat.mainTexture; if (tex == null) return Vector2.zero; return new Vector2(tex.width, tex.height); } } 

ध्यान दें कि मेष को प्रारंभ फ़ंक्शन में प्रारंभ किया जाता है, क्योंकि जब इसे प्रारंभ किया जाता है, तो कैमरे से जानकारी का उपयोग किया जाता है, और यह हमारे द्वारा जागृत में आरम्भ किया जाता है, अर्थात। प्रारंभ में, यह जानकारी अन्य वस्तुओं के लिए पहले से ही उपलब्ध है (एकता में, सभी जाग को पहले कहा जाता है, फिर सभी प्रारंभ करें , लेकिन विभिन्न वस्तुओं के लिए एक ही फ़ंक्शन को कॉल करने का क्रम परिभाषित नहीं है)। इस उदाहरण में भी, Camera.main का उपयोग किया जाता है - मंच पर मुख्य कैमरा। यानी हमारे कैमरे को MainCamera के साथ टैग किया जाना चाहिए।



सिद्धांत रूप में, इस स्तर पर स्प्राइट के साथ काम करना पहले से ही संभव है। ऐसा करने के लिए, आपको किसी भी ऑब्जेक्ट (उदाहरण के लिए, घटक मेनू के माध्यम से या उस पर स्क्रिप्ट फ़ाइल को खींचकर) से नमूनाप्रतिष्ठित घटक संलग्न करना होगा । MeshFilter और MeshRenderer घटकों को स्वचालित रूप से इसमें जोड़ा जाता है। अब, यदि आप इस ऑब्जेक्ट पर बनावट सामग्री (या बनावट, और सामग्री स्वचालित रूप से बनाई गई है) को खींचते हैं और मापदंडों को समायोजित करते हैं, तो आप समाप्त 2 डी छवि देख सकते हैं।

बनावट सेटिंग्स समायोजित करें

स्प्राइट को सही ढंग से प्रदर्शित करने के लिए, आपको बनावट गुणों में निम्नलिखित मापदंडों को बदलने की आवश्यकता है:

1. ताकि स्प्राइट आंदोलन सुचारू हो, ताकि जब स्प्राइट अपना आकार बदलता है, तो यह चिकना दिखता है, आपको टेक्स्ट एक्सपोर्ट पैरामीटर फ़िल्टर मोड को बिलिनियर या ट्रिलिनियर पर सेट करने की आवश्यकता होती है);
2. GUI मान के लिए बनावट प्रकार सेट करें;
3. Truecolor के लिए प्रारूप पैरामीटर के मूल्य को निर्धारित करके संपीड़न को हटाने के लिए याद रखें।

प्रकाश

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

1. संस्करण 3.3 में अनलिट शेड्स का एक समूह है जिसमें लाइटिंग बंद है। पारदर्शिता के साथ स्प्राइट्स के लिए, अनलिट-> पारदर्शी शेडर उपयुक्त है , पृष्ठभूमि के लिए अनलिमिटेड-> बनावट ।
2. एकता के पुराने संस्करणों में, आप ट्रांसपेरेंट-> डिफ्यूज़ शेडर का उपयोग कर सकते हैं। लेकिन फिर आप एडिट-> रेंडर सेटिंग्स में एंबिएंट लाइट को सफेद रंग में डालना न भूलें ताकि सभी स्प्राइट एक प्राकृतिक रंग के हों। अन्यथा, उन्हें अंधेरा कर दिया जाएगा, क्योंकि एम्बिएंट लाइट के लिए डिफ़ॉल्ट सेटिंग ग्रे की एक छाया है।
3. आप अपना स्वयं का शेडर लिख सकते हैं जिसमें प्रकाश व्यवस्था बंद कर दी जाएगी। आप यह देख सकते हैं कि आधिकारिक एकता shader ट्यूटोरियल में यह कैसे किया जाए।

संपादक सुविधाओं का उपयोग करना

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

1. संपादकीय टैग।
2. संपादक वर्ग से विरासत में लेकर घटक निरीक्षक में गेम ऑब्जेक्ट एडिटर बनाना।
3. EditorWindow वर्ग से विरासत में संपादक विंडो बनाना।

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

 using UnityEditor; using UnityEngine; [CustomEditor(typeof(SampleSprite))] public class SampleSpriteEditor : Editor { public override void OnInspectorGUI() { Target.Size = EditorGUILayout.Vector2Field("Size", Target.Size); Target.Zero = EditorGUILayout.Vector2Field("Zero Point", Target.Zero); Target.TextureCoords = EditorGUILayout.RectField("Texture Coordinates", Target.TextureCoords); Target.PixelCorrect = EditorGUILayout.Toggle("Pixel Correct", Target.PixelCorrect); if (GUI.changed) { Target.UpdateMesh(); EditorUtility.SetDirty(target); } } private SampleSprite Target { get { return target as SampleSprite; } } [MenuItem("Sprites/Create/Sample")] private static void CreateSprite() { var gameObject = new GameObject("New Sample Sprite"); gameObject.AddComponent<SampleSprite>(); Selection.activeObject = gameObject; } } 

नोट : सम्पादक से जुड़ी सभी लिपियाँ एसेट्स / सम्पादक फ़ोल्डर में स्थित होनी चाहिए।

CustomEditor विशेषता इंगित करती है कि इस वर्ग का उपयोग Component Inspector में EditorSprite घटक वर्ग के संपादक के रूप में किया जाएगा। लक्षित संपत्ति को संपादित वस्तु के क्षेत्रों तक पहुंचने की सुविधा के लिए पेश किया गया था, क्योंकि डिफ़ॉल्ट लक्ष्य वस्तु प्रकार की वस्तु है । ओवररैप किए गए OnInspectorGUI फ़ंक्शन इंस्पेक्टर में प्रदर्शित नमूनासमिति घटक मापदंडों की सूची सेट करता है । यदि इनमें से कम से कम एक पैरामीटर बदल जाता है ( GUI.changed ), स्प्राइट को अपडेट किया जाएगा, और हम स्क्रीन पर परिवर्तन का परिणाम देखेंगे, साथ ही स्प्राइट के परिवर्तित पैरामीटर ( EditorUtility.SetDirty )।

नमूनाप्रमाण श्रेणी में संपादन योग्य पैरामीटर जोड़ें और उन्हें सशर्त रूप से संकलित करें (ताकि यह कोड अंतिम उत्पाद में न आए, लेकिन केवल संपादक में काम करता है):

 #if UNITY_EDITOR public Vector2 Size { get { return size; } set { size = value; } } public Vector2 Zero { get { return Vector2.Scale(zero, size); } set { if (size.x != 0 && size.y != 0) { zero = new Vector2(value.x / size.x, value.y / size.y); } } } public Rect TextureCoords { get { return NonNormalizedTextureCoords; } set { textureCoords = value; Vector2 texSize = TextureSize; if (texSize != Vector2.zero) { textureCoords.xMin /= texSize.x; textureCoords.xMax /= texSize.x; textureCoords.yMin /= texSize.y; textureCoords.yMax /= texSize.y; } } } public bool PixelCorrect { get { return pixelCorrect; } set { pixelCorrect = value; } } public void UpdateMesh() { InitializeMesh(); } #endif 

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

अनुकूलन, सुधार और बहुत कुछ

ड्रा कॉल की संख्या कम करें

ऐसा करने के कई तरीके हैं।

1. स्टेटिक बैचिंग । यदि ऑब्जेक्ट कभी नहीं बदलता है, तो इसे स्थिर ( इंस्पेक्टर में स्टेटिक चेकबॉक्स) के रूप में चिह्नित किया जा सकता है। ऐसी सभी वस्तुओं को एक बड़े एक में जोड़ दिया जाएगा और एक ड्रॉ कॉल में खींचा जाएगा। दुर्भाग्य से, स्थिर बैचिंग सुविधा केवल एकता प्रो संस्करण में उपलब्ध है।
2. गतिशील बैचिंग । यदि कई ऑब्जेक्ट एक ही सामग्री का उपयोग करते हैं, तो यूनिटी उन्हें ड्राइंग से पहले एक में जोड़ती है, और उन सभी को एक ड्रॉ कॉल में खींचा जाएगा। इस आशय को प्राप्त करने के लिए, बनावट को एक एटलस में जोड़ा जाना चाहिए - एक बड़ी बनावट। Atlases का उपयोग करें - वे आपको ड्रा कॉल ( गतिशील बैचिंग के कारण) की संख्या और बनावट द्वारा कब्जा की गई मेमोरी की मात्रा (जो मोबाइल प्लेटफार्मों के लिए बहुत महत्वपूर्ण है) दोनों को कम करने की अनुमति देते हैं।
   संकेत : कुछ प्लेटफार्मों के लिए बैचिंग प्रकारों को सक्षम / अक्षम करना फ़ाइल-> बिल्ड सेटिंग्स-> प्लेयर सेटिंग्स में किया जाता है ।
3. स्प्राइट मैनेजर कार्यान्वयन में से एक SpriteManager है । स्प्राइट को स्प्राइट प्रबंधक में जोड़ा जाता है, जो एक एटलस बनावट ( मेशरेंडर घटक में) का उपयोग करता है, और स्प्राइट्स के लिए ( मेशफिल्टर घटक में) एक जाल बनाता है, जिसमें कई आयताकार शामिल होते हैं, प्रत्येक स्प्राइट के लिए (लेखक ने इस कार्यान्वयन के लिए संपादक की सुविधा को खराब कर दिया और SM2 प्राप्त किया। )। आप स्प्रिट प्रबंधक का उपयोग किए गए सामग्री के लिंक के लिए स्प्राइट को सेट करके भी कर सकते हैं, स्प्राइट प्रबंधक के मेशरेंडर घटक में सभी सामग्रियों को संग्रहीत कर सकते हैं, और मेष की एक छोटी मात्रा (एक सामग्री) के संग्रह के रूप में मेष को खींच सकते हैं। मैकबाइनमेश , मेश.सिट्रीएंगल्स , मेष की क्षमताओं का उपयोग करके । GetTriangles , Mesh.subMeshCount । यह आपको प्रत्येक सामग्री के लिए स्प्राइट प्रबंधक शुरू नहीं करने देगा।

कुछ कोड में सुधार

1. बेशक, CreateMesh फ़ंक्शन के निरंतर कॉल से छुटकारा पाने के लिए बेहतर है, जो एक नए जाल के निर्माण की ओर जाता है (इस मामले में, यह महत्वपूर्ण नहीं है, क्योंकि सब कुछ संपादक में होता है, और वास्तविक अनुप्रयोग में स्प्राइट एक बार बनाया जाएगा और अब नहीं बदलेगा)। इसके बजाय, बस पैरामीटर को बदलें। जाल को याद रखें ।ecalculateBounds () अगर कोने सरणी बदल दिया गया है। यदि त्रिकोण सरणी को बदल दिया जाता है, तो यह फ़ंक्शन स्वचालित रूप से कहा जाएगा।
2. Camera.main के बजाय कैमरा को स्क्रिप्ट पैरामीटर के रूप में सेट करना बेहतर है।

एनिमेशन कैसे बनाये

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

2d भौतिकी

आप कोलाइडर के एक घटक को किसी भी स्प्राइट में संलग्न कर सकते हैं: घटक-> भौतिकी-> आयताकार वस्तुओं के लिए BoxCollider और गोलाकार वस्तुओं के लिए घटक-> भौतिकी-> SphereCollider । इन घटकों का उपयोग दो उद्देश्यों के लिए किया जा सकता है:

1. ऑब्जेक्ट को ट्रिगर बनाएं ( ट्रिगर चेकबॉक्स है)।
2. वस्तु को भौतिक प्रभाव से गुजरने दें। ऐसा करने के लिए, आप इसके अलावा घटक-> भौतिकी-> कठोर घटक को वस्तु में संलग्न कर सकते हैं।

Rigidbody का उपयोग करके, आप किसी वस्तु के भौतिकी को दो आयामों तक सीमित कर सकते हैं: घटक में बाधा पैरामीटर है। आपको Rigidbody-> कांस्ट्रेक्ट्स-> फ्रीज पोजिशन-> Z को टिक करके Z अक्ष के साथ ऑब्जेक्ट की गति को सीमित करने की आवश्यकता है, और X और Y एक्सिस ( फ्रीज रोटेशन-> X और फ्रीज रोटेशन-> Y ) के साथ रोटेशन को सीमित करें।



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

विकल्प

1. EZSprite एकता में 2d एनिमेशन बनाने के लिए एक सरल भुगतान प्रणाली है (लेखन के समय, प्लगइन की लागत $ 35 है)।
2. SpriteManager स्प्राइट एनिमेशन बनाने के लिए एक क्लास सिस्टम है। एक ड्रा कॉल में स्प्राइट ड्राइंग का समर्थन करता है, स्प्राइट्स के प्रबंधक, एनिमेशन और एटलस। सेट करने के लिए काफी असुविधाजनक, लेकिन अगर बजट सीमित है, तो यह उपयोग के लिए काफी उपयुक्त है।
3. SM2 (स्प्राइट मैनेजर 2) एडिटर सपोर्ट वाला एक पेड स्प्राइट मैनेजर है। यह मुक्त संस्करण के अलावा कई उपयोगी कार्यों का समर्थन करता है: बनावट क्षेत्रों को उजागर करने के लिए संपादक का उपयोग करके, स्वचालित रूप से एनिमेशन बनाने, और बहुत कुछ। यदि आप मैन्युअल रूप से स्प्राइट को लागू नहीं करना चाहते हैं, तो एसएम 2, मेरी राय में, सबसे अच्छा विकल्प है। यदि आपको यह पसंद नहीं है तो 60 दिनों के लिए पैसे वापस करने के अवसर के साथ $ 150 का खर्च आता है।
4. रेजस्पेलाइन , $ 50। यह प्लगइन पूरी तरह से स्प्राइट नहीं है, बल्कि एक वेक्टर है। प्लगइन में कई दिलचस्प विशेषताएं हैं:
   
   • बेज़ियर वक्रों के आधार पर 2d मेश और लाइनें बनाना;
   • विभिन्न चौड़ाई की वस्तुओं की आकृति;
   • एकल रंग भरने / ढाल;
   • बनावट वाली वस्तुएँ;
   • और भी बहुत कुछ।

निष्कर्ष

मेरे बारे में जो कुछ मैंने लिखा है वह दो-आयामी गेम बनाते समय मेरे 2d-system और इसके बाद के उपयोग को लिखने के लिए पर्याप्त है। इंजन की तीन-आयामीता और भौतिकी का समर्थन हमें नए समृद्ध अवसर प्रदान करता है, और एकता (जो इंजन का एक बड़ा प्लस है) पर उच्च विकास की गति लागत को कम करेगी।

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