Package net.fabricmc.fabric.api.renderer.v1.mesh

Interface MutableQuadView

All Superinterfaces:
QuadView
All Known Subinterfaces:
QuadEmitter
public interface MutableQuadView extends QuadView
A mutable QuadView instance. The base interface for QuadEmitter and for dynamic renders/mesh transforms.

Instances of MutableQuadView will practically always be thread local and/or reused - do not retain references.

Unless otherwise stated, assume all properties persist through serialization into Meshes and have an effect in both block and item contexts. If a property is described as transient, then its value will not persist through serialization into a Mesh.

Only the renderer should implement or extend this interface.

  • Field Details

    • BAKE_ROTATE_NONE

      static final int BAKE_ROTATE_NONE
      When enabled, causes texture to appear with no rotation. This is the default and does not have to be specified explicitly. Can be overridden by other rotation flags. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

    • BAKE_ROTATE_90

      static final int BAKE_ROTATE_90
      When enabled, causes texture to appear rotated 90 degrees clockwise. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

    • BAKE_ROTATE_180

      static final int BAKE_ROTATE_180
      When enabled, causes texture to appear rotated 180 degrees. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

    • BAKE_ROTATE_270

      static final int BAKE_ROTATE_270
      When enabled, causes texture to appear rotated 270 degrees clockwise. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

    • BAKE_LOCK_UV

      static final int BAKE_LOCK_UV
      When enabled, texture coordinates are assigned based on vertex positions and the nominal face. Any existing UV coordinates will be replaced and the BAKE_NORMALIZED flag will be ignored. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).

      UV lock derives texture coordinates based on nominal face by projecting the quad onto it, even when the quad is not co-planar with it. This flag is ignored if the normal face is null.

      See Also:

    • BAKE_FLIP_U

      static final int BAKE_FLIP_U
      When enabled, U texture coordinates for the given sprite are flipped as part of baking. Can be useful for some randomization and texture mapping scenarios. Results are different from what can be obtained via rotation and both can be applied. Any rotation is applied before this flag. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

    • BAKE_FLIP_V

      static final int BAKE_FLIP_V
      Same as BAKE_FLIP_U but for V coordinate.
      See Also:

    • BAKE_NORMALIZED

      static final int BAKE_NORMALIZED
      UV coordinates by default are assumed to be 0-16 scale for consistency with conventional Minecraft model format. This is scaled to 0-1 during baking before interpolation. Model loaders that already have 0-1 coordinates can avoid wasteful multiplication/division by passing 0-1 coordinates directly. Pass in bakeFlags parameter to spriteBake(TextureAtlasSprite, int).
      See Also:

  • Method Details

    • pos

      MutableQuadView pos(int vertexIndex, float x, float y, float z)
      Sets the geometric vertex position for the given vertex, relative to block origin, (0,0,0). Minecraft rendering is designed for models that fit within a single block space and is recommended that coordinates remain in the 0-1 range, with multi-block meshes split into multiple per-block models.

      The default value for all vertices is 0.0f.

    • pos

      default MutableQuadView pos(int vertexIndex, org.joml.Vector3f pos)
      Sets the geometric position for the given vertex. Only use this method if you already have a Vector3f. Otherwise, use pos(int, float, float, float).

    • pos

      default MutableQuadView pos(int vertexIndex, org.joml.Vector3fc pos)
      Sets the geometric position for the given vertex. Only use this method if you already have a Vector3fc. Otherwise, use pos(int, float, float, float).

    • color

      MutableQuadView color(int vertexIndex, int color)
      Sets the color in ARGB format (0xAARRGGBB) for the given vertex.

      The default value for all vertices is 0xFFFFFFFF.

    • color

      default MutableQuadView color(int c0, int c1, int c2, int c3)
      Sets the color in ARGB format (0xAARRGGBB) for all vertices at once.
      See Also:

    • uv

      MutableQuadView uv(int vertexIndex, float u, float v)
      Sets the texture coordinates for the given vertex.

      The default value for all vertices is 0.0f.

    • uv

      default MutableQuadView uv(int vertexIndex, org.joml.Vector2f uv)
      Sets the texture coordinates for the given vertex. Only use this method if you already have a Vector2f. Otherwise, use uv(int, float, float).

    • uv

      default MutableQuadView uv(int vertexIndex, org.joml.Vector2fc uv)
      Sets the texture coordinates for the given vertex. Only use this method if you already have a Vector2fc. Otherwise, use uv(int, float, float).

    • spriteBake

      default MutableQuadView spriteBake(net.minecraft.client.renderer.texture.TextureAtlasSprite sprite, int bakeFlags)
      Sets the texture coordinates for all vertices using the given sprite. Also sets this quad's atlas to the given sprite's atlas. Can handle UV locking, rotation, interpolation, etc. Control this behavior by passing additive combinations of the BAKE_ flags defined in this interface.

    • lightmap

      MutableQuadView lightmap(int vertexIndex, int lightmap)
      Sets the minimum lightmap value for the given vertex. Input values will override lightmap values computed from world state if input values are higher. Exposed for completeness but some rendering implementations with non-standard lighting model may not honor it.

      For emissive rendering, prefer using emissive(boolean).

      The default value for all vertices is 0.

    • lightmap

      default MutableQuadView lightmap(int l0, int l1, int l2, int l3)
      Sets the lightmap value for all vertices at once.

      For emissive rendering, prefer using emissive(boolean).

      See Also:

    • normal

      MutableQuadView normal(int vertexIndex, float x, float y, float z)
      Sets the normal vector for the given vertex. The face normal is used when no vertex normal is provided. Models that have per-vertex normals should include them to get correct lighting when it matters.

    • normal

      default MutableQuadView normal(int vertexIndex, org.joml.Vector3f normal)
      Sets the normal vector for the given vertex. Only use this method if you already have a Vector3f. Otherwise, use normal(int, float, float, float).

    • normal

      default MutableQuadView normal(int vertexIndex, org.joml.Vector3fc normal)
      Sets the normal vector for the given vertex. Only use this method if you already have a Vector3fc. Otherwise, use normal(int, float, float, float).

    • nominalFace

      MutableQuadView nominalFace(@Nullable net.minecraft.core.Direction face)
      Sets the nominal face, which provides a hint to the renderer about the facing of this quad. It is not required, but if set, should be the expected value of QuadView.lightFace(). It may be used to shortcut geometric analysis, if the provided value was correct; otherwise, it is ignored.

      The nominal face is also used for spriteBake(TextureAtlasSprite, int) with BAKE_LOCK_UV.

      When cullFace(Direction) is called, it also sets the nominal face.

      The default value is null.

      This property is transient. It is set to the same value as QuadView.lightFace() when a quad is decoded.

    • cullFace

      MutableQuadView cullFace(@Nullable net.minecraft.core.Direction face)
      Sets the cull face. This quad will not be rendered if its cull face is non-null and the block is occluded by another block in the direction of the cull face.

      The cull face is different from BakedQuad.direction(), which is equivalent to QuadView.lightFace(). The light face is computed based on geometry and must be non-null.

      When called, sets nominalFace(Direction) to the same value.

      The default value is null.

      This property is respected only in block contexts. It will not have an effect in other contexts.

    • renderLayer

      MutableQuadView renderLayer(@Nullable net.minecraft.client.renderer.chunk.ChunkSectionLayer renderLayer)
      Controls how this quad's pixels should be blended with the scene.

      If set to null, ItemBlockRenderTypes.getChunkRenderType(BlockState) will be used to retrieve the render layer in block contexts. Set to another value to override this behavior.

      In block contexts, a non-null value will be used directly. In item contexts, any value will be converted to a RenderType using FabricLayerRenderState.setRenderTypeGetter(ItemRenderTypeGetter).

      The default value is null.

    • emissive

      MutableQuadView emissive(boolean emissive)
      When true, this quad will be rendered at full brightness. Lightmap values provided via QuadView.lightmap(int) will be ignored.

      This is the preferred method for emissive lighting effects as some renderers with advanced lighting pipelines may not use lightmaps.

      Note that vertex colors will still be modified by diffuse shading and ambient occlusion, unless disabled via diffuseShade(boolean) and ambientOcclusion(TriState).

      The default value is false.

    • diffuseShade

      MutableQuadView diffuseShade(boolean shade)
      Controls whether vertex colors should be modified for diffuse shading.

      The default value is true.

      This property is guaranteed to be respected in block contexts. Some renderers may also respect it in item contexts, but this is not guaranteed.

    • ambientOcclusion

      MutableQuadView ambientOcclusion(TriState ao)
      Controls whether vertex colors should be modified for ambient occlusion.

      If set to TriState.DEFAULT, ambient occlusion will be used if the block state has BlockBehaviour.BlockStateBase.getLightEmission() a luminance} of 0. Set to TriState.TRUE or TriState.FALSE to override this behavior. TriState.TRUE will not have an effect if Minecraft.useAmbientOcclusion() ambient occlusion is disabled globally}.

      The default value is TriState.DEFAULT.

      This property is respected only in block contexts. It will not have an effect in other contexts.

    • glint

      MutableQuadView glint(@Nullable net.minecraft.client.renderer.item.ItemStackRenderState.FoilType glint)
      Controls how glint should be applied.

      If set to null, glint will be applied in item contexts based on ItemStackRenderState.LayerRenderState.setFoilType(ItemStackRenderState.FoilType) the glint type of the layer}. Set to another value to override this behavior.

      The default value is null.

      This property is guaranteed to be respected in item contexts. Some renderers may also respect it in block contexts, but this is not guaranteed.

    • shadeMode

      MutableQuadView shadeMode(ShadeMode mode)
      A hint to the renderer about how this quad is intended to be shaded, for example through ambient occlusion and diffuse shading. The renderer is free to ignore this hint.

      The default value is ShadeMode.ENHANCED.

      This property is respected only in block contexts. It will not have an effect in other contexts.

      See Also:

    • atlas

      MutableQuadView atlas(QuadAtlas quadAtlas)
      Sets the atlas texture used by this quad.

      In block contexts, this property must be QuadAtlas.BLOCK. In item contexts, this property will be converted to a RenderType using FabricLayerRenderState.setRenderTypeGetter(ItemRenderTypeGetter).

      The default value is QuadAtlas.BLOCK.

      See Also:

    • tintIndex

      MutableQuadView tintIndex(int tintIndex)
      Sets the tint index, which is used to retrieve the tint color.

      The default value is -1.

    • tag

      MutableQuadView tag(int tag)
      Sets the tag, which is an arbitrary integer that is meant to be encoded into Meshes to later allow performing conditional transformation or filtering on their quads.

      The default value is 0.

    • copyFrom

      MutableQuadView copyFrom(QuadView quad)
      Copies all quad data and properties from the given QuadView to this quad.

      Calling this method does not emit this quad.

    • fromBakedQuad

      MutableQuadView fromBakedQuad(net.minecraft.client.renderer.block.model.BakedQuad quad)
      Sets all applicable data and properties of this quad as specified by the given BakedQuad. In addition, this quad's vertex colors and vertex normals will be reset. This quad's existing lightmap values will be ignored.

      Calling this method does not emit this quad.