रेंडर कंट्रोलर

ऐनिमेशन मॉब को हिलाते हैं। रेंडर कंट्रोलर तय करता है कि मॉब किस चीज़ से बनाकर दिखाया जाए: कौन सा मॉडल, कौन सा texture और कौन सा material। यह मॉडल के हिस्से छिपा भी सकता है। इस गाइड में हमारे Ruby golem को तीन रत्न-रंग मिलेंगे और एक ताज जिसे वह कभी-कभी ही पहनता है।

रेंडर कंट्रोलर रिसोर्स पैक में रहते हैं। ऐनिमेशन की तरह, ये भी सिर्फ़ यह बदलते हैं कि मॉब कैसा दिखता है।

फ़ाइलें

RP/
  entity/
    ruby_golem.entity.json
  render_controllers/
    ruby_golem.render_controllers.json
  textures/
    entity/
      ruby_golem/
        red.png
        pink.png
        dark.png

क्या आपको इसकी ज़रूरत भी है?

कई मॉब का एक ही मॉडल और एक ही skin होता है। उनके लिए vanilla कंट्रोलर controller.render.default इस्तेमाल करें। यह क्लाइंट एंटिटी में default नाम वाली geometry, texture और material को दिखाता है, और आपको कोई फ़ाइल लिखनी नहीं पड़ती। आपका पहला कस्टम मॉब ठीक यही करता है।

आपको अपना रेंडर कंट्रोलर तब चाहिए जब:

• मॉब के पास चुनने के लिए कई textures हों, जैसे रंग या skins,
• मॉब का मॉडल बदलता हो, जैसे ऊन खो देने वाली भेड़,
• मॉडल के हिस्से दिखने या गायब होने चाहिए, जैसे काठी या armor,
• मॉब को किसी रंग में tint करना हो।

छोटे नाम क्लाइंट एंटिटी से आते हैं

रेंडर कंट्रोलर कभी file paths इस्तेमाल नहीं करता। वह वे छोटे नाम इस्तेमाल करता है जो आपने क्लाइंट एंटिटी में दिए थे, आगे एक prefix लगाकर:

तो texture.red का मतलब है "वह texture जिसे मैंने क्लाइंट एंटिटी में red नाम दिया था"।

स्टेप 1: सबसे सरल कंट्रोलर

रेंडर कंट्रोलर फ़ाइलें render_controllers फ़ोल्डर में जाती हैं:

{
  "format_version": "1.8.0",
  "render_controllers": {
    "controller.render.ruby_golem": {
      "geometry": "geometry.default",
      "materials": [{ "*": "material.default" }],
      "textures": ["texture.red"]
    }
  }
}

तीन मुख्य हिस्से:

नाम controller.render. से शुरू होना चाहिए। फिर इसे क्लाइंट एंटिटी में लिखें:

"render_controllers": ["controller.render.ruby_golem"]

स्टेप 2: तीन रत्न-रंग

अब मज़ेदार हिस्सा। पहले, तीनों textures क्लाइंट एंटिटी में लिखें:

"textures": {
  "red": "textures/entity/ruby_golem/red",
  "pink": "textures/entity/ruby_golem/pink",
  "dark": "textures/entity/ruby_golem/dark"
}

फिर इन्हें रेंडर कंट्रोलर में एक array में रखें और Molang से एक चुनें:

{
  "format_version": "1.8.0",
  "render_controllers": {
    "controller.render.ruby_golem": {
      "arrays": {
        "textures": {
          "array.gem_colors": [
            "texture.red",
            "texture.pink",
            "texture.dark"
          ]
        }
      },
      "geometry": "geometry.default",
      "materials": [{ "*": "material.default" }],
      "textures": ["array.gem_colors[query.variant]"]
    }
  }
}

array.gem_colors[query.variant] का मतलब है "लिस्ट से नंबर query.variant वाला आइटम लो"। गिनती 0 से शुरू होती है, तो variant 0 लाल है, 1 गुलाबी और 2 गहरा।

query.variant कहाँ से आता है?

बिहेवियर पैक से। minecraft:variant कंपोनेंट मॉब पर एक नंबर रखता है, और query.variant उसे पढ़ता है। यहाँ हर golem spawn होते समय एक random रंग चुनता है:

"component_groups": {
  "wiki:color_red": { "minecraft:variant": { "value": 0 } },
  "wiki:color_pink": { "minecraft:variant": { "value": 1 } },
  "wiki:color_dark": { "minecraft:variant": { "value": 2 } }
},
"events": {
  "minecraft:entity_spawned": {
    "randomize": [
      { "weight": 2, "add": { "component_groups": ["wiki:color_red"] } },
      { "weight": 1, "add": { "component_groups": ["wiki:color_pink"] } },
      { "weight": 1, "add": { "component_groups": ["wiki:color_dark"] } }
    ]
  }
}

लाल का weight 2 है, इसलिए यह बाकी दोनों में से हर एक से दोगुना बार दिखता है।

मॉडल और materials के लिए भी arrays

arrays में तीन तरह की लिस्ट हो सकती हैं। हर लिस्ट में सिर्फ़ एक ही तरह की चीज़ हो सकती है:

आपको हमेशा array की ज़रूरत नहीं होती। दो चीज़ों के बीच आसान चुनाव के लिए Molang ternary काफ़ी है:

"geometry": "query.is_baby ? geometry.small : geometry.default"

स्टेप 3: हिस्से छिपाएँ और दिखाएँ

part_visibility बोन्स को चालू और बंद करता है। हमारे golem के पास एक crown बोन है जो सिर्फ़ tame होने पर दिखता है:

"part_visibility": [
  { "*": true },
  { "crown": "query.is_tamed" }
]

• हर एंट्री एक बोन का नाम और एक value है। true या 0 के अलावा कुछ भी उसे दिखाता है, false या 0 उसे छिपाता है।
• किसी बोन को छिपाने से उसके children भी छिप जाते हैं।
• एंट्रीज़ क्रम से लागू होती हैं, इसलिए बाद वाली जीतती हैं। यहाँ पहले सब कुछ दिखाया जाता है, फिर ताज query से सेट होता है।
• * wildcard की तरह काम करता है: "gem_*" से gem_left, gem_right वगैरह मैच होते हैं।

materials लिस्ट भी ऐसे ही काम करती है: सब कुछ के लिए { "*": ... } से शुरू करें, फिर उसके बाद अलग-अलग बोन्स को override करें।

"materials": [
  { "*": "material.default" },
  { "core": "material.glow" }
]

इसके काम करने के लिए, glow क्लाइंट एंटिटी के materials में एक छोटा नाम होना चाहिए, जो किसी असली चमकने वाले material की तरफ़ इशारा करे, जैसे entity_emissive_alpha।

रंग और इफ़ेक्ट

रेंडर कंट्रोलर रंग भी बदल सकता है। ये सभी optional हैं:

हर रंग में 0 से 1 तक r, g, b और a होते हैं, और हर एक Molang हो सकता है:

"overlay_color": {
  "r": 1.0,
  "g": 1.0,
  "b": 1.0,
  "a": "variable.is_shouting ? 0.5 : 0.0"
}

एक से ज़्यादा कंट्रोलर

क्लाइंट एंटिटी में render_controllers एक लिस्ट है। हर कंट्रोलर अपने मॉडल के साथ मॉब को एक बार बनाता है, इसलिए आप इन्हें एक के ऊपर एक रख सकते हैं। Vanilla इसका इस्तेमाल armor या चमकती आँखों जैसी layers के लिए करता है।

आप एक condition भी जोड़ सकते हैं ताकि कोई कंट्रोलर सिर्फ़ कभी-कभी बने:

"render_controllers": [
  "controller.render.ruby_golem",
  { "controller.render.ruby_golem_shine": "query.is_powered" }
]

जब कुछ गड़बड़ हो

और मदद Troubleshooting में है।

आगे क्या

• एंटिटी ऐनिमेशन से मॉब को हिलाएँ।
• ऐनिमेशन इवेंट्स से ऐनिमेशन में साउंड और पार्टिकल चलाएँ।
• Pixel textures से बेहतर skins बनाएँ।