xiaokun/netease-modsdk-wiki
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

搬运一批Bedrock wiki内容，完善翻译

Browse Source
This commit is contained in:
boybook
2025-03-20 00:13:44 +08:00
parent ead7392a76
commit 4896c1a4f2
163 changed files with 33930 additions and 1464 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
docs/wiki/visuals/animated-entity-texture.md Normal file
View File

@@ -0,0 +1,123 @@
---
title: Entity Texture Animations
mentions:
- MedicalJewel105
- IlkinQafarov
- TheItsNameless
- SmokeyStack
tags:
- intermediate
category:
- Tutorials
---
## Whats on this page?
From this page you will learn how to make an animated texture for an entity. Animated, like a flipbook texture for blocks.
## Source
This page is based on content by [AgentMindStorm](https://www.youtube.com/channel/UC-ljddYkFdTQl-MVEaVvbuQ).
<YouTubeEmbed
id="F6e-w1rCEi4"
/>
## Textures
First let's draw some new texture frames for our entity. In this tutorial it will be a cow, which is looking around.
<WikiImage
src="/assets/images/visuals/animated-entity-texture/cow.png"
alt="cow"
pixelated="false"
width=180
/>
We need to place our textures vertically, like for blocks in flipbook textures.
In this case we have 4 frames.
## Materials
We will need to modify materials in this guide. However due to render dragon materials became outdated, so **use it at your own risk**.
To use animated texture, we need to change the entity material to one, that has `USE_UV_ANIM` property.
Let's simply add a new material:
<CodeHeader>RP/materials/entity.material</CodeHeader>
```json
{
"materials":{
"version":"1.0.0",
"custom_animated:entity":{
"+defines":[
"USE_UV_ANIM"
]
}
}
}
```
Or you can add this to existing ones, check default material file.
<CodeHeader></CodeHeader>
```json
"+defines":[
"USE_UV_ANIM"
]
```
<BButton
link="/assets/packs/visuals/animated-entity-texture/entity.material" download
color=default
>Download default entity.material file</BButton>
:::warning
It is not that easy for every entity!
Some entities have multiple materials and if you want to make its texture animated, you will need to add this property to all materials of this entity.
:::
## Client Entity File
Before we go next, we need to define a new material in our client entity file.
<CodeHeader>RP/entity/cow.json#description</CodeHeader>
```json
"materials": {
"default": "custom_animated"
}
```
## Render Controllers
After that all, we need to edit a render controller.
Here we will add `uv_anim` component with offset and scale properties:
<CodeHeader>RP/render_controllers/cow.render_controllers.json#controller.render.cow</CodeHeader>
```json
"uv_anim": {
"offset": [ 0.0, "math.mod(math.floor(q.life_time * frames_per_second),frame_count) / frame_count" ],
"scale": [ 1.0, "1 / frame_count" ]
}
```
Where `frames_per_second` is a count of frames you want to change in one second and `frame_count` is a total frame count.
This formula calculates the offset and the size of the texture depending on life time.
## Testing
Now, it is time to test your creation!
![](/assets/images/visuals/animated-entity-texture/result.gif)
## Download Example
<BButton
link="https://github.com/Bedrock-OSS/wiki-addon/releases/download/download/animated_entity_texture.mcpack"
color=blue
>Download</BButton>

181
docs/wiki/visuals/animation-effects.md Normal file
View File

@@ -0,0 +1,181 @@
---
title: Effects in Animations
mentions:
- MedicalJewel105
category:
- General
---
## Effects in Animations
Sometimes it is much easier to use particles or sounds in animation rather than in animation controller.
Animations can have effects in them, such as:
- Particles
- Sounds
### Particles
Minecraft Particles can be used in entity animations. For example, the phantom has an animation which emits the minecraft:phantom_trail particle constantly. Let's try to add a particle to our entity's attack animation.
<CodeHeader>RP/entity/my_entity.json</CodeHeader>
```json
"particle_effects": {
"flames": "minecraft:mobflame_emitter"
}
```
Here we defined a shortname for particle that we are going to use.
You can find a list of particles [here](https://minecraft.wiki/w/Particles) or [here](/particles/vanilla-particles).
:::warning Warning!
Not every particle works there. If you have problems, consider trying another particle. For example, use this one.
Also note that some particles emit constantly.
:::
### Sounds
If you want to use a sound, you need to define it too.
<CodeHeader>RP/entity/my_entity.json</CodeHeader>
```json
"sound_effects": {
"meow": "mob.cat.meow"
}
```
:::warning Warning!
Not every sound works there. If you have problems, consider trying another sound. For example, use this one.
:::
## Adding Effects to Animation
You can add particles or sounds to your animation mainly or in Blockbench.
### Mainly
You need to add the following to your animation:
<CodeHeader>RP/animations/my_animation.json#my.animation</CodeHeader>
```json
"particle_effects": {
"0.0": {
"effect": "flames",
"locator": "" //You need to add a locator in your model
}
}
```
<CodeHeader>RP/animations/my_animation.json#my.animation</CodeHeader>
```json
"sound_effects": {
"0.0": {
"effect": "meow"
}
}
```
You can call more than one particle at the same time:
```json
"particle_effects": {
"0.0": [
{
"effect": "particle_1",
"locator": "locator_1"
},
{
"effect": "particle_2",
"locator": "locator_2"
}
]
}
```
<Spoiler title="Example">
<CodeHeader>RP/animations/my_animation.json</CodeHeader>
```json
{
"format_version" : "1.8.0",
"animations" : {
"animation.sheep.grazing" : {
"animation_length" : 2.0,
"loop" : true,
"particle_effects": {
"0.0": {
"effect": "flames",
"locator": "body"
}
},
"sound_effects": {
"0.0": {
"effect": "meow"
}
},
"bones" : {
"head" : {
"position" : {
"0" : [ 0.0, 0.0, 0.0 ],
"0.2" : [ 0.0, -9.0, 0.0 ],
"1.8" : [ 0.0, -9.0, 0.0 ],
"2" : [ 0.0, 0.0, 0.0 ]
},
"rotation" : {
"0.2" : {
"post" : [ "180.0 * (0.2 + 0.07 * math.sin(q.key_frame_lerp_time * 1644.39))", 0.0, 0.0 ],
"pre" : [ 36.0, 0.0, 0.0 ]
},
"1.8" : {
"post" : [ 36.0, 0.0, 0.0 ],
"pre" : [ "180.0 * (0.2 + 0.07 * math.sin(q.key_frame_lerp_time * 1644.39))", 0.0, 0.0 ]
}
}
}
}
}
}
}
```
</Spoiler>
### In Blockbench
First let's add a locator for our particle. Go to "Edit" section, select a group, right-click and choose "Add Locator":
![](/assets/images/visuals/animation-effects/add-locator.png)
Rename it and move where you want.
Then go to "Animate" section, choose an animation and click on a magic stick icon:
![](/assets/images/visuals/animation-effects/add-effect.png)
Now click "+" to open menu and specify the data:
![](/assets/images/visuals/animation-effects/specify-data.png)
You can attach a sound to animation the same way.
Now save your animation and launch the game!
![](/assets/images/visuals/animation-effects/showcase.png)
## Offscreen Updating
You can set `"should_update_bones_and_effects_offscreen"` to `true` inside entity rp scripts for particle and sound effects to update offscreen, by default both of them will stop playing if the entity isn't being rendered on display.
<CodeHeader>RP/entity/my_entity.json#description</CodeHeader>
```json
"scripts": {
"should_update_bones_and_effects_offscreen": true
}
```

122
docs/wiki/visuals/bedrock-modeling.md Normal file
View File

@@ -0,0 +1,122 @@
---
title: Bedrock Modeling
nav_order: 2
category:
- General
mentions:
- SirLich
- solvedDev
- MedicalJewel105
---
This will guide tips, tricks, and things you should know when modeling for Minecraft Bedrock Edition.
## Texture Glitch
Sometimes the texture on some (smaller) faces is glitched or invisible. This is because the size of cubes is floored for the UV map calculation. This means that any size smaller than 1 will result in a 0 pixel wide UV map, which will look glitchy. To prevent this, make sure all of your cubes are at least 1 unit long in each direction. To create smaller cubes, use the Inflate slider.
Another trick to solve this if you _must_ have smaller textures is by **increasing the element size by 1 in each direction** and then **inflating the element by -1** though note that this will make you have smaller pixels textured incorrectly will lead to mixels.
## Vertex Snap
Vertex snap is a handy tool in blockbench any modeler should use. It's beneficial when doing rounded things like wheels.
You can find this tool right top next to the movement & scale tools. It has 2 modes, Move & Scale. How this tool works can be seen in the following gif.
![](/assets/images/visuals/bedrock-modeling/vertex_snap.gif)
## Transparency
If you use semi-transparent textures (like colored glass), you need to move elements with that texture to the bottom of the element list. Otherwise, elements behind these semi-transparent ones won't render in-game.
## Texturing
When learning to texture, your best bet is practicing with references on how others textured similar objects & surfaces. Patterns for wood & metal are different, and you should consider that. Good guides are
[Masteriano's Texturing Tips](https://www.blockbench.net/wiki/guides/minecraft-style-guide)
and in general, any on pixel art.
## Materials
Whether or no the transparency or emissive textures in your models work in-game, it's decided by the materials applied to them.
| Material | Description |
| --------------------- | -------------------------------------------------------------------------------------------------------- |
| entity | basic opaque material |
| entity_alphatest | supports transparent pixels |
| entity_alphablend | supports translucent pixels |
| entity_emissive | solid, alpha channel is used as the emissive channel |
| entity_emissive_alpha | alpha channel is used for emissiveness, completely black + transparent pixels are rendered transparently |
## Z-fighting
Z-fighting is called when you have the face of 2 elements in the same place, and you can see both or half of them at the same time, as seen in the following picture.
![](/assets/images/visuals/bedrock-modeling/z-fighting.png)
You can solve this by inflating one of them by `0.01` or `-0.01` depending on which one should prioritize.
## Basics of Animations
When animating in Blockbench, you can set each keyframe by hand, or you can use variables & functions.
Here you will learn the basics.
Let's start with this picture.
![](/assets/images/visuals/bedrock-modeling/animations-1.png)
the name or `animation.cuack` is essential. You can't have symbols or caps there, and it must start with `animation.` for the animations to work without problems. Now the function we will be using is
`Base + Math.sin((q.life_time + Offset) * Speed) \_ pitch`
- Base is the starting rotation/position the bone has
- Sin is the math function we all know
- `q.life_time` is a variable. Is a number that will be increasing as the animation continues
- Offset is a number we use to have the animation start earlier or later than its "original" position
- Speed is the time it will take from going from top to down
- Pitch is how far it goes from the origin
![](/assets/images/visuals/bedrock-modeling/animations-2.gif)
Function used:
`Math.sin((q.life_time+0.5)*150)*15`
one on position & the other on rotation.
<MolangGraph code="Math.sin((q.life_time+0.5)*150)*15" :toY="2" :stepSize="0.001"/>
Don't forget that for the animation to be a perfect loop. It would help if you correlated the sin equation `speed` & the animation `time`.
Here's a table with values to get a perfect loop, though there are more you can discover.
| Speed | Time | Group |
| ----- | ---- | ----- |
| 150 | 2.4 | 1 |
| 100 | 3.6 | 2 |
These numbers can be multiplied but not divided, so these will also work
But only multiples of the same option
| Speed | Time | Group |
| ----- | ---- | ----- |
| 150 | 4.8 | 1 |
| 200 | 3.6 | 2 |
| 300 | 2.4 | 1 |
| 300 | 3.6 | 1 & 2 |
Now not all of these will "loop" together. And that is the Group column. The ones with the same number will work together. Otherwise, they will have a visible "glitch" in the loop.
:::tip
You can have an animation in the loop by clicking on the following setting:
![](/assets/images/visuals/bedrock-modeling/setting-loop.png)
:::
With this function & creativity, animals & dinosaurs are animated into walking, running & attacking.
You can learn more about queries & functions [here](https://bedrock.dev/docs/stable/Molang).
## Animation Speed
To easily change the speed of an animation you can simply multiply the default value of `anim_time_update` (defaults to `q.delta_time + q.anim_time`) inside our animation:
<CodeHeader>RP/animations/myentity.animation.json#animations</CodeHeader>
```json
"animation.myentity.myanimation": {
"anim_time_update":"2 * q.delta_time + q.anim_time"
//Your animation goes here!
}
```
This will make the animation run 2 times faster. We can tweak the value to any buoyant float, so we can even slow down animations. With 0.5, for example, the animation will run 2 times slower, etc.

137
docs/wiki/visuals/custom-skin-packs.md Normal file
View File

@@ -0,0 +1,137 @@
---
title: Skin Packs
mentions:
- MedicalJewel105
- SirLich
- Joelant05
- TheItsNameless
category:
- General
---
Many people wrongly assume that skin packs are only available for creation to Marketplace Partners. No! It's a very easy process, which can easily be fully automated by python. But that's not it. Let's learn how to make a skin pack!
:::warning
The `development_skin_packs` doesn't seem to function correctly. You need to use `skin_packs` folder and reload Minecraft every time you made a change.
:::
## What is needed
Here is what is needed:
<FolderView
:paths="[
'com.mojang/skin_packs/my_skin_pack/texts/en_US.lang',
'com.mojang/skin_packs/my_skin_pack/my_skin.png',
'com.mojang/skin_packs/my_skin_pack/manifest.json',
'com.mojang/skin_packs/my_skin_pack/skins.json'
]"
></FolderView>
## manifest.json
<CodeHeader>skin_packs/tutorial_skin_pack/manifest.json</CodeHeader>
```json
{
"format_version": 2,
"header": {
"name": "Tutorial Skin Pack",
"uuid": "bb9616eb-327c-4a81-9f00-064cae820cd5",
"version": [
1,
0,
0
]
},
"modules": [
{
"type": "skin_pack",
"uuid": "e4bc71b6-8f9b-4094-9d47-dc3824f8a3dc",
"version": [
1,
0,
0
]
}
]
}
```
- `format_version` can be 1 too, as v2 doesn't change much for skin packs.
- `name` is self explanatory. However, it isn't of great importance.
- `uuid` and `version` are already familiar to us. Both UUIDs in the manifest need to be different. You can generate them via a generator linked in [useful links](/meta/useful-links). As a reminder, you CANNOT use the same UUID TWICE.
- `type` in `modules` needs to be set to `skin_pack`, of course.
## skins.json
This file is used to define textures and shortnames for skins. Most of the options are, however, hard-coded or unchangeable.
<CodeHeader>skin_packs/tutorial_skin_pack/skins.json</CodeHeader>
```json
{
"geometry": "geometry.json",
"serialize_name": "Tutorial Skin Pack",
"localization_name": "tutorial",
"skins": [
{
"localization_name": "tutorial_skin_1",
"geometry": "geometry.humanoid.custom",
"texture": "goggled_gecko_no_goggles.png",
"type": "free"
},
{
"localization_name": "tutorial_skin_2",
"geometry": "geometry.humanoid.customSlim",
"texture": "goggled_gecko.png",
"type": "free"
}
]
}
```
- The `geometry` object must be the same as on the example code in every object. Mojang removed the ability to add custom geometries via skin packs, because the feature was abused.
- `serialize_name` is for marketplace.
- `localization_name` is a pack identifier. **Don't use in other skin packs** as it affects translations.
- `skins` array, where you define your each skin. The skins will be displayed in the same order in minecraft as they are defined here.
> - `localization_name` is going to be used in the .lang file. Think of it as the skins identifier.
> - `geometry` you can use `geometry.humanoid.custom` and `geometry.humanoid.customSlim` here.
> - `texture` is the name of the image file, located in the main skin pack folder.
> - `type` is only accessible to marketplace partners, leave it as `free`, otherwise it will be locked.
## texts/en_US.lang
Finally, we'll define the names of the skin pack and every skin in the `.lang` file. Of course "en_US" can be replaced with any language.
<CodeHeader>skin_packs/tutorial_skin_pack/texts/en_US.lang</CodeHeader>
```
skinpack.tutorial=Tutorial Skin Pack
skin.tutorial.tutorial_skin_1=Skin 1
skin.tutorial.tutorial_skin_2=Skin 2
```
The first line defines the pack's name itself. It's done in this format:
`skinpack.[pack localization_name]=Actual Pack Name`
The other lines define the skins' names:
`skin.[pack localization_name].[skin localization_name]=Actual Skin Name`
Done! Now, when you open Character Creator, you'll see your skins available to be chosen!
## Troubleshooting
If you play on MC version lower than 1.18.30, you might experience a bug when "Equip" button is not showing. You need to download a special texture pack.
![](/assets/images/visuals/skin-packs/troubleshooting-1.png)
<BButton
link="/assets/packs/visuals/skin-packs/equip_button_fix.mcpack" download
color=default
>Download Equip Button Fix</BButton>
![](/assets/images/visuals/skin-packs/troubleshooting-2.png)

390
docs/wiki/visuals/death-animations.md Normal file
View File

@@ -0,0 +1,390 @@
---
title: Custom Death Animations
tags:
- intermediate
category:
- General
mentions:
- SirLich
- Joelant05
- Dreamedc2015
- MedicalJewel105
- aexer0e
- Xterionix
- ChibiMango
- SmokeyStack
- ThomasOrs
---
Death animation refers to the rotation of the entity as it dies. This is accompanied by a red coloring and followed shortly after by the disappearance of the entity geometry and the appearance of the death particles.
## Cancelling Death Animations
This part will explain how to remove death animations at all.
### Teleporting the Entity
A fairly common way to remove entities without causing death effects is to teleport them into the void. This can be done from animation controllers by using `!q.is_alive` like:
`/teleport @s ~ ~-1000 ~`
Please note that this will remove all death effects, including sound, particles, loot, and the visual death of the entity.
### minecraft:instant_despawn
If you want to make entity just disappear, you can add component group with `"minecraft:instant_despawn":{}` and run an event which will add this component group.
Please note that this will remove all death effects, including sound, particles, loot, and the visual death of the entity.
### Transformation to another entity
Similar to teleporting, the entity is triggering an entity transform on death. Use `!q.is_alive` in animation controller to send an event which will add component group with `"minecraft:transformation"` component. With this component entity will convert into another:
<CodeHeader></CodeHeader>
```json
"minecraft:transformation": {
"into": "wiki:death_animation_entity",
"transformation_sound" : "converted_to_zombified",
"keep_level": true,
"drop_inventory": true,
"preserve_equipment": false,
"drop_equipment": true,
"delay": {
"block_assist_chance": 0.0,
"block_radius": 0,
"block_max": 0,
"value": 10
}
}
```
### Cancelling the Animation
We can also cancel the rotational value of the entity, allowing the entity to die more conventionally (particles, red-coloring, loot) without the 90-degree spin.
If you need more information about triggering animations from entity death, see [this document](/animation-controllers/death-commands) on death effects.
Rotation needs to be applied to a bone parent to all other bones, with a pivot at [0,0,0], and the animation should only start when `!q.is_alive`.
Animation:
<CodeHeader></CodeHeader>
```json
"rotation" : [ 0, 0, "Math.min(Math.sqrt(Math.max(0, q.anim_time * 20 - 0.5) / 20 * 1.6), 1) * -90" ]
```
Animation Controller:
(q.all_animations_finished is only needed for respawning entities, like players)
<CodeHeader>RP/animation_controllers/custom_death.animation.controllers.json</CodeHeader>
```json
{
"format_version": "1.10.0",
"animation_controllers": {
"controller.animation.player.cancel_death_animaton": {
"initial_state": "default",
"states": {
"default": {
"transitions": [
{
"cancel_animation": "!q.is_alive"
}
]
},
"cancel_animation": {
"animations": ["my.animation"],
"transitions": [
{
"default": "q.is_alive && q.all_animations_finished"
}
]
}
}
}
}
}
```
Note that you will need attach animation and animations controller in `.entity.json` file of resource pack.
## Custom Death Animations
This part will explain how to customize death animation.
### Changing Damage Color Overlay
You can remove/customize entity damage color overlay.
Before starting, you must have the basics of render controller so check out the [tutorial](/entities/render-controllers) of render controllers.
To remove the damage overlay color of any entity you want when it gets damaged, we will use `is_hurt_color` and remove the damage overlay color when an entity receives damage from lava or fire use `on_fire_color`.
First, you need to make the rgba values to 0
Here's the example of removing the damage and fire overlay color.
<CodeHeader>RP/render_controllers/custom_death.render_controllers.json</CodeHeader>
```json
{
"format_version": "1.8.0",
"render_controllers": {
"controller.render.sample": {
"geometry": "Geometry.default",
"materials": [{ "*": "Material.default" }],
"textures": ["Texture.default"],
"is_hurt_color": {},
"on_fire_color": {}
}
}
}
```
The code above will remove the red damage overlay color.
You can also change the damage color overlay to different colors just by putting different values in rgba. You can check out various websites to get the rgba values of all colors.
Here's another example in which the damage color overlay becomes pink.
<CodeHeader>RP/render_controllers/custom_death.render_controllers.json</CodeHeader>
```json
{
"format_version": "1.8.0",
"render_controllers": {
"controller.render.kbg": {
"geometry": "Geometry.default",
"materials": [{ "*": "Material.default" }],
"textures": ["Texture.default"],
"is_hurt_color": {
"r": "1.0",
"g": "0.4",
"b": "0.7",
"a": "0.5"
},
"on_fire_color": {
"r": "1.0",
"g": "0.4",
"b": "0.7",
"a": "0.5"
}
}
}
}
```
### Using Damage Sensor to Trigger Instant Despawn and One Item Drop
You can use the damage_sensor component to trigger an event upon fatal damage; this event adds a particular despawning component group containing the spawn_entity and instant_despawn components. Spawn_entity with 0 wait time will drop an item just before the entity is despawned. For simple entities like furniture, which only need one item, this is very convenient.
When an entity recieves fatal damage, an event is triggered that adds a dummy component. We can then use this dummy component to play the animation and using `minecraft:timer` we can have it despawn.
Please note that you will have to find another work for entities with an inventory. You should also ensure that the despawn component group is not added when the entity is spawned using the entity_spawned event. If you have a entity that performs other actions (movement and attacks) you will likely want to remove those components as well.
Here an example file in the BP
<CodeHeader>BP/entities/entity.json</CodeHeader>
```json
{
"format_version":"1.14.0",
"min_engine_version":"1.16.100",
"minecraft:entity":{
"description":{
"identifier":"wiki:entity",
"is_spawnable":true,
"is_summonable":true,
"is_experimental":true
},
"component_groups":{
"wiki:death":{
"minecraft:spawn_entity":{
"max_wait_time":0,
"min_wait_time":0,
"spawn_item":"egg",
"single_use":true
},
"minecraft:is_sheared":{},
"minecraft:timer":{
"looping":true,
"time":[
2.56,
2.56
], // Change this to match your animation's time
"time_down_event":{
"event":"wiki:despawn"
}
}
},
"wiki:despawn":{
"minecraft:instant_despawn":{}
}
},
"components":{
"minecraft:type_family":{
"family":[
"cart",
"inanimate"
]
},
"minecraft:collision_box":{
"width":0.8,
"height":0.5
},
"minecraft:health":{
"value":8,
"max":8
},
"minecraft:physics":{},
"minecraft:pushable":{
"is_pushable":true,
"is_pushable_by_piston":true
},
"minecraft:damage_sensor":{
"triggers":{
"on_damage":{
"filters":{
"all_of":[
{
"test":"has_damage",
"value":"fatal"
}
]
},
"target":"self",
"event":"wiki:death",
"deals_damage":false,
"cause":"fatal"
}
}
}
},
"events":{
"wiki:death":{
"add":{
"component_groups":[
"wiki:death"
]
},
"wiki:despawn":{
"add":{
"component_groups":[
"wiki:despawn"
]
}
}
}
}
}
}
```
Here an example file for the animation controller.
<CodeHeader>RP/animation_controllers/animation_controller.entity.json</CodeHeader>
```json
{
"format_version": "1.10.0",
"animation_controllers": {
"controller.animation.entity": {
"states": {
"default": {
"blend_transition": 0.2,
"transitions": [
{
"dead": "q.is_sheared"
}
]
},
"death": {
"blend_transition": 0.2,
"animations": [
"death"
]
}
}
}
}
}
```
Note: You can also spawn custom spawn egg items using the `minecraft:spawn_entity` component by setting `"spawn_item"`
to be your entity's id and an affix of `spawn_egg`, and it will look something like this.
<CodeHeader>BP/entities/my_entity.json#components</CodeHeader>
```json
{
"minecraft:spawn_entity": [
{
"min_wait_time": 0,
"max_wait_time": 0,
"spawn_item": "wiki:custom_zombie_spawn_egg",
"single_use": true
}
]
}
```
If you want to drop a loot table, you can trigger an event (as shown below) and summon another entity that have this component:
<CodeHeader></CodeHeader>
```json
{
"minecraft:behavior.drop_item_for":{
"seconds_before_pickup":0.0,
"cooldown":5,
"drop_item_chance":1,
"offering_distance":0.0,
"minimum_teleport_distance":1024.0,
"target_range":[
64.0,
64.0,
64.0
],
"teleport_offset":[
0.0,
1.0,
0.0
],
"speed_multiplier":1.0,
"search_range":64,
"search_height":64,
"search_count":0,
"goal_radius":64.0,
"entity_types":[
{
"filters":{
"test":"is_family",
"subject":"other",
"value":"player"
},
"max_dist":64
}
],
"priority":1,
"loot_table":"loot_tables/entities/example.loot_table.json",
"time_of_day_range":[
0.0,
1.0
]
},
"minecraft:timer": {
"time": 2,
"time_down_event": {
"event": "wiki:my_despawn_event"
}
}
}
```
And then despawn it through adding component group with instant_despawn through `wiki:my_despawn_event`.
### Detecting Death with Commands
<BButton
link="/commands/tick_json-creations#death-detection"
color=blue
>View</BButton>

248
docs/wiki/visuals/deferred-qna.md Normal file
View File

@@ -0,0 +1,248 @@
---
title: Deferred Technical Preview Q&A 2024/02/23
mentions:
- SmokeyStack
---
This Q&A took place in the [Bedrock Add-Ons discord](https://discord.gg/uZF75ZxcJq). Six Mojang/Microsoft employees joined us to answer questions about the Deferred Technical Preview API. Questions were community sourced.
:::warning
Not all messages were copied over, and some were copy-edited. If you want to see everything, join the above discord, and get the "events archive" role.
:::
## How Long Has the Deferred Rendering Pipeline Been in Development
- **Q**: How long has the Deferred Rendering Pipeline been in development? What were the challenges in making this pipeline?
- **A**: The Deferred pipeline has been in development in various forms since 2020. Parts of it were born out of optimizations to the RTX pipeline but other parts were born out of the pipeline used for Minecraft Legends. Development started in earnest in March of 2022.
## Supported Platforms
- **Q**: Will any platforms not be supported?
- **A**: There's no official announcements right now on what will or will not be supported. As mentioned in another thread, we aim to make deferred as widely available as possible on devices that can support it, but ensure that the visuals and perf are where they should be for a good playing experience.
- **Q**: I solely play Minecraft on my phone and ray tracing, shaders, etc look so cool! But I have never been able to experience them 😞 Will deferred lighting be available for Android devices?
- **A**: Yes! The deferred preview is currently available on Android and can be accessed as part of the Beta program. Also available in Preview on Xbox, iOS, and PC!
- **Q**: Is deferred available on chrome book?
- **A**: We don't have any news to share on when new platforms will be available right now, but we are definitely testing and looking into adding additional platforms that can handle deferred. We want to make sure as many players as possible can experience the new graphics mode but also that the playing experience will be solid.
## Molang in Deferred Rendering
- **Q**: Please add the ability to use Molang queries in global.json or any other files! It would be useful for detecting specific moon phases and create local/unique experiences!
- **A**: Appreciate the suggestion, but we don't have any news to share on Molang integration right now. We have quite a few constraints with perf and other things that we have to be mindful of with deferred.
## Features Left
- **Q**: How many features are left for deferred?
- **A**: There's some hints across the other threads, but I'll make a cheat sheet here 🙂
Right now, in the works to share with you we have: Color grading, Water lighting + movement, Subsurface scattering, Reflections, and Texture Set support for Items and particles.
## Optimization
- **Q**: I wonder when optimization for deferred will begin aajabrams said it would be when y’all get all of deferreds features implemented but idk when that is.
- **A**: AJ is right, we're definitely working on getting all the features out before really hammering at optimizations. No timeline to share right now, but definitely on our roadmap!
## Pom Effects
- **Q**: Will Pom Effects Such As Paralax Be Added?
- **A**: We don't have anything to share on POM techniques at this time, but thank you for the suggestion!
## Deferred PBR
- **Q**: Can you expand deferred PBR capabilities with e.g. subsurface scattering, porosity, POM/tessellation, etc.?
- **A**: Been answered in a few places already, mostly here: https://discord.com/channels/523663022053392405/1209533667224068188/1210658737103048805
- **A**: Yes! We will be expanding the current model to include a Sub Surface Scattering approximation, and we will also be enabling a unique lighting model for water geometry. Water will operate on properties like how much algae is present.
- **Q**: "unique lighting model for water geometry" what about POM/tessellation for blocks?
- **A**: We don't have any plans regarding POM/tessellation to share at this time. Thank you for the suggestion, though!
## Super Duper Graphics Pack Cancellation
- **Q**: Why was the super duper graphics package canceled?
- **A**: This [link](https://www.minecraft.net/en-us/article/super-duper-graphics-pack-ceasing-development) is probably still the best info for what happened with SDGP.
## Data Driven Renderer Folder
- **Q**: Will the renderer folder be exposed for us to use in resource packs? Doing so will allow many unique packs and configs for creators to experiment with.
- **A**: Not the renderer folder itself, but there will be more data-driving capabilities that we expose to resource packs over time, yes.
## Weirdest Bugs
- **Q**: What is the weirdest rendering bug you have seen while developing the Deferred Rendering Pipeline?
- **A**: Early experiments with indirect specular ended up lighting the whole scene! ![](/assets/images/visuals/deferred-qna/deferred-qna-media1.gif)
- **A**: We also see NaNs that get seeded and sometimes spread through the world. Don't divide by zero, friends. 😉 ![](/assets/images/visuals/deferred-qna/deferred-qna-media2.png)
- **A**: Who's that ~~Pokemon~~ Minecraft mob? ![](/assets/images/visuals/deferred-qna/deferred-qna-media3.png)
- **A**: No screenshot, but another was when we had phantom shadows from mobs on the other side of the world! At first we thought they were mobs with invisibility status and their shadow just needed to be hidden, but the corresponding mob was sometimes 1000s of blocks away with no invisibility! Ended up being a transform-inversion issue. That was a fun one to track down.
## Light Contrast and Saturation For the Sun/Moon and Pointlight
- **Q**: Will deferred ever see the likes of contrast and/or saturation control for all lights? For example increasing the contrast and/or saturation for colors from the sun/moon to have more bright and/or a somewhat vibrant color, or increasing Saturation for colors to standout.
I have noticed that colors from the sun is quite dull, and not even changing the tone-mapper helps a bit.
- **A**: Not per light source, but, like Veka mentioned, we will be doing it on the full scene as part of tonemapping. And why stop at contrast and saturation? We are working on a full HDR color grading suite, complete with contrast, saturation, gain, offset and split-tone grading. This feature will be data-drivable in your resource packs.
## Focus Parameter
- **Q**: Will a focus mode be added to the Object ?
- **A**: We don't have anything to share regarding focus or other camera-related properties at this time. Thank you for the suggestion!
## Customizable Clouds
- **Q**: As of right now, Clouds are not really customizeable for deferred, is there plans to add volumetric Clouds.
- **A**: No plans on clouds to share right now, but appreciate the suggestion here! Definitely lots to explore here.
- **Q**: Will deferred have a multiple clouds layers like SDGP as config? that's feels more like aesthetic things that might gonna fit well with some packs.
- **A**: Thanks for the suggestion! Nothing to share right now on clouds
## Any Plans for Deferred to be Scriptable
- **Q**: When client side apis come out, are their any plans to add a api for deferred to allow us to manipulate it through scripting?
- **A**: The answer to this is similar to our Molang response: https://discord.com/channels/523663022053392405/1209532356403142656
> Appreciate the suggestion, but we don't have any news to share on Molang integration right now. We have quite a few constraints with perf and other things that we have to be mindful of with deferred.
## Global Illumination
- **Q**: Are there any plans for implementing some form of global illumination? Something for more accurate skylight, reflected sunlight or ambient blocklight. Perhaps you already have a specific technique in mind? 👀
- **A**: Global Illumination is such a broad topic, so technically the answer is, yes! More specifically, we are working on adding reflections, both IBL-based and screen-space. We have discussed many other forms of GI internally, but don't have anything to share on other applications at this time.
## Is the graphical team fully dedicated to the DRP?
- **Q**: This is an indirect way to ask if we can finally have some non-official confirmation that a certain other graphical system we have explicitly asked not to talk about in <#1208794326361055324> is not being worked on at all by the team.
Actually also curious what percentage of the graphics team is dedicated to the DRP knowing that there are at the same time a fair number of graphical bugs, quirks and optimizations to be had in the base RenderDragon.
- **A**: No. The graphics team owns initiatives like DTP, but also is responsible for maintaining the RenderDragon engine as well as the rendering of the core game. We do have a dedicated group of engineers within the graphics team that is fully dedicated to the DTP however.
## Accurate Sky Model
- **Q**: As of right now , deferred uses vanilla style sky model which stitches the moon and sun sky semi globes together which is fine for vanilla but looks unappealing in deferred and causes issues when stitching the sky in deferred.
Are there any plans you have in mind to deal with it?
- **A**: Thanks for the feedback! There are definitely some visual bugs and enhancements to the sky we've got to buff out. 🙂
## Unique Techniques and Features
- **Q**: Were there any graphical techniques developed in-house rather than relying on existing solutions? For example, deferred atmosphere seems quite unique, was it created from scratch or is it an implementation of already existing model?
- **A**: Many of the techniques we've employed are derived from whitepapers and talks presented at various technical conventions (like Siggraph, GDC, etc.), so nothing we've done is technically truly novel (this is usually the case for Graphics development in the game industry in general).
That said, we've put a Minecraft specific slant on many of the techniques employed to ensure parity with Vanilla lighting (e.g. light falls off in a similar way, some visual emphasis on "blockiness", scenes that are dark in Vanilla lighting look dark in Deferred lighting too, etc.)
There are also opportunities for novel approaches (like lighting in the nether/end dimensions) but at this time we don't have any additional information we can share.
## Deferred Upscaling
- **Q**: Could you implement other optional upscaling techniques (like AMD FSR or Intel XeSS) and sharpness slider like many games that implement upscaling
- **A**: Thanks for the suggestion, it could be valuable for performance. We'll be taking this into consideration!
## Better Water
- **Q**: Deferred now still uses the default water from the initial release in the preview and there are only a few changes, so will there be additional features such as screenspace reflection, caustic, waves and underwater effects which are much better than before?
- **A**: Yes! We are definitely working on updating the water lighting model and other effects in deferred. These are some great suggestions, and would love to hear more about what other effects and control you'd like to have with water in the deferred preview!
** A**: These are all great ideas for water improvement! I'm happy to say that many of these are already on our roadmap: caustics, noise, volumetric rays, reflections, refractions.
- **Q**: I know I'm asking a lot, but you might consider adding snell's window?
- **A**: Yes. 😉
## Will We See Items Getting Material Support?
- **Q**: Items are now the last *major* thing to not receive any official PBR support in deferred. It is still *possible* to give items PBR capabilities with some workarounds (ex: attachables, as well as tools like MIAM1 ), but I’m curious if it stay that way, or if there is a plan to eventually give items these PBR features.
- **A**: Yes! This is something we are working on. And don't forget about Particles! Those will be getting PBR support as well, likely sooner than Items.
## Enable/disable Deferred Graphics Options For Each Packs?
- **Q**: I would like to ask wether there is any plan to add support for the toggle that is enabling and disabling deferred-graphics for each packs.
Since shader packs are too heavy for some devices, I thought it would be wonderful if there were such option for each packs.
- **A**: Deferred graphics resource packs will stack like any other resource pack with the pack being higher on the stack overriding the properties of the pack below it. Your description of pack overriding behavior sounds right!
## Are There Any Plans To Fix Volumetric Fogs That Use Height Rather Than Uniformity From Blinding You?
- **Q**: To add more context. When you set up a fog and it uses the height parameters rather than being uniform, their thickness goes to the maximum upon entering the biome then fades into the proper height the further in you go. Is this intentional or a bug?
- **A**: Interpolation at biome transitions aren't the most polished right now (what you're describing is likely a bug). We'll be working on more polished transitions closer to final release!
## Entities: Spot/Point lights
- **Q**: Are entities planned to be involved? such as conditionally shining flashlights from players, glowing mobs, etc.
(I just imagine a lethal company style flashlight through fog in minecraft and get excited lol)
- **A**: No, we do not have plans to include spot lights or attachable lights to entities at this point in time. Thank you for your suggestion!
## How Customizable Will Deferred Be On Release?
- **Q**: Seeing that there are **a lot** of configs for deferred inside the game’s files, will we be able to edit those fully through resource packs in the future?
Something else I was wondering is if we will get more customizations in the future (for example: More lighting Config, Renderer Config, etc).
- **A**: While we won't end up exposing everything, we are still looking into expanding some of the data-driving to give Creators additional control. What are some of the specific configurations that you would like to see exposed that would give you the most additional creative control?
## Reloading Resource Packs
- **Q**: Will there ever be a F3+T feature in bedrock edition? i feel like the ability to reload resource packs without leaving the world should be added to bedrock edition, it's already in java from the start but never made it to bedrock.
- **A**: We definitely know that reloading resource packs is a pain. Not a great development flow. We want to do things here to make this easier, but nothing really to announce today. And this sort of thing is pretty gnarly to work on.
- **Q**: What about `/reload all` in Editor mode? (I'm not even sure if that's related in any way.)
- **A**: Yeah we have some tech that can reload some things, but not all things. And yeah, you're on the right line of thinking that if we do light up these features, Editor would be the safest place for us to do it.
## Identifier-Based Configuration
- **Q**: More of a feature request with the "Are there any plans to…" prefix, but identifier-based configurations would be quite useful. There are times when I want to change lighting configurations based on gameplay. Some command or something to switch configurations would be needed. Maybe scripting only.
Directional lights especially come to mind as something I'd like to change due to world events. Maybe a "world destroyer" boss should change the very way that light is cast in the Overworld. As an example of these identifier-based files:
```json
{
"format_version": "1.20.80",
"minecraft:directional_lights": {
"description": {"identifier": "bao:world_destroyer_event"},
"sun": {},
"moon": {}
}
}
```
And then something like:
```swift
/renderer lighting set bao:world_destroyer_event
```
Essentially, this would be using the same kind of ideas as fogs, wherein it isn't enough to just map them to biomes. They need to be freestanding for application when appropriate.
- **A**: Yes! This is something we are working on and will be enabling in both our lighting and atmospherics JSONs. The identification will be very similar to how Fog is identified. Creators should expect that when this change comes out, that they will have to update their current PBR packs to make use of the identifiers as it will be a breaking schema change. Though it will be straight forward and we will provide guidance on how to do it.
## Dimension Based Config
- **Q**: Similar to <https://discord.com/channels/523663022053392405/1210250265895243807>, I think it would be cool if blocks could have 3 pbr textures and config, one for each dimension. This would help enhance each dimension to be unique.
Having point light emit different colours based on dimension as one example
This is similar to my Molang post, but currently there is no molang query to detect dimension as far as I know
- **A**: We're currently working on being able to provide unique configurations per biome and I believe these will allow you to configure properties unique to other dimensions like the nether or the end dimensions.
We're still exploring how lighting will work in other dimensions with a big focus on the overworld presently!
- **A**: And as we also look at custom biomes and custom dimensions (no timeline or promises, just things on the list) we will also consider how deferred graphics will be utilized by these creator things.
## Vanilla PBR
- **Q**: Is Mojang planning on releasing PBRs for the *massive* collection of textures in this game? Getting started with PBR as a "technical artist" without just ripping PBRs with someone else's pack sucks if not just because of the sheer volume.
(This is not a request for vanilla features. I figured the team had some internal pack they use for testing when in deferred. So I'm more asking for this as a developer resource.)
- **A**: Unfortunately we don't have any plans to share a PBR resource pack anytime soon for testing, I hear your feedback though and apologize it's not so easy to test right now.
You can however set default values for all blocks and entities that don't have a specific texture set in the global lighting file, which may help in some scenarios!
## Preview Atmosphere in Real Time
- **Q**: Currently, as a creator, when authoring atmosphere config there is no way to preview changes in real time. The workflow is: edit json -> reload the world -> observe changes. This process is quite annoying, as you don't see the changes instantly - it makes it harder to know how json changes translate to atmosphere visuals, as well as makes the iteration process take much longer than necessary.
It would've been better if we could preview how different json configs and values affect atmosphere look in real time. Are there any plans (that you can share) that address this issue? E.g. some kind of in-game atmosphere editor or a plugin for <#1084090299120373760>? Or even an official (or not) standalone tool/webapp similar to blockbench or snowstorm. And if someone like me wanted to make such tool, what are the conditions or requirements for that, specific license to use for Bedrock's shader code?
- **A**: Yes, we hear you and feel your pain. 🙏 We do intend to integrate the Deferred Technical Preview more with the Bedrock Editor so that creators can more easily customize their packs and see changes in real-time.
## Trailer
- **Q**: Will deferred be getting a trailer anytime soon?
- **A**: Good question! It's still too early to think about marketing materials. Right now our focus is just building these features and getting feedback from you all! But I'd love to see community made trailers, hint hint! 😄
- **A**: I frequently search YouTube for videos of the latest updates and community packs! Also all the tutorials that help others get the deferred preview on their own devices too 🙂
## Increases to Keyframe Periods
- **Q**: Any plans to customize keyframes *across days*? (I'm hoping this didn't change since the last time I tested it.) I'd noticed before I was limited with keyframes to a single looping day. I was hoping I could vary directional lights by moon phases and was disappointed when I couldn't.
I figured that the period could automatically be adjusted based on the largest resolved time key in the keyframe object. For example, `7.5` would cause a period of 8 days, with *all* of the listed times for that one keyframe object adhering to that period.
Essentially, this would be not too dissimilar to how an animation automatically sets its total duration by looking at the largest given timeline value. Except these will be rounded up to a full day.
- **A**: Unfortunately we don't have plans to expand keyframing outside of a single day in the near to mid term. But that idea around moon phases is super awesome, something I hadn't thought of yet!

100
docs/wiki/visuals/glowing-texture.md Normal file
View File

@@ -0,0 +1,100 @@
---
title: Glowing Entity Texture
category: Tutorials
mentions:
- LeGend077
- MedicalJewel105
---
In this tutorial, you will learn how to make a glowing texture, like enderman's eyes have for an entity by using materials and textures.
## Texture
To make your entity's texture glow, you need to open your texture in an advanced image editor (here, Blockbench) to half-erase the pixels alpha.
- Open your entity's texture file.
_Don't mind strange bones rotation, Mojang likes to render models correctly through animations._
- Find the __Eraser__ tool and set its opacity/alpha to something low like 71 or 23.
![](/assets/images/visuals/glowing-texture/eraser.png)
![](/assets/images/visuals/glowing-texture/opacity.png)
- Then, erase the part of the texture you want it to glow. The less visible a pixel is the more it glows, but be sure it is not 100% erased.
![](/assets/images/visuals/glowing-texture/erase-pixels.png)
Example Pig texture:
![](/assets/images/visuals/glowing-texture/pig.png)
## Material
We need to modify the `RP/entity/my_entity.entity.json` file of the mob we want to glow. Now, find `"materials":{}` and set the values to `"entity_emissive_alpha"`. (Be sure to check if the textures are properly defined).
<CodeHeader>RP/entity/pig.entity.json#description</CodeHeader>
```json
"materials": {
"default": "entity_emissive_alpha"
}
```
<Spoiler title="Example Pig Entity File">
<CodeHeader>RP/entity/pig.entity.json</CodeHeader>
```json
{
"format_version": "1.10.0",
"minecraft:client_entity": {
"description": {
"identifier": "minecraft:pig",
"min_engine_version": "1.8.0",
"materials": {
"default": "entity_emissive_alpha" // replace "pig" with "entity_emissive_alpha"
},
"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": "q.modified_move_speed"
},
"look_at_target",
{
"baby_transform": "q.is_baby"
}
]
},
"render_controllers": ["controller.render.pig"],
"spawn_egg": {
"texture": "spawn_egg",
"texture_index": 2
}
}
}
}
```
</Spoiler>
## Testing
Now, load up Minecraft and open a word with this resource pack enabled. Set the time to _midnight_ or find a nearby cave and test it out. The entity should glow as expected.
![](/assets/images/visuals/glowing-texture/result.png)

14
docs/wiki/visuals/index.md Normal file
View File

@@ -0,0 +1,14 @@
---
title: Visuals
categories:
- title: General
color: blue
- title: Tutorials
color: green
- title: Ideas
color: orange
---
Welcome to the Entity Visuals section!
<BButton color="blue" link="introduction">Get Started!</BButton>

17
docs/wiki/visuals/introduction.md Normal file
View File

@@ -0,0 +1,17 @@
---
title: Introduction to Entity Visuals
nav_order: 1
tags:
- guide
category:
- General
mentions:
- SirLich
- MedicalJewel105
- Overload1252
---
## What is this section about?
Welcome, stranger. You have entered entity visuals section.
Here you can learn how to improve visual part of your content. This section is important as good expression is mostly formed of how everything looks in add-on.

53
docs/wiki/visuals/leash-position.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Leash Position
category:
- Tutorials
mentions:
- MedicalJewel105
- SirLich
- Overload1252
tags:
- easy
---
Have you ever wanted to change position of a leash on your entity?
If so, this page is for you!
## Blockbench Part
To set a leash position, we will use Blockbench.
Open your model, in this case it will be a llama model.
*Don't mind strange bones rotation, mojang likes to render models correctly through animations.*
![](/assets/images/visuals/leash-position/model-1.png)
Now search for locator `lead`.
![](/assets/images/visuals/leash-position/model-2.png)
If it doesn't exist, you can
<Spoiler title="create it">
1. Select a group.
2. Right-click on it.
3. Choose "Add Locator" option.
![](/assets/images/visuals/leash-position/locator-1.png)
4. Rename it to `lead`
</Spoiler>
The last thing will be to move the locator where you want and save the model.
![](/assets/images/visuals/leash-position/model-3.png)
## Testing
Before:
![](/assets/images/visuals/leash-position/result-0.png)
After:
![](/assets/images/visuals/leash-position/result-1.png)

223
docs/wiki/visuals/material-creations.md Normal file
View File

@@ -0,0 +1,223 @@
---
title: Material Creations
tags:
- expert
category:
- General
---
:::warning
Materials are not for the faint of heart. Be prepared for potential crashes, content log errors, and long loading times.
:::
On this page you can find material creations by community.
## Custom material that glows and works with semi transparency.
Note: this also works by disabling culling so you don't run into those weird culling issues where you can't see entities and things behind the texture the material is applied to.
Note: Texture needs to have semi transparency in it to add the glow effect.
"customblend" is what you would call in your entity as a material.
<Spoiler title="Show">
<CodeHeader></CodeHeader>
```json
{
"customblend:entity_alphablend": {
"+defines": [
"USE_EMISSIVE"
],
"+states": [
"Blending",
"DisableCulling",
"DisableDepthWrite",
"DisableAlphaWrite"
]
}
}
```
</Spoiler>
Credit: StealthyX.
## Alpha Channel Textures with Render Dragon
Material that allows for alpha channel textures with render dragon:
<Spoiler title="Show">
<CodeHeader></CodeHeader>
```json
{
"ambient_alpha:entity": {
"+states": [
"Blending",
"DisableCulling"
],
"vertexShader": "shaders/color_uv.vertex",
"vrGeometryShader": "shaders/color_uv.geometry",
"fragmentShader": "shaders/color_texture.fragment",
"blendSrc": "SourceAlpha",
"blendDst": "OneMinusSrcAlpha",
"vertexFields": [
{
"field": "Position"
},
{
"field": "Color"
},
{
"field": "Normal"
},
{
"field": "UV0"
}
],
"variants": [
{
"skinning": {
"+defines": [
"USE_SKINNING"
],
"vertexFields": [
{
"field": "Position"
},
{
"field": "BoneId0"
},
{
"field": "Color"
},
{
"field": "Normal"
},
{
"field": "UV0"
}
]
}
}
]
}
}
```
</Spoiler>
After some more testing was found out that this only works in 3rd person, but still useful since vanilla blending materials still were broken regardless of perspective.
Credit: Ambient.
## overlay_color in render controllers
Material that doesn't permit overlay_color to be used in render controllers:
<Spoiler title="Show">
<CodeHeader></CodeHeader>
```json
{
"materials": {
"version": "1.0.0",
"ambient_no_overlay": {
"defines": [
"ALPHA_TEST"
],
"vertexShader": "shaders/entity.vertex",
"vrGeometryShader": "shaders/entity.geometry",
"fragmentShader": "shaders/entity.fragment",
"vertexFields": [
{
"field": "Position"
},
{
"field": "Normal"
},
{
"field": "UV0"
}
],
"variants": [
{
"skinning": {
"+defines": [
"USE_SKINNING"
],
"vertexFields": [
{
"field": "Position"
},
{
"field": "BoneId0"
},
{
"field": "Normal"
},
{
"field": "UV0"
}
]
}
},
{
"skinning_color": {
"+defines": [
"USE_SKINNING"
],
"+states": [
"Blending"
],
"vertexFields": [
{
"field": "Position"
},
{
"field": "BoneId0"
},
{
"field": "Color"
},
{
"field": "Normal"
},
{
"field": "UV0"
}
]
}
}
],
"msaaSupport": "Both",
"+samplerStates": [
{
"samplerIndex": 0,
"textureFilter": "Point"
},
{
"samplerIndex": 1,
"textureWrap": "Repeat"
}
]
}
}
}
```
</Spoiler>
May be useful for applying to a specific bone and not the entire geometry.
Credit: Ambient.
## entity_alphablend_nocolorentity_static Material
Using the `entity_alphablend_nocolorentity_static` material will reliably crash Minecraft.
Credit: Gecko.

239
docs/wiki/visuals/materials.md Normal file
View File

@@ -0,0 +1,239 @@
---
title: Materials
tags:
- expert
category:
- General
mentions:
- SirLich
- Joelant05
- MedicalJewel105
- Luthorius
---
:::warning
Materials are not for the faint of heart. Be prepared for potential crashes, content log errors, and long loading times.
:::
## Overview
Materials are used to specify the shaders that render the different parts of the game, along with states and settings the shaders should consider for each element.
At the moment, most things in the game are hard-coded to use specific material and may not be assigned new ones. The only way to change how these elements are rendered is by editing their materials directly (potentially having unintentional effects on other parts) or creating new shaders (an old experimental feature no longer officially supported by Mojang). The only elements that allow default or custom materials to be assigned or removed are entities and particles.
If you are not prepared to go in-depth with the ins and outs, material presets can be found [here](/documentation/materials).
## Syntax and Structure
Most materials inherit the settings of previously defined materials, then further building off of them. This is written in the following format:
<CodeHeader>RP/materials/name.material</CodeHeader>
```json
{
"materials": {
"version": "1.0.0",
"<New material ID>:<ID of material to use as a base>": {
<defines, states, and other settings>
}
}
}
```
:::warning
Although it may look similar, do not confuse material format files in packs. There are no namespaces used in materials.
:::
Some material files contain extensive branching trees of materials. For example, nearly all of the materials used by default entities are ultimately derivatives of the material `entity_static` in the entity.material file. If we look at the material used by the current villagers:
<CodeHeader></CodeHeader>
```json
"villager_v2_masked:entity_multitexture_masked": {
"depthFunc": "LessEqual"
},
```
We can see that the material's name is `villager_v2_masked` and builds off the material named `entity_multitexture_masked`.
Scrolling up in the file, we can find "entity_multitexture_masked" inheriting the settings from "entity_alphatest" and building further onto it:
<CodeHeader></CodeHeader>
```json
"entity_multitexture_masked:entity_alphatest":{
"+defines":[
"MASKED_MULTITEXTURE"
],
"+samplerStates":[
{
"samplerIndex":0,
"textureWrap":"Clamp"
},
{
"samplerIndex":1,
"textureWrap":"Clamp"
}
]
}
```
"entity_alphatest" can then be followed to "entity_nocull"
<CodeHeader></CodeHeader>
```json
"entity_alphatest:entity_nocull":{
"+defines":[
"ALPHA_TEST"
],
"+samplerStates":[
{
"samplerIndex":1,
"textureWrap":"Repeat"
}
],
"msaaSupport":"Both"
}
```
which can be followed to plain "entity"
<CodeHeader></CodeHeader>
```json
"entity_nocull:entity":{
"+states":[
"DisableCulling"
]
}
```
which can then finally be followed to "entity_static"
<CodeHeader></CodeHeader>
```json
"entity:entity_static":{
"+defines":[
"USE_OVERLAY"
],
"msaaSupport":"Both"
},
```
"entity_static" doesn't have a colon followed by another material, indicating that it's the bottom of this inheritance tree.
<CodeHeader></CodeHeader>
```json
"entity_static":{
"vertexShader":"shaders/entity.vertex",
"vrGeometryShader":"shaders/entity.geometry",
"fragmentShader":"shaders/entity.fragment",
"vertexFields":[
{
"field":"Position"
},
{
"field":"Normal"
},
{
"field":"UV0"
}
],
"variants":[
{
"skinning":{
"+defines":[
"USE_SKINNING"
],
"vertexFields":[
{
"field":"Position"
},
{
"field":"BoneId0"
},
{
"field":"Normal"
},
{
"field":"UV0"
}
]
}
},
{
"skinning_color":{
"+defines":[
"USE_SKINNING",
"USE_OVERLAY"
],
"+states":[
"Blending"
],
"vertexFields":[
{
"field":"Position"
},
{
"field":"BoneId0"
},
{
"field":"Color"
},
{
"field":"Normal"
},
{
"field":"UV0"
}
]
}
}
],
"msaaSupport":"Both",
"+samplerStates":[
{
"samplerIndex":0,
"textureFilter":"Point"
}
]
}
```
## 1.16.100+ Notes
Warning for anybody who uses custom materials!
Custom material inheriting is no longer valid and causes content log errors the workaround Is to define the material fully custom with just the prefix and material name.
This was not an issue before 1.16.100.
```json
{
"materials": {
"version": "1.0.0",
"prefix:window_glass:entity": { //now throws a content log error.
"+states": [
"Blending"
],
"defines": [
"ENABLE_FOG",
"ENABLE_LIGHT",
"USE_ONLY_EMISSIVE"
]
},
"prefix:window_glass:": { //corrects the content log error. Note: may have to also define the old inherited values.
"+states": [
"Blending"
],
"defines": [
"ENABLE_FOG",
"ENABLE_LIGHT",
"USE_ONLY_EMISSIVE"
]
}
}
}
```

99
docs/wiki/visuals/math-based-animations.md Normal file
View File

@@ -0,0 +1,99 @@
---
title: Math-based Animations
tags:
- intermediate
category:
- General
mentions:
- SirLich
- solvedDev
- Joelant05
- MedicalJewel105
- yanasakana
- Luthorius
- TheItsNameless
- SmokeyStack
- ThomasOrs
---
Math animations are a powerful alternative to keyframe animations. Generally speaking, `math-based animations` is the concept of using Molang expressions to animate entity geometry. All vanilla animations are math-based, here is an example:
<CodeHeader></CodeHeader>
```json
"leftarm" : {
"rotation" : [ "((-0.2 + 1.5 * (math.abs(math.mod(q.modified_distance_moved, 13) - 6.5) - 3.25) / 3.25) * q.modified_move_speed) * 57.3 - v.agent.armxrotationfactor", 0.0, "-v.agent.armzrotation" ]
},
```
As you can see, math-based animations can be quite complicated and difficult to understand. Thus, they should be treated as a _specialized-alternative_ to using key-frames - not a *total* replacement.
This is the cost of the smooth and ideal loop of the animation.
![](/assets/images/visuals/math-based-animations/animation-1.gif)
## Writing Math-Animations
### By Hand
To write such an animation by hand, simply create an animation file and substitute keyframes for singular arrays of values; strings values are accepted, and it is in a string that one may place a math expression. The Vanilla files can prove an invaluable reference for these types of animations, and it is **strongly** recommended you download and preview them!
As an important tip for those who wish to *visualise* their processes, the tool, [Molang Grapher](https://jannisx11.github.io/molang-grapher/) from [Jannis](https://twitter.com/jannisx11) may simulate expressions on a proper graph!
### In Blockbench
Blockbench allows - to a degree - for the creation and live-previewing of most math-based animations.
To begin, first create a new keyframe at frame 0 in your timeline. You may then add and edit Molang expressions in the keyframe panel on the left sidebar. Mixing keyframes and math is supported.
**Remember**, you should always omit quotation marks around expressions; they are only required in raw JSON-editing!
Do mind that not all Molang queries are supported in Blockbench in part due to missing game-context. If you wish to preview an animation that uses a context-specific query, you may add it to the Variable Placeholders section, just underneath the keyframe panel, to simulate a value.
For example, adding `q.modified_distance_moved = time*8` simulates the `modified_distance_moved` query with a speed of 8 blocks per second.
## Using Queries
The largest and most useful of tools in our mathematical repertoire is the wide array of Molang "Queries". Queries can be used to add outside information into your math expression.
Common Queries include:
- `q.modified_distance_moved`
- `q.modified_move_speed`
- `q.anim_time`
- `q.life_time`
These are utilised in animations to draw things such as the attack-time or distance-moved from the game-world to provide a more dynamic and synced flow.
### Avoiding Animation Controllers
By using queries, you can avoid the need to create animation controllers. If the entity's speed is directly related to the speed of the walk animation, then by default, an entity that isn't moving won't be animated.
## Example
A specific application example of a Math-Based animation may be found below. The example utilises the Molang Query, `"q.modified_distance_moved"`:
<CodeHeader></CodeHeader>
```json
{
"format_version": "1.12.0",
"animations": {
"animation.car.wheel_spin": {
"loop": true,
"bones": {
"front_wheels": {
"rotation": [ "q.modified_distance_moved * -30", 0, 0 ]
},
"back_wheels": {
"rotation": [ "q.modified_distance_moved * -30", 0, 0 ]
}
}
}
}
}
```
In this example, the model's bones, `front_wheels` and `back_wheels`, are rotated on the X-axis based on information passed from `q.modified_distance_moved`, then multiplied by -30.
This means that a car at *rest* **will not** spin, and a car that is *driving* **will spin** - doing so at a rate proportional to the car's movement speed.

517
docs/wiki/visuals/player-geometry.md Normal file
View File

@@ -0,0 +1,517 @@
---
title: Player Geometry
tags:
- beginner
category:
- Tutorials
mentions:
- SirLich
- MedicalJewel105
---
This tutorial will show you how to create player NPCs and add them into your world. These player NPCs will take vanilla player skins, and come included with walk-animations, attack animations, etc.
This tutorial is a _graphical_ tutorial. Mechanics are not covered.
:::warning
This will be a very json-heavy document. The json is intended for copy-pasting.
:::
## Geometry File
This json contains geometry for both the Steve and Alex versions:
`geometry.npc.steve`
`geometry.npc.alex`
<Spoiler title="Geometry">
<CodeHeader></CodeHeader>
```json
{
"format_version": "1.12.0",
"minecraft:geometry": [
{
"description": {
"identifier": "geometry.cape",
"texture_width": 64,
"texture_height": 32
},
"bones": [
{
"name": "body",
"pivot": [0.0, 24.0, 0.0],
"parent": "waist"
},
{
"name": "waist",
"pivot": [0.0, 12.0, 0.0]
},
{
"name": "cape",
"parent": "body",
"pivot": [0.0, 24.0, 3.0],
"rotation": [0.0, 180.0, 0.0],
"cubes": [
{
"origin": [-5.0, 8.0, 3.0],
"size": [10, 16, 1],
"uv": [0, 0]
}
]
}
]
},
{
"description": {
"identifier": "geometry.npc.steve",
"visible_bounds_width": 1,
"visible_bounds_height": 2,
"visible_bounds_offset": [0, 1, 0],
"texture_width": 64,
"texture_height": 64
},
"bones": [
{
"name": "root",
"pivot": [0.0, 0.0, 0.0]
},
{
"name": "body",
"parent": "waist",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 12.0, -2.0],
"size": [8, 12, 4],
"uv": [16, 16]
}
]
},
{
"name": "waist",
"parent": "root",
"pivot": [0.0, 12.0, 0.0]
},
{
"name": "head",
"parent": "body",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 24.0, -4.0],
"size": [8, 8, 8],
"uv": [0, 0]
}
]
},
{
"name": "cape",
"pivot": [0.0, 24, 3.0],
"parent": "body"
},
{
"name": "hat",
"parent": "head",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 24.0, -4.0],
"size": [8, 8, 8],
"uv": [32, 0],
"inflate": 0.5
}
]
},
{
"name": "leftArm",
"parent": "body",
"pivot": [5.0, 22.0, 0.0],
"cubes": [
{
"origin": [4.0, 12.0, -2.0],
"size": [4, 12, 4],
"uv": [32, 48]
}
]
},
{
"name": "leftSleeve",
"parent": "leftArm",
"pivot": [5.0, 22.0, 0.0],
"cubes": [
{
"origin": [4.0, 12.0, -2.0],
"size": [4, 12, 4],
"uv": [48, 48],
"inflate": 0.25
}
]
},
{
"name": "leftItem",
"pivot": [6.0, 15.0, 1.0],
"parent": "leftArm"
},
{
"name": "rightArm",
"parent": "body",
"pivot": [-5.0, 22.0, 0.0],
"cubes": [
{
"origin": [-8.0, 12.0, -2.0],
"size": [4, 12, 4],
"uv": [40, 16]
}
]
},
{
"name": "rightSleeve",
"parent": "rightArm",
"pivot": [-5.0, 22.0, 0.0],
"cubes": [
{
"origin": [-8.0, 12.0, -2.0],
"size": [4, 12, 4],
"uv": [40, 32],
"inflate": 0.25
}
]
},
{
"name": "rightItem",
"pivot": [-6, 15, 1],
"locators": {
"lead_hold": [-6, 15, 1]
},
"parent": "rightArm"
},
{
"name": "leftLeg",
"parent": "root",
"pivot": [1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-0.1, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [16, 48]
}
]
},
{
"name": "leftPants",
"parent": "leftLeg",
"pivot": [1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-0.1, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 48],
"inflate": 0.25
}
]
},
{
"name": "rightLeg",
"parent": "root",
"pivot": [-1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-3.9, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 16]
}
]
},
{
"name": "rightPants",
"parent": "rightLeg",
"pivot": [-1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-3.9, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 32],
"inflate": 0.25
}
]
},
{
"name": "jacket",
"parent": "body",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 12.0, -2.0],
"size": [8, 12, 4],
"uv": [16, 32],
"inflate": 0.25
}
]
}
]
},
{
"description": {
"identifier": "geometry.npc.alex",
"visible_bounds_width": 1,
"visible_bounds_height": 2,
"visible_bounds_offset": [0, 1, 0],
"texture_width": 64,
"texture_height": 64
},
"bones": [
{
"name": "root",
"pivot": [0.0, 0.0, 0.0]
},
{
"name": "waist",
"parent": "root",
"pivot": [0.0, 12.0, 0.0]
},
{
"name": "body",
"parent": "waist",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 12.0, -2.0],
"size": [8, 12, 4],
"uv": [16, 16]
}
]
},
{
"name": "head",
"parent": "body",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 24.0, -4.0],
"size": [8, 8, 8],
"uv": [0, 0]
}
]
},
{
"name": "hat",
"parent": "head",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 24.0, -4.0],
"size": [8, 8, 8],
"uv": [32, 0],
"inflate": 0.5
}
]
},
{
"name": "rightLeg",
"parent": "root",
"pivot": [-1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-3.9, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 16]
}
]
},
{
"name": "rightPants",
"parent": "rightLeg",
"pivot": [-1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-3.9, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 32],
"inflate": 0.25
}
]
},
{
"name": "leftLeg",
"parent": "root",
"pivot": [1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-0.1, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 16]
}
],
"mirror": true
},
{
"name": "leftPants",
"parent": "leftLeg",
"pivot": [1.9, 12.0, 0.0],
"cubes": [
{
"origin": [-0.1, 0.0, -2.0],
"size": [4, 12, 4],
"uv": [0, 48],
"inflate": 0.25
}
]
},
{
"name": "leftArm",
"parent": "body",
"pivot": [5.0, 21.5, 0.0],
"cubes": [
{
"origin": [4.0, 11.5, -2.0],
"size": [3, 12, 4],
"uv": [32, 48]
}
]
},
{
"name": "leftSleeve",
"parent": "leftArm",
"pivot": [5.0, 21.5, 0.0],
"cubes": [
{
"origin": [4.0, 11.5, -2.0],
"size": [3, 12, 4],
"uv": [48, 48],
"inflate": 0.25
}
]
},
{
"name": "leftItem",
"pivot": [6, 14.5, 1],
"parent": "leftArm"
},
{
"name": "rightArm",
"parent": "body",
"pivot": [-5.0, 21.5, 0.0],
"cubes": [
{
"origin": [-7.0, 11.5, -2.0],
"size": [3, 12, 4],
"uv": [40, 16]
}
]
},
{
"name": "rightSleeve",
"parent": "rightArm",
"pivot": [-5.0, 21.5, 0.0],
"cubes": [
{
"origin": [-7.0, 11.5, -2.0],
"size": [3, 12, 4],
"uv": [40, 32],
"inflate": 0.25
}
]
},
{
"name": "rightItem",
"pivot": [-6, 14.5, 1],
"locators": {
"lead_hold": [-6, 14.5, 1]
},
"parent": "rightArm"
},
{
"name": "jacket",
"parent": "body",
"pivot": [0.0, 24.0, 0.0],
"cubes": [
{
"origin": [-4.0, 12.0, -2.0],
"size": [8, 12, 4],
"uv": [16, 32],
"inflate": 0.25
}
]
},
{
"name": "cape",
"pivot": [0.0, 24, -3.0],
"parent": "body"
}
]
}
]
}
```
</Spoiler>
## Entity File
Use this entity file if you would like to have animations for your geometry. This file includes error-free animations for:
- walking
- looking at player
- idle
If you need a more complete set of animations, consider copying the default player RP-entity file, and trying to work with the animations by hand.
<Spoiler title="Entity File">
<CodeHeader></CodeHeader>
```json
{
"format_version": "1.10.0",
"minecraft:client_entity": {
"description": {
"identifier": "wiki:npc",
"materials": {
"default": "villager_v2"
},
"geometry": {
"default": "geometry.npc.alex"
},
"render_controllers": ["controller.render.single_texture"],
"textures": {
"default": "textures/entity/npc/introduction"
},
"scripts": {
"scale": "0.9375",
"pre_animation": [
"v.tcos0 = (math.cos(q.modified_distance_moved * 38.17) * q.modified_move_speed / v.gliding_speed_value) * 57.3;"
],
"animate": [
"move.arms",
"move.legs",
"look_at_target_default",
"bob"
]
},
"animations": {
"look_at_target_default": "animation.humanoid.look_at_target.default",
"move.arms": "animation.player.move.arms",
"move.legs": "animation.player.move.legs",
"bob": "animation.player.bob"
}
}
}
}
```
</Spoiler>

122
docs/wiki/visuals/remove-shadows.md Normal file
View File

@@ -0,0 +1,122 @@
---
title: Remove Entity Shadows
tags:
- intermediate
category:
- Tutorials
mentions:
- SirLich
- solvedDev
- Joelant05
- MedicalJewel105
- SmokeyStack
- ThomasOrs
---
There are quite a few ways to remove shadows from entities, and nearly all of them have undesirable effects. There is no foolproof way to perfectly remove shadows from specific entities, without causing side effects.
This document will showcase some of the various ways to remove shadows, and any possible effects from doing this.
## Small Collision Box
One possibility is to make the size of the collision component very small. This will make it hard to interact/hit the entity, but it will make the shadow disappear!
<CodeHeader></CodeHeader>
```json
"minecraft:collision_box": {
"width": 0.1,
"height": 0.1
}
```
You can also add the [custom hit test component](https://bedrock.dev/docs/stable/Entities#minecraft:custom_hit_test). The `custom_hit_test` component will allow you to hit the entity, although you will not be able to interact with it. The `custom_hit_test` will not create a shadow.
<CodeHeader></CodeHeader>
```json
"minecraft:custom_hit_test": {
"hitboxes": [
{
"pivot": [0, 0.5, 0],//This is the position of the hitbox, you can change the X, Y and Z values.
"width": 0.8,
"height": 0.7
}//And you can add many more hitboxes as you want, just copy-paste the hitbox inside the "hitboxes" array.
]
}
```
## Teleport underground
If you have a dummy entity (invisible) that you need to interact with, you can teleport like `/teleport @x ~ ~-0.01 ~`. This will slightly insert the entity into the ground, and stop shadows from showing.
## Using runtime identifier
Some entities don't have shadows, or very small shadows at least. By using the runtime identifier of these entities, we can remove the shadows. The downside is taking on that entities hard-coded behaviors, which can sometimes be very problematic. See the [runtime identifiers document](/entities/runtime-identifier) for more information.
## Using Materials
:::danger
This method is no longer supported. With the advent of render-dragon, materials like this no longer function. Please do not attempt to use this code in a serious way, and definitely do not attempt it on a marketplace map.
:::
:::warning
- This folder is NOT included in the vanilla RP Pack examples and must be exported from a APK files or added by hand.
- This has not been tested for blocks and has only been verified for entities. If you find it works on blocks too please let us know so we can add that in.
:::
<Spoiler title="Removing shadows via Materials.">
#### Working shadow code: Shadows for ALL entities:
<CodeHeader>RP/materials/shadows.material</CodeHeader>
```json
"shadow_overlay":{
"+states":[
"DisableDepthTest",
"DisableCulling",
"Blending",
"EnableStencilTest"
],
"vertexShader":"shaders/color.vertex",
"vrGeometryShader":"shaders/color.geometry",
"fragmentShader":"shaders/shadow_stencil_overlay.fragment",
"blendSrc":"DestColor",
"blendDst":"Zero",
"frontFace":{
"stencilFunc":"Equal",
"stencilPass":"Replace"
}
}
```
#### Disabled shadow code: No Shadows for ALL entities:
<CodeHeader></CodeHeader>
```json
"shadow_overlay":{
"+states":[
"DisableDepthTest",
"DisableCulling",
"Blending",
"EnableStencilTest"
],
"vertexShader":"",
"vrGeometryShader":"",
"fragmentShader":"",
"blendSrc":"DestColor",
"blendDst":"Zero",
"frontFace":{
"stencilFunc":"Equal",
"stencilPass":"Replace"
}
}
```
</Spoiler>
#### Geometry + Materials Workaround
You can hide entity shadows if you apply a model on your entity to cover the shadow and use `"banner_pole"` material.

59
docs/wiki/visuals/retexturing-spawn-eggs.md Normal file
View File

@@ -0,0 +1,59 @@
---
title: Retexturing Spawn Eggs
tags:
- beginner
category:
- Tutorials
mentions:
- SirLich
- Joelant05
- MedicalJewel105
- aexer0e
---
Custom entities will automatically be given a spawn egg. This spawn egg can be found inside of the creative menu, with a name like `item.spawn_egg.entity.wiki:my_entity.name`. If you want to rename your spawn egg as well as set a texture, you can do so in the lang files.
In this tutorial we are going to retexture the spawn egg so it looks more like your spawned item, and less like an egg.
## Creating the Texture
You can easily take a screenshot of your entity using the Blockbench software. Load the mode, and select export screenshot from the drop-down.
If you don't want an image like this, you can also create your own pixel art, or use any image you like.
## Adding the Texture
Add the texture file under `textures/items/`. I personally suggest creating an `eggs` folder to contain all the spawn egg textures. For example, `textures/items/eggs/my_entity.png`. The file itself should be square.
## Giving the Texture a Name
Now we need to give our texture a short-name. This can be done in item_texture file:
<CodeHeader>RP/textures/item_texture.json</CodeHeader>
```json
{
"resource_pack_name": "My Map Name", //I don't actually know if this field does anything.
"texture_name": "atlas.items",
"texture_data": {
"my_entity": { //"my_entity" is the short-name of the texture, which we can reference later
"textures": "textures/items/egg/my_entity"
}
//Add more spawn egg textures here
}
```
## Using the new texture:
Now we can use our new texture inside of the Resource Pack entity file:
<CodeHeader>RP/entity/my_entity.json#description</CodeHeader>
```json
"spawn_egg": {
"texture": "my_entity", //"my entity should match the texture short-name we created in step-1.
"texture_index": 0
}
```
Go and test it now!

53
docs/wiki/visuals/structure-presentation.md Normal file
View File

@@ -0,0 +1,53 @@
---
title: Structure Presentation
category: Ideas
mentions:
- MedicalJewel105
- LeGend077
- ThomasOrs
---
## Why this page exists
Presenting features of an add-on clearly has same importance in showcasing quality. If people can understand an add-on and it's features they might be more likely to try it. This page will demonstrate a way of presenting structures.
## Presentation Methods
There are lots ways of you could showcase structures to people. You can:
- Take in-game screenshots of the structure.
- Take a screenshot inside of a structure block.
- Create a 3D object of your structure.
Below all three methods will be shown using the Pillager outpost structure as an example.
### In-Game Screenshot
This is the simplest method because it is quick and easy. It also lets you showcase the structure in the context of the world, there are some disadvantages however. You may need to find a good place to take a screenshot or have difficulty finding a good angle.
![](/assets/images/visuals/structure-presentation/in-game.png)
### In a Structure Block
This method avoids some of the disadvantages of a screenshot in the world, you are able to focus entirely on the structure without other blocks in the view.
![](/assets/images/visuals/structure-presentation/structure-block-0.png)
By making [JSON UI](/json-ui/json-ui-intro) edits you can change the background color and remove other elements to further improve this method.
![](/assets/images/visuals/structure-presentation/structure-block-1.png)
### Rendered 3D Object
Structures can be exported as a 3d model. If 3D export button is not working for you, you can try applying a 3d-export-fix pack.
<BButton
link="/assets/packs/visuals/structure-presentation/3d-export-fix.mcpack" download
color=blue
>Download Pack</BButton>
![](/assets/images/visuals/structure-presentation/model-render.png)
This method is mostly available for pc users. You can create a simple render in Paint 3D or a more advanced in blender. In this case we can represent our structure in a fast and easy way.
⬇ If you have any other methods, contribute them below.