Animationen Dokumentation (Bedrock)

Aus Minecraft Wiki
Wechseln zu: Navigation, Suche

Dies ist die Animationen Dokumentation für die Bedrock Edition 1.14.0.

Überblick[Bearbeiten]

Im Folgenden werden die aktuellen Minecraft-JSON-Paradigmen beschrieben:
- Felder sollten in Kleinbuchstaben geschrieben sein und Unterstriche (keine Leerzeichen) verwenden.
- Alle JSON-Dateien im Definitionsverzeichnis und im Teilbaum werden vom Animationssystem eingelesen und interpretiert


Erste Schritte[Bearbeiten]

Upgrade von v1.7 Beta auf v1.8[Bearbeiten]

Es wurden nur wenige Änderungen vorgenommen, da wir die Dinge basierend auf dem Feedback bereinigen und die Technologie entlang der Roadmap vorantreiben. Um frühere Skripte zu aktualisieren, müssen Sie die folgenden Schritte für alle Ihre Molang-Skripte in der angegebenen Reihenfolge ausführen:
1) entity.flags.foo -> query.foo
2) entity.member.foo -> query.foo
3) entity.foo -> variable.foo
4) params.foo -> global.foo
5) Die allgemeine Regel lautet, dass 'query' schreibgeschützte Werte der Entität darstellt, auf der das Skript ausgeführt wird, und 'variable' vom Benutzer erstellte Lese- / Schreibdaten darstellt.
6) Wir haben snake_case für alle Namen von Dingen übernommen. Sie können gerne Großbuchstaben verwenden, wenn Sie dies wünschen, da wir die Groß- und Kleinschreibung nicht berücksichtigen. Wir empfehlen jedoch snake_case im Allgemeinen.
7) Mehrere zuvor für Mobs festgelegte Variablen wurden geändert, um das Format query.foo zu verwenden. Sehen Sie sich die aktualisierte Liste unten an, um zu sehen, was hinzugefügt und geändert wurde.


Upgrade von v1.8 Beta auf v1.10[Bearbeiten]

Die drei wichtigsten Änderungen bei 1.10 sind
- die Möglichkeit, Animationen auf andere Animationen in einer willkürlich tiefen Hierarchie verweisen zu lassen.
- Der Parameterabschnitt von Animationscontrollern wurde durch den Abschnitt "Variablen" ersetzt.
- in In der Entitätsdefinitionsdatei werden die Animationscontroller jetzt im Abschnitt "Animationen" aufgeführt, und ein Abschnitt "scripts�nimate" wurde hinzugefügt, um zu definieren, welche Root-Animationen abgespielt werden sollen.
Das Dateiformat v1.8 ist abwärtskompatibel v1.10, damit Sie nichts ändern müssen (obwohl wir empfehlen, Ihre Dateien im Geiste von v1.10 umzugestalten, da das neue Format einen leichten Leistungsgewinn bringt und einfacher zu verstehen ist.


Animationen hinzufügen[Bearbeiten]

Objektdefinition[Bearbeiten]

Um zu definieren, über welche Animationen eine Entität verfügt, müssen Sie der Entitätsdefinitionsdatei einer Entität sowohl einen Abschnitt "Animationen" als auch einen Abschnitt "Skripte / Animationen" hinzufügen.

Hier sehen Sie die Entitätsdefinition für pig.json:

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "minecraft:pig",
      "min_engine_version": "1.8.0",
      "materials": { "default": "pig" },
      "textures": {
        "default": "textures/entity/pig/pig",
        "saddled": "textures/entity/pig/pig_saddle"
      },
      "geometry": {
        "default": "geometry.pig.v1.8"
      },
      "animations": {
        "setup": "animation.pig.setup",
        "walk": "animation.quadruped.walk",
        "look_at_target": "animation.common.look_at_target",
        "baby_transform": "animation.pig.baby_transform"
      },
      "scripts": {
        "animate": [
          "setup",
          { "walk": "query.modified_move_speed" },
          "look_at_target",
          { "baby_transform": "query.is_baby" }
        ]
      },
      "render_controllers": [ "controller.render.pig" ],
      "spawn_egg": {
        "texture": "spawn_egg",
        "texture_index": 2
      }
    }
  }
}


Hinweis: Die Laufanimation für Schweine ist für Kühe und Schafe gleich und verwendet daher animation.quadruped.walk, anstatt eine eigene zu definieren. Dies bedeutet, dass Sie die Verschiebungsanimation auch nicht in der Animationsdatei pig.json sehen. Wenn Sie einen benutzerdefinierten Schweinespaziergang durchführen möchten, können Sie diese Zeile so ändern, dass sie auf Ihre benutzerdefinierte Animation verweist.

Animationen werden als Kurzname angegeben, gefolgt von ihrem vollständigen Ressourcennamen. Der Kurzname wird in Animationscontrollern und in der Liste "Skripte / Animieren" verwendet, während der Langname in der Animationsdatei verwendet wird.

Im Abschnitt "Skripte / Animieren" listen Sie die abzuspielenden Animationen auf in welcher Reihenfolge. Sie können entweder eine Animation direkt oder einen Mischungsausdruck angeben.



Animations-Controller[Bearbeiten]

Man muss steuern können, wie Animationen wann abgespielt werden und wie sie mit anderen Animationen interagieren. Animationen gruppieren Während ein Großteil davon im Abschnitt "Skripte / Animieren" der Entitätsdefinition verwaltet werden kann, geben Ihnen Animations-Controller die Funktionalität einer Zustandsmaschine in Zustände und steuern sie als Block. Animationen in einem Animationscontroller-Status können selbst Animationscontroller sein, die beliebig komplexe Animationshierarchien ermöglichen.

Hier ist ein Beispiel für einen Animations-Controller
{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.my_mob.move": {
      "initial_state": "moving",
      "states": {
        "moving": {
          "animations": [
            "wag_tail",
            "wiggle_ears",
            { "walk": "query.modified_move_speed" }
          ],
          "transitions": [
            { "grazing": "query.is_grazing" }
          ]
        },
        "grazing": {
          "animations": [ "grazing" ],
          "transitions": [
            { "moving": "query.all_animations_finished" }
          ]
        }
      }
    }
  }
}


Animationen[Bearbeiten]

Zu Beginn jedes Frames wird das Skelett aus der Geometriedefinition auf dessen Standardposition zurückgesetzt, und anschließend werden die Animationen pro Kanal additiv in der angegebenen Reihenfolge angewendet. Beachten Sie, dass die Kanäle (x, y und z) zuerst separat über Animationen hinweg hinzugefügt und dann in eine Transformation konvertiert werden, sobald alle Animationen kumulativ angewendet wurden.

Animationsdaten können entweder Rohdaten sein:

Standardmäßig erfolgt die Drehung in Grad im Euler-Format X-dann-Y-dann-Z
"rotation": [90.0, 0.0, 0.0]


oder ein zur Laufzeit interpretiertes Skript: 
"rotation": ["cos(query.anim_pos * 38.17) * 80.0 * query.anim_speed", 0.0, 0.0]


Hier ist ein Beispiel aus quadruped.animation.json im Animationsordner der Vanilla Resource Packs:
{
  "format_version": "1.8.0",
  "animations": {
    "animation.quadruped.walk": {
      "anim_time_update": "query.modified_distance_moved",
      "loop": true,
      "bones": {
        "leg0": { "rotation": [ "Math.cos(query.anim_time * 38.17) *  80.0", 0.0, 0.0 ] },
        "leg1": { "rotation": [ "Math.cos(query.anim_time * 38.17) * -80.0", 0.0, 0.0 ] },
        "leg2": { "rotation": [ "Math.cos(query.anim_time * 38.17) * -80.0", 0.0, 0.0 ] },
        "leg3": { "rotation": [ "Math.cos(query.anim_time * 38.17) *  80.0", 0.0, 0.0 ] }
      }
    }
  }
}



Animationshierachie[Bearbeiten]

Animationen sind kanalbasiert (Rotation, Position oder Skalierung) und enthalten Schlüsselrahmen:

EntityAnimation: Animationsname
__BoneAnimation []: Knochenname zur Animation für diese Animation
____ AnimationChannel []: Drehung, Skalierung oder Übersetzung zum Animieren
______ KeyFrame []: Der Wert für den Kanal zu einem bestimmten Zeitpunkt

Alle oben genannten Konzepte werden im Folgenden ausführlich beschrieben -up Ansatz unten



Namen[Bearbeiten]

Alle Namen: Animationen, Knochen, Zustände usw. müssen mit einem Buchstaben beginnen und dürfen nur alphanumerische Zeichen, Unterstriche oder Punkte enthalten. Es wird empfohlen, Namen in Kleinbuchstaben zu verwenden


Transformierung[Bearbeiten]

- Reihenfolge der Operationen: Scheitelpunkte werden übersetzt, gedreht und dann skaliert.
- Animationsdaten werden als hierarchisch angenommen und auf einen Knochen angewendet, dessen Name mit dem Knochennamen in den Animationsdaten mit dem Skelett der Zielgeometrie übereinstimmt.
- Nicht jeder Knochen muss animiert werden.
- Sie können Knochen animieren, die in der Zielgeometrie nicht vorhanden sind (fehlende Knochen werden ignoriert).
- Für jede Skala, Drehung, Position können die Felder festgelegt werden einzeln oder einheitlich mit einem einzigen Wert. Zum Beispiel sind diese gleichwertig.

"scale": [2.0, 2.0, 2.0]
"scale": 2.0
"scale": [2.0]


Kanäle (Rotation, Position, Größe)[Bearbeiten]

Die Engine verfolgt die Animation von Rotation, Position und Skalierung separat. Innerhalb eines Kanals werden ein oder mehrere Keyframes zu beliebigen Zeiten in Sekunden ab dem Start der Animation angegeben. Wenn keine Keyframes angegeben sind, wird bei t = 0,0 ein einzelner Keyframe erstellt und alle Kanaldaten werden in diesem Keyframe gespeichert.


Beispiele für das Format von Entitätsanimationen[Bearbeiten]

Das JSON-Format für eine Animation lautet wie folgt. Hinweis Entsprechend dem Geometrieformat sind die Einheiten in 1/16 Metern angegeben.

```
<animation_name>": {
  // optional
  "loop": <bool>                                       // Standard = false.  Sollte die Animationsschleife nach Beendigung auf t = 0,0 zurückkehren?
  "blend_weight": <expression>                         // Standard = "1.0".  Wie sehr diese Animation mit den anderen gemischt wird. 0,0 = off. 1.0 = Alle Transformationen vollständig anwenden. Kann ein Ausdruck sein - siehe Abschnitt Animation Controller unten
  "animation_length": <float>                          // Standard = Zeit des letzten Schlüsselbildes. Wann betrachtet das System diese Animation als beendet?
  "override_previous_animation": <bool>                // Standard = false.  Sollte die Animationspose des Knochens vor dem Anwenden dieser Animation auf die Bindungspose gesetzt werden, um alle vorherigen Animationen bis zu diesem Punkt zu überschreiben?

  // required
  "bones": [
    {
    "<bone_name>": {                                   // muss mit dem Namen des im Geometrieskelett angegebenen Knochens übereinstimmen
      // verschiedene Arten von Einstellungsdaten
      // Wenn Sie einen Kanal weglassen, wird dieser Kanal für diese Animation dieses Knochens übersprungen
      // Eine beliebige Anzahl von Floats unten kann wie oben beschrieben durch einen String-Ausdruck ersetzt werden. Sie müssen nicht alle Floats in einer Zeile durch Ausdrücke ersetzen, sondern nur diejenigen, die Ausdrucksbasis sein sollend
      "position": 1.0,                                 // setze x, y, und z zu 1
      "position": [1.0],                               // setze x, y, und z zu 1
      "position": [1.0, 2.0, 3.0],                     // setze x = 1 , y = 2 und z = 3
      "rotation": 45.0,                                // setze x, y, und z zu 45 grad
      "rotation": [45.0],                              // setze x, y, und z zu 45 grad
      "rotation": [30.0, 0.0, 45.0],                   // setze x, y, und z auf die jeweiligen Werte (in Grad)
      // note: only uniform scaling is supported at this time
      "scale": 2.0,                                    // skaliert den Knochen um 2,0
      "scale": [2.0],                                  // skaliert den Knochen um 2,0
      // Keyframe-Daten werden unten beschrieben
      // Beachten Sie, dass jeder der oben genannten Wertestile für "pre" und "post" funktioniert und "pre" nicht das gleiche Format wie "post" haben muss.
      "rotation": {
        "0.0": [80.0, 0.0, 0.0],
        "0.1667": [-80.0, 0.0, 0.0],
        "0.333": [80.0, 0.0, 0.0]
      }
      // Für eine diskontinuierliche Kanalkurve können Sie beim Interpolieren zu / von diesem Keyframe einen anderen Wert angeben
      "rotation": {
        "0.3": {                                       // Das Schlüsselfeld ist der Zeitstempel für diesen Schlüsselrahmen: Der Wert kann eines der obigen Beispiele sein
        "pre": [30.0, 0.0, 45.0],                      // Verwenden Sie diesen Wert, wenn Sie vom vorherigen in Richtung dieses Schlüsselbilds interpolieren
        "post": "180.0 * Math.Sin(global.key_frame_lerp_time)"  // Verwenden Sie diesen Wert, wenn Sie von diesem Keyframe zum nächsten interpolieren
        }
      }
      // anderes Beispiel
      "rotation": {
        "0.0": [80.0, 0.0, 0.0],                       // Beginnt mit einer x-Rotation von 80 Grad
        "0.4": {
        "pre": [80.0, 0.0, 0.0],                       // Bleibt bei 80, bis 0,4 Sekunden vergangen sind
        "post": [0.0, 0.0, 0.0],                       // Stellt die x-Drehung diskontinuierlich auf 0,0 Grad ein
        },
        "0.8": [-80.0, 0.0, 0.0]                       // Verwenden Sie im Lerp-Modus des vorherigen Frames Lerp auf eine x-Drehung von -80 Grad um 0,8 Sekunden
      }
    }
  ]
}
```


Keyframes[Bearbeiten]

Ein Keyframe definiert zwei Werte für eine kanalspezifische Transformation zu einem bestimmten Bone zu einem bestimmten Zeitpunkt, einen, wenn sich die Zeit der Keyframe-Zeit nähert, und den zweiten ab dieser Keyframe-Zeit.
Wenn Sie also zwischen zwei Keyframes interpolieren, Man kann die Steigung der Animationskurve entweder kontinuierlich oder diskontinuierlich definieren.

Interpolation[Bearbeiten]

Derzeit wird nur lineare Interpolation unterstützt. Die Einstellungen für "Pre" und "Post" des Keyframes ermöglichen die Steuerung der Interpolationskurve bei jedem Keyframe.


Kontinuierliches Beispiel[Bearbeiten]

In diesem Beispiel wird der Knochen "Kopf" in 1 Sekunde um die Drehung der y-Achse 1 gedreht.
Beachten Sie, dass der Kopf bei 0,25 Sekunden um 90 Grad gedreht wird, da die Interpolation linear ist.

"head": {
  "rotation": {
    "0.0":[0, 0, 0],
    "0.5": [ 0, 180, 0],
    "1.0": [0, 360, 0]
  }
}


Diskontinuierliches Beispiel[Bearbeiten]

Diskontinuierlich bedeutet nur, dass es keinen reibungslosen Übergang zwischen Keyframes gibt. Es ist nützlich, wenn Sie möchten, dass sofort etwas passiert.
In diesem Beispiel wird der Knochenkopf skaliert:
1. Von 0 bis 0,5 Sekunden (im "Pre" -Tag) wird der Kopfknochen in allen Dimensionen [X, Y, Z]
2 auf seine normale Skala von 1 eingestellt. Nach 0,5 Sekunden skaliert der Knochen sofort auf das Zweifache seiner normalen Größe
3. Von 0,5 bis 1 Sekunde ("nach") wird der Knochen in allen Dimensionen auf seine normale Größe von 1 zurückskaliert.

Hinweis Im größeren Beispiel oben des Dateiformats "vor" und "post" kann auch durch einen Molang-Ausdruck definiert werden, der diesen Wert zur Laufzeit berechnet, sodass Sie eine mathematisch definierte Kurve haben können, anstatt rein linear zu sein.

"head": {
  "scale": {
    "0.5": {
      "pre": [1, 1, 1],
      "post": 2.0
    }
    "1.0": [ 1.0 ]
  }
}

Animations-Controller[Bearbeiten]

Animations-Controller entscheiden, welche Animationen wann abgespielt werden sollen. Jeder Controller enthält eine Liste von Zuständen, die eine oder mehrere Animationen abspielen, von denen jeder auf Wunsch durch einen Molang-Ausdruck gemischt werden kann. Controller-Dateien werden als JSON im Ordner animation_controllers
gespeichert

Animations-Controller Format:
{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.sheep.move": {
      "states": {
        "default": {
          "animations": [
            { "walk": "query.modified_move_speed" }
          ],
          "transitions": [
            { "grazing": "query.is_grazing" }
          ]
        },
        "grazing": {
          "animations": [ "grazing" ],
          "transitions": [
            { "default": "query.all_animations_finished" }
          ]
        }
      }
    }
  }
}


Zustände[Bearbeiten]

Ein Status definiert eine Gruppe von zu verarbeitenden Animationen (von denen jede ihren eigenen Mischwert haben kann). Jeder Status verfügt über einen optionalen Variablenabschnitt, in dem eine beliebige Anzahl von Variablen aufgelistet ist, die referenzierte Animationen verwenden können. Jeder Status verfügt außerdem über eine oder mehrere Animationen, die den in der Definition json der Entität angegebenen Namen verwenden.

Zustandsvariablen[Bearbeiten]

Variablen werden entweder vom Spiel oder von einem benutzerdefinierten Skript festgelegt, das in der Objektdefinition json unter definitions/entity/<Objektname> .json enthalten ist. Der Wert von Variablen wird durch einen Molang-Ausdruck festgelegt. Sie können ihren Wert auch über eine linear interpolierte Kurve neu zuordnen lassen.

Zum Beispiel:[Bearbeiten]

Dies definiert eine Steuerung mit einem einzelnen Status. Es wird eine Variable `variable.ground_speed_curve` erstellt, die nur auf der Entität lebt, während der Animationscontroller für diesen Frame verarbeitet wird. Es nimmt den Wert von "query.ground_speed" an und ordnet ihn dann zwischen 0,2 und 0,7 neu zu, basierend auf dem Wert von "query.ground_speed" von 0,0 bis 1,0. Es wird ein Animationsspaziergang abgespielt, der von 0,0 bis 1,0 als Die Fahrgeschwindigkeit steigt von gestoppt auf 2,3 m / s. Die Remap-Kurve kann beliebig viele Einträge enthalten. Der Animations-Controller spielt dann die auf Entitäten bezogenen "wiggle_nose" -Animationen ab, gefolgt von der "walk" -Animation, wobei letztere mit dem Wert von "variable.ground_speed_curve" skaliert wird.

```
{
  "format_version": "1.10.0",
  "animation_controllers": {
    "controller.animation.sheep.move": {
      "states": {
        "default": {
          "variables": {
            "ground_speed_curve": {
              "input": "query.ground_speed",
              "remap_curve": {
                "0.0": 0.2,
                "1.0": 0.7
              }
            }
          },
          "animations": [
            "wiggle_nose",
            { "walk": "variable.ground_speed_curve" }
          ]
        }
      }
    }
  }
}
```

Beispiel für ein benutzerdefiniertes Skript[Bearbeiten]

Dieses Skript setzt foo auf das Ergebnis des Sinus von query.life_time, das später in der Animation oder im Animationscontroller verwendet wird.

Hinweis: "pre_animation" weist das Skript an, die Werte dieser Variablen einmal a herauszufinden Frame, bevor die Animation erfolgt, damit die Animation diese Werte in ihren eigenen Formeln verwenden kann. Wenn eine Variable nicht vorhanden war, wird eine neue Variable erstellt und der Standardwert ist 0.0

In definitions\entity\tiger.json: 
{
  "custom:tiger":{
    "scripts":{
      "pre_animation": {
        "variable.foo = math.sin(query.life_time)"
      }
    }
  }
}


Beachten Sie in diesem Beispiel, dass foo einer Sinuswelle entspricht und seine Werte zwischen -1 und 1 liegen. Dies bedeutet, dass Sie eine Periode von 0 bis -1 bis 0 haben, in der nur "base_pose" abgespielt wird und dann eine Gleiche Zeitspanne, in der Walk über base_pose spielt, während foo von 0 auf 1 zurück auf 0 geht. Base_pose hat einen Mischwert von 1,0.

"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [
        // Animationen sind ADDITIV, sofern nicht anders angegeben
        // In diesem Fall wird base_pose immer im Standardzustand abgespielt
        // walk wird ebenfalls abgespielt, wenn Entity.foo größer als 0.0 ist
        "base_pose",
        { "walk": "variable.foo > 0.0" }
      ]
    }
  }
}




Zustandsübergänge[Bearbeiten]

Ein Status kann eine beliebige Anzahl von Übergangsskripten angeben, die nacheinander aufgelistet sind. Jeder Übergang hat einen Zielstatus, zu dem gewechselt werden soll, und ein Skript, ob er wechseln soll oder nicht. Bewerten Sie das Skript für jeden Übergang in der angegebenen Reihenfolge. Wenn es einen Wert ungleich Null zurückgibt, wechseln Sie sofort in den angegebenen Status. HINWEIS: Pro Frame wird nur ein Übergang verarbeitet.

"<controller_name>": {
  "states": {
    "<state_name>": {
      ...
      "transitions": [
        // Die folgenden Ausdrücke der Reihe nach auswerten.
        // Der erste Wert, der ungleich Null zurückgibt, ist der Status, in den übergegangen werden soll.
        // Wenn alle Null sind, dann nicht übergehen.
        { "<target_state_name_A>", "<Ausdruck>" },
        { "<target_state_name_B>", "<Ausdruck>" },
        ...
      ]
    }
  },
  ...
}
Zum Beispiel:
"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [ "base_pose", "walk" ],
      "transitions": [
        { "angry": "query.is_angry" }, // Übergang in den wütenden Zustand, wenn query.is_angry true zurückgibt
        { "tired": "variable.is_tired" } // Übergang in den müden Zustand, wenn variable.is_tired true zurückgibt
      ]
    },
    "angry": {
      "animations": [ "roar", "extend_claws" ],
      "transitions": [
        { "default": "query.any_animation_finished" } // Übergang zurück in den Standardzustand, wenn entweder die Roar-Animation oder die Extend_Claws-Animation beendet ist
      ]
    },
    "tired": {
      "animations": [ "yawn", "stretch" ],
      "transitions": [
        { "default": "query.all_animation_finished" } // Übergang zurück in den Standardzustand, wenn sowohl die Gähnen- als auch die Dehnungsanimationen beendet sind
      ]
    }
  }
}


Zustandsvermischung[Bearbeiten]

Wenn Sie möchten, dass beim Übergang eine Überblendung zwischen Zuständen auftritt, setzen Sie einfach "blend_transition" auf die Zeit, zu der das System die Überblendung zwischen den beiden Zuständen übernehmen soll. Dies erfolgt als einfacher Lerp zwischen den beiden Zuständen über die angegebene Zeit.

Zum Beispiel:
"controller.animation.tiger.move": {
  "states": {
    "default": {
      "animations": [ "base_pose", "walk" ],
      "transitions": [
        { "angry": "query.is_angry" } // Übergang in den wütenden Zustand, wenn query.is_angry true zurückgibt
      ],
      "blend_transition": 0.2          // when transitioning away from this state, cross-fade over 0.2 seconds
    },
    "angry": {
      "animations": [ "roar", "extend_claws" ],
      "transitions": [
        { "default": "query.any_animation_finished" } // Übergang zurück in den Standardzustand, wenn entweder die roar-Animation oder die extend_claws-Animation beendet ist
      ]
    }
  }
}



Render Controller[Bearbeiten]

Der Render Controller benötigt eine Kennung und muss dem Format "controller.render. <Name>" folgen. Dieser Name muss mit dem in JSON für Client-Entitätsdefinitionen festgelegten Namen übereinstimmen.

Mit Render-Controllern kann der Player bestimmen, was auf der Entität gerendert wird. Spieler können die Geometrie, Materialien, Texturen und Teilesichtbarkeit der Entität festlegen. Zusätzlich zum direkten Einstellen der Schlüssel können Spieler mithilfe von Arrays die Entität zwischen verschiedenen Optionen wählen lassen.

Beginnen[Bearbeiten]

Um einen neuen Ordner mit dem Namen "render_controllers" im Stammverzeichnis des Resource Packs zu erstellen, möchten Sie den neuen Render Controller-JSON hinzufügen.

Beispiel für Render-Controller JSON für den Ozelot
"format_version": "1.8.0",
"render_controllers": {
  "controller.render.ocelot": {
    "arrays": {
      "textures": {
        "Array.skins": ["Texture.wild", "Texture.black", "Texture.red", "Texture.siamese"]
      }
    },
    "geometry": "Geometry.default",
    "materials": [{ "*": "Material.default" }],
    "textures": ["Array.skins[query.variant]"]
  }
}


Beispiele[Bearbeiten]

Beispiel Array für Geometrie aus der Schaf JSON Datei
"arrays": {
  "geometries": {
    "Array.geos": ["Geometry.default", "Geometry.sheared"]
  }
},
"geometry": "Array.geos[query.is_sheared]",
Beispiel Array für Materialien aus der Spider JSON Datei
"arrays": {
  "materials": {
    "Array.materials": ["Material.default", "Material.invisible"]
  }
},
"materials": [{ "*": "Array.materials[query.is_invisible]" }], 
Beispiel Array für Geometrie aus der Dorfbewohner JSON Datei
"arrays": {
  "textures": {
    "Array.skins": ["Texture.farmer", "Texture.librarian", "Texture.priest", "Texture.smith", "Texture.butcher"]
  }
},
"textures": ["Array.skins[query.variant]"]
Beispiel mit Farbe zum Abtönen von Teilen aus Armor 1.0 Render Controller JSON:
"format_version": "1.8.0",
"render_controllers": {
		"controller.render.armor.chest.v1.0": {
				"arrays": {
					"materials": {
						"array.armor_material": [
							"material.armor",
							"material.armor_enchanted",
							"material.armor_leather",
							"material.armor_leather_enchanted"
						]
					},
					"textures": {
						"array.armor_texture": [
							"texture.leather",
							"texture.chain",
							"texture.iron",
							"texture.diamond",
							"texture.gold"
						]
					}
				},
				"geometry": "geometry.armor",
				"materials" : [
					{ "body": "array.armor_material[query.armor_material_slot(1)]" },
					{ "leftarm": "array.armor_material[query.armor_material_slot(1)]" },
					{ "rightarm": "array.armor_material[query.armor_material_slot(1)]" }
				],
				"part_visibility" : [
					{ "*": 0 },
					{ "body": "query.has_armor_slot(1)" },
					{ "leftarm": "query.has_armor_slot(1)" },
					{ "rightarm": "query.has_armor_slot(1)" }
				],
				"color": {
					"r": "query.armor_color_slot(1, 0)",
					"g": "query.armor_color_slot(1, 1)",
					"b": "query.armor_color_slot(1, 2)",
					"a": "query.armor_color_slot(1, 3)"
				},
				"textures": ["array.armor_texture[query.armor_texture_slot(1)]", "texture.enchanted"]
		}
}
Beispiel mit overlay_color von Wither Boss Render Controller JSON:
"format_version": "1.8.0",
"render_controllers": {
		"controller.render.wither_boss": {
				"arrays": {
					"textures": {
						"Array.wither_state": ["Texture.invulnerable", "Texture.default"]
					}
				},
				"geometry" : "Geometry.default",
				"materials" : [{ "*": "Material.default" }],
				"textures" : ["Array.wither_state[variable.display_normal_skin]"],
				"overlay_color" : {
					"r": "variable.is_invulnerable ? 1.0 : this",
					"g": "variable.is_invulnerable ? 1.0 : this",
					"b": "variable.is_invulnerable ? 1.0 : this",
					"a": "variable.is_invulnerable ? query.overlay_alpha : this"
				}
		}
}
Beispiel mit part_visibility zum Ein- und Ausschalten der Sichtbarkeit von Teilen von Llama JSON:
"format_version": "1.8.0",
"render_controllers": {
  "controller.render.llama": {
    "arrays": {
      "textures": {
        "Array.base": ["Texture.creamy", "Texture.white", "Texture.brown", "Texture.gray"],
        "Array.decor": ["Texture.decor_none", "Texture.decor_white", "Texture.decor_orange", "Texture.decor_magenta", "Texture.decor_light_blue", "Texture.decor_yellow", "Texture.decor_lime", "Texture.decor_pink", "Texture.decor_gray", "Texture.decor_silver", "Texture.decor_cyan", "Texture.decor_purple", "Texture.decor_blue", "Texture.decor_brown", "Texture.decor_green", "Texture.decor_red", "Texture.decor_black"]
      }
    },
    "geometry": "Geometry.default", 
    "part_visibility": [{ "chest*": "query.is_chested" }],
    "materials": [{ "*": "Material.default" }],
    "textures": [
      "Array.base[query.variant]",
      "Array.decor[variable.decor_texture_index]",
      "Texture.decor_none"
    ]
  }
}

HINWEIS: Die Arrays für die Sichtbarkeit von Materialien und Teilen werden in der angegebenen Reihenfolge angewendet. Die später in der Datei angegebene Sichtbarkeit von Materialien und Teilen überschreibt frühere Materialien oder Teile.

Beispiel für ein Materialarray von Horse Render Controllern. Der Sattel überschreibt die Mähne, wodurch TailA usw.:
"materials": [
  { "*": "Material.default" },
  { "TailA": "Material.horse_hair" },
  { "Mane": "Material.horse_hair" },
  { "*Saddle*": "Material.horse_saddle" }
],

Siehe auch[Bearbeiten]