👨🏾‍🏫 👨🏽‍🎓 🧖🏽 ख्रुश्चेव प्रक्रियात्मक जनरेटर 😂 🕍 🥅

मैं एक बार घर पर बैठा, ख्रुश्चेव के बारे में एक लेख पढ़ा और वास्तुकार की प्रतिभा की प्रशंसा की। तब मुझे जाने दिया गया, और मैंने सोचा कि ख्रुश्चेव की सुस्तता और एकरूपता को बहुत आसानी से गणितीय रूप से वर्णित किया जा सकता है। समकोण, समान अंतराल, सजावट की एक न्यूनतम - क्या सरल हो सकता है?

वास्तव में, ख्रुश्चेव में कई दर्जन संशोधन हैं, लेकिन एक निश्चित आधार, ख्रुश्चेव का सार, अभी भी पता लगाया जा सकता है।

सामान्य तौर पर, दो बार सोचने के बिना, मैं बैठ गया और यूनिटी 3 डी के तहत C # में ख्रुश्चेव जनरेटर लिखा। कट के तहत uv- कार्ड, सबमेश और शेड्स के विषय पर एल्गोरिथ्म और प्रतिबिंब का वर्णन है।

▣ पहले प्रयास करें। सभी ज्यामिति की कुल प्रोग्रामिंग।

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

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

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

एक आदिम खिड़की बनाने के लिए कोड

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

Mesh EntrancePanel(Vector3 vertex0, Vector3 vertex1, Vector3 vertex2, Vector3 vertex3) { var normal = Vector3.Cross((vertex1 - vertex0), (vertex2 - vertex0)).normalized; var window0 = vertex0 + (vertex3 - vertex0) * 0.25f + (vertex1 - vertex0) * 0.25f; var window1 = vertex0 + (vertex3 - vertex0) * 0.25f + (vertex1 - vertex0) * 0.75f; var window2 = vertex0 + (vertex3 - vertex0) * 0.75f + (vertex1 - vertex0) * 0.75f; var window3 = vertex0 + (vertex3 - vertex0) * 0.75f + (vertex1 - vertex0) * 0.25f; var mesh = new Mesh { vertices = new[] {vertex0, vertex1, vertex2, vertex3, window0, window1, window2, window3, window0, window1, window2, window3}, normals = new[] { normal, normal, normal, normal, normal, normal, normal, normal, normal, normal, normal, normal }, uv = new[] {new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0), new Vector2(0.25f, 0.25f), new Vector2(0.25f, 0.75f), new Vector2(0.75f, 0.75f), new Vector2(0.75f, 0.25f), new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0)}, triangles = new[] { 0, 1, 4, 4, 1, 5, 1, 2, 5, 5, 2, 6, 2, 3, 6, 6, 3, 7, 3, 0, 7, 7, 0, 4, 8, 9, 10, 10, 11, 8}, subMeshCount = 2 }; mesh.SetTriangles(new[] { 0, 1, 4, 4, 1, 5, 1, 2, 5, 5, 2, 6, 2, 3, 6, 6, 3, 7, 3, 0, 7, 7, 0, 4}, 0); mesh.SetTriangles(new[] { 8, 9, 10, 10, 11, 8 }, 1); return mesh; }

यह विकल्प दिलचस्प है, लेकिन जब मैंने एक दीवार, एक खिड़की, एक सामने का दरवाजा और एक चमकता हुआ बालकनी बनाने में बहुत समय बिताया, तो मुझे अचानक दुख हुआ और मैंने दूसरी तरफ से अंदर जाने का फैसला किया।

▣ दूसरी कोशिश। सब कुछ संपादक के माध्यम से, सबमर्स और बहुत सारी सामग्रियों के साथ है

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

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

▣ तीसरा प्रयास। समुराई shader और बनावट नक्शे

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

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

ख्रुश्चेव shader कोड

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

 Shader "Custom/Khrushchyovka" { Properties { _Color ("Main Color", Color) = (1,1,1,1) _MainTex ("Base (RGBA)", 2D) = "white" {} _GlassColor ("Glass Color", Color) = (0.5, 0.5, 0.5, 1) _Shininess ("Shininess", Range (0.01, 1)) = 0.078125 _SpecColor ("Specular Color", Color) = (0.5, 0.5, 0.5, 1) _SpecTex ("Specular (RGB)", 2D) = "gray" {} } SubShader { Tags { "RenderType"="Opaque" } LOD 200 CGPROGRAM #pragma surface surf BlinnPhong sampler2D _MainTex, _SpecTex; fixed4 _Color, _GlassColor; half _Shininess; struct Input { float2 uv_MainTex; }; void surf (Input IN, inout SurfaceOutput o) { half4 main = tex2D (_MainTex, IN.uv_MainTex); half4 spec = tex2D(_SpecTex, IN.uv_MainTex); o.Albedo = main.rgb * _Color.rgb + spec.rgb * _GlassColor.rgb; o.Gloss = spec.rgb; o.Specular = _Shininess; } ENDCG } FallBack "Diffuse" }

Wall हम एक दीवार का निर्माण करते हैं

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

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

दो अलग-अलग प्लेटों के साथ, दी गई लंबाई के अंतराल को भरना अधिक कठिन होता है। इस कार्य का अपना नाम है - सबसेट योग समस्या । इस समस्या को हल करने के लिए कई विकल्प हैं, मैंने एक सरल पुनरावर्ती एल्गोरिथम चुना।

प्रारंभ में, उपलब्ध पैनल लंबाई के साथ एक सरणी होती है और एक सेगमेंट भरना पड़ता है। एल्गोरिथ्म के परिणामस्वरूप, एक और सरणी प्राप्त की जाती है, जिसमें संख्याओं का मतलब पहले सरणी से एक ही सूचकांक में लंबाई के साथ आवश्यक पैनलों की संख्या है। यही है, पहला सरणी इस तरह दिखता है: {3, 2.5f}। और 11 मीटर के खंड के लिए दूसरा ऐसा दिखता है: {2, 2}। मैं यह भी ध्यान देता हूं कि पैनलों के साथ सरणी अवरोही क्रम में क्रमबद्ध है।

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

एल्गोरिदम कोड

उपरोक्त के अलावा, शेष के आकार के लिए एक चेक जोड़ा जाता है, यदि यह सबसे छोटे पैनल से छोटा है, तो एक छोटा पैनल जोड़ा जाता है।

 int[] ExteriorWallSizesDraft(float remainder, int[] draft = null, int startIndex = 0) { if (draft == null) { draft = new int[panels.Length]; for (int i = 0; i < draft.Length; i++) { draft[i] = 0; } } if (remainder < panels[panels.Length - 1]) { draft[draft.Length - 1] = 1; return draft; } for (var i = startIndex; i < panels.Length; i++) { draft[i] += (int)(remainder / panels[i]); remainder %= panels[i]; } if (remainder > 0) { for (var i = 0; i < draft.Length; i++) { if (draft[i] != 0) { if (i == draft.Length - 1) { return draft; } draft[i]--; remainder += panels[i]; startIndex = i+1; break; } } draft = ExteriorWallSizesDraft(remainder, draft, startIndex); } return draft; }

कोई फर्क नहीं पड़ता कि मैंने कितनी कोशिश की, मैं विभिन्न लंबाई के पैनलों के वितरण के सिद्धांत को नहीं समझ सका, इसलिए एक सरणी को लंबाई के साथ एक सरणी में एक मात्रा में परिवर्तित करने के बाद, यह फिशर - येट्स एल्गोरिदम के अनुसार मिश्रण करता है। यह काफी सभ्य परिणाम निकला।

▣ हम एक मुखौटा डिजाइन करते हैं

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

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

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

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

मुखौटा जनरेटर कोड

मैं पैनल के प्रकार को इंगित करने के लिए एक एन्यूमरेशन का उपयोग करता हूं; यह इस तरह दिखता है:

 public enum PanelType { Wall, Window, Balcony, Entrance, EntranceWall, EntranceWallLast, Socle, Attic, };

नीचे दिया गया शाखा कोड काफी सरल है, चर नाम खुद के लिए बोलते हैं, समझाने के लिए बहुत कुछ नहीं है।

 List<List<PanelType>> FacadePattern(int panelCount, int floorCount, bool haveAttic=false, bool longFacade=false, int entrancesCount=0) { var panelPattern = new List<List<PanelType>>(); var entranceIndex = panelCount / (entrances + 1); var entranceCount = 1; for (var i = 0; i < floorCount+1; i++) { panelPattern.Add(new List<PanelType>()); for (var j = 0; j < panelCount; j++) { if (i == 0) { if (entrancesCount > 0 && j == entranceIndex && entranceCount <= entrances) { panelPattern[0].Add(PanelType.Entrance); entranceCount++; entranceIndex = panelCount*entranceCount/(entrances + 1); } else { panelPattern[0].Add(PanelType.Socle); } } else if (i == 1) { if (panelPattern[0][j] == PanelType.Entrance) { panelPattern[1].Add(PanelType.EntranceWall); } else if (longFacade) { panelPattern[1].Add(PanelType.Window); } else { panelPattern[1].Add(PanelType.Wall); } } else { panelPattern[i].Add(panelPattern[i - 1][j]); } if (i == floorCount) { if (panelPattern[i - 1][j] == PanelType.Entrance || panelPattern[i - 1][j] == PanelType.EntranceWall) { panelPattern[i][j] = PanelType.EntranceWallLast; } } } if (i == 1 && !longFacade) { for (int j = 0; j <= panelPattern[1].Count / 2; j++) { if (j != 0 && j != panelCount - 1 && Random.value > 0.5f) { panelPattern[1][j] = PanelType.Window; panelPattern[1][panelPattern[1].Count - 1 - j] = PanelType.Window; } } } if (i == 2) { for (int j = 0; j <= panelPattern[2].Count/2; j++) { if (panelPattern[2][j] == PanelType.Window && panelPattern[2][panelPattern[2].Count - 1 - j] == PanelType.Window && Random.value > 0.5f) { panelPattern[2][j] = PanelType.Balcony; panelPattern[2][panelPattern[2].Count - 1 - j] = PanelType.Balcony; } } } } if (haveAttic) { panelPattern.Add(new List<PanelType>()); for (var j = 0; j < panelCount; j++) { panelPattern[panelPattern.Count-1].Add(PanelType.Attic); } } return panelPattern; }

▣ हम ख्रुश्चेव को कवर करते हैं

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

छत के लिए, मैंने एक मीटर की चौड़ाई और लंबाई के साथ मॉडल बनाए, और फिर उन्हें आवश्यकतानुसार बढ़ाया।

छत का विकल्प

 switch (roofType) { case RoofType.Flat: combine.Add(RandomItem(roofFlat)); matrices.Add(Matrix4x4.TRS(roofHeight, Quaternion.identity, new Vector3(length, 1, width))); break; case RoofType.FlatOverhang: combine.Add(RandomItem(roofFlat)); matrices.Add(Matrix4x4.TRS(roofHeight, Quaternion.identity, new Vector3(length + 1, 1, width + 1))); break; case RoofType.Gabled: combine.Add(RandomItem(roofGabled)); matrices.Add(Matrix4x4.TRS(roofHeight, Quaternion.identity, new Vector3(length, 1, width + 1))); break; case RoofType.Hipped: combine.Add(RandomItem(roofHipped)); matrices.Add(Matrix4x4.TRS(roofHeight, Quaternion.identity, new Vector3(length + 1, 1, width + 1))); break; }

वह सब है। ख्रुश्चेव तैयार है।

▣ निष्कर्ष

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

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

एकता वेब प्लेयर | विंडोज | लिनक्स | मैक | गिटहब स्रोत

बाईं माउस बटन - नई इमारत, Esc - बाहर निकलें।

पी एस मुझे खुशी होगी अगर कोई मॉडल के अंतिम रूप देने में मदद करता है, मेरे लिए मॉडलर खराब है।

ख्रुश्चेव प्रक्रियात्मक जनरेटर