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 threadlocal and/or reused - do not retain references.

Only the renderer should implement or extend this interface.

  • Field Details

    • BAKE_ROTATE_NONE

      static final int BAKE_ROTATE_NONE
      Causes texture to appear with no rotation. Pass in bakeFlags parameter to spriteBake(int, Sprite, int).
      See Also:

    • BAKE_ROTATE_90

      static final int BAKE_ROTATE_90
      Causes texture to appear rotated 90 deg. relative to nominal face. Pass in bakeFlags parameter to spriteBake(int, Sprite, int).
      See Also:

    • BAKE_ROTATE_180

      static final int BAKE_ROTATE_180
      Causes texture to appear rotated 180 deg. relative to nominal face. Pass in bakeFlags parameter to spriteBake(int, Sprite, int).
      See Also:

    • BAKE_ROTATE_270

      static final int BAKE_ROTATE_270
      Causes texture to appear rotated 270 deg. relative to nominal face. Pass in bakeFlags parameter to spriteBake(int, Sprite, int).
      See Also:

    • BAKE_LOCK_UV

      static final int BAKE_LOCK_UV
      When enabled, texture coordinate are assigned based on vertex position. Any existing uv coordinates will be replaced. Pass in bakeFlags parameter to spriteBake(int, Sprite, int).

      UV lock always derives texture coordinates based on nominal face, even when the quad is not co-planar with that face, and the result is the same as if the quad were projected onto the nominal face, which is usually the desired result.

      See Also:

    • BAKE_FLIP_U

      static final int BAKE_FLIP_U
      When set, 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 than what can be obtained via rotation and both can be applied. Pass in bakeFlags parameter to spriteBake(int, Sprite, 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(int, Sprite, int).
      See Also:

  • Method Details

    • material

      MutableQuadView material(RenderMaterial material)
      Assigns a different material to this quad. Useful for transformation of existing meshes because lighting and texture blending are controlled by material.

    • cullFace

      @Nullable @Nullable MutableQuadView cullFace(@Nullable @Nullable net.minecraft.util.math.Direction face)
      If non-null, quad is coplanar with a block face which, if known, simplifies or shortcuts geometric analysis that might otherwise be needed. Set to null if quad is not coplanar or if this is not known. Also controls face culling during block rendering.

      Null by default.

      When called with a non-null value, also sets nominalFace(Direction) to the same value.

      This is different than the value reported by BakedQuad.getFace(). That value is computed based on face geometry and must be non-null in vanilla quads. That computed value is returned by QuadView.lightFace().

    • nominalFace

      @Nullable @Nullable MutableQuadView nominalFace(net.minecraft.util.math.Direction face)
      Provides a hint to renderer about the facing of this quad. Not required, but if provided can shortcut some geometric analysis if the quad is parallel to a block face. Should be the expected value of QuadView.lightFace(). Value will be confirmed and if invalid the correct light face will be calculated.

      Null by default, and set automatically by QuadView.cullFace().

      Models may also find this useful as the face for texture UV locking and rotation semantics.

      Note: This value is not persisted independently when the quad is encoded. When reading encoded quads, this value will always be the same as QuadView.lightFace().

    • colorIndex

      MutableQuadView colorIndex(int colorIndex)
      Value functions identically to BakedQuad.getColorIndex() and is used by renderer / model builder in same way. Default value is -1.

    • fromVanilla

      @Deprecated MutableQuadView fromVanilla(int[] quadData, int startIndex, boolean isItem)
      Deprecated.
      Use #fromVanilla(BakedQuad, RenderMaterial, Direction, int[], int) which has better encapsulation and removed outdated item flag
      Enables bulk vertex data transfer using the standard Minecraft vertex formats. This method should be performant whenever caller's vertex representation makes it feasible.

      Calling this method does not emit the quad.

    • fromVanilla

      MutableQuadView fromVanilla(net.minecraft.client.render.model.BakedQuad quad, RenderMaterial material, net.minecraft.util.math.Direction cullFace)
      Enables bulk vertex data transfer using the standard Minecraft vertex formats. This method should be performant whenever caller's vertex representation makes it feasible.

      Calling this method does not emit the quad.

    • tag

      MutableQuadView tag(int tag)
      Encodes an integer tag with this quad that can later be retrieved via QuadView.tag(). Useful for models that want to perform conditional transformation or filtering on static meshes.

    • 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.

    • pos

      default MutableQuadView pos(int vertexIndex, net.minecraft.util.math.Vec3f vec)
      Same as pos(int, float, float, float) but accepts vector type.

    • normal

      MutableQuadView normal(int vertexIndex, float x, float y, float z)
      Adds a vertex normal. Models that have per-vertex normals should include them to get correct lighting when it matters. Computed face normal is used when no vertex normal is provided.

      Renderer implementations should honor vertex normals for diffuse lighting - modifying vertex color(s) or packing normals in the vertex buffer as appropriate for the rendering method/vertex format in effect.

    • normal

      default MutableQuadView normal(int vertexIndex, net.minecraft.util.math.Vec3f vec)
      Same as normal(int, float, float, float) but accepts vector type.

    • lightmap

      MutableQuadView lightmap(int vertexIndex, int lightmap)
      Accept vanilla lightmap values. 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, it is better to use MaterialFinder.emissive(int, boolean).

    • lightmap

      default MutableQuadView lightmap(int b0, int b1, int b2, int b3)
      Convenience: set lightmap for all vertices at once.

      For emissive rendering, it is better to use MaterialFinder.emissive(int, boolean). See lightmap(int, int).

    • spriteColor

      MutableQuadView spriteColor(int vertexIndex, int spriteIndex, int color)
      Set sprite color. Behavior for spriteIndex > 0 is currently undefined.

    • spriteColor

      default MutableQuadView spriteColor(int spriteIndex, int c0, int c1, int c2, int c3)
      Convenience: set sprite color for all vertices at once. Behavior for spriteIndex > 0 is currently undefined.

    • sprite

      MutableQuadView sprite(int vertexIndex, int spriteIndex, float u, float v)
      Set sprite atlas coordinates. Behavior for spriteIndex > 0 is currently undefined.

    • sprite

      default MutableQuadView sprite(int vertexIndex, int spriteIndex, net.minecraft.util.math.Vec2f uv)
      Set sprite atlas coordinates. Behavior for spriteIndex > 0 is currently undefined.

      Only use this function if you already have a Vec2f. Otherwise, see sprite(int, int, float, float).

    • spriteBake

      MutableQuadView spriteBake(int spriteIndex, net.minecraft.client.texture.Sprite sprite, int bakeFlags)
      Assigns sprite atlas u,v coordinates to this quad for the given sprite. Can handle UV locking, rotation, interpolation, etc. Control this behavior by passing additive combinations of the BAKE_ flags defined in this interface. Behavior for spriteIndex > 0 is currently undefined.