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 Summary

Fields

Modifier and Type	Field and Description
static int	BAKE_FLIP_U When set, U texture coordinates for the given sprite are flipped as part of baking.
static int	BAKE_FLIP_V Same as BAKE_FLIP_U but for V coordinate.
static int	BAKE_LOCK_UV When enabled, texture coordinate are assigned based on vertex position.
static int	BAKE_NORMALIZED UV coordinates by default are assumed to be 0-16 scale for consistency with conventional Minecraft model format.
static int	BAKE_ROTATE_180 Causes texture to appear rotated 180 deg.
static int	BAKE_ROTATE_270 Causes texture to appear rotated 270 deg.
static int	BAKE_ROTATE_90 Causes texture to appear rotated 90 deg.
static int	BAKE_ROTATE_NONE Causes texture to appear with no rotation.

Fields inherited from interface net.fabricmc.fabric.api.renderer.v1.mesh.QuadView

VANILLA_QUAD_STRIDE, VANILLA_VERTEX_STRIDE

Method Summary

Modifier and Type	Method and Description
MutableQuadView	colorIndex(int colorIndex) Value functions identically to BakedQuad.getColorIndex() and is used by renderer / model builder in same way.
@Nullable MutableQuadView	cullFace(@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.
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.
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
MutableQuadView	lightmap(int vertexIndex, int lightmap) Accept vanilla lightmap values.
default MutableQuadView	lightmap(int b0, int b1, int b2, int b3) Convenience: set lightmap for all vertices at once.
MutableQuadView	material(RenderMaterial material) Assigns a different material to this quad.
@Nullable MutableQuadView	nominalFace(net.minecraft.util.math.Direction face) Provides a hint to renderer about the facing of this quad.
MutableQuadView	normal(int vertexIndex, float x, float y, float z) Adds a vertex normal.
default MutableQuadView	normal(int vertexIndex, net.minecraft.client.util.math.Vector3f vec) Same as normal(int, float, float, float) but accepts vector type.
MutableQuadView	pos(int vertexIndex, float x, float y, float z) Sets the geometric vertex position for the given vertex, relative to block origin.
default MutableQuadView	pos(int vertexIndex, net.minecraft.client.util.math.Vector3f vec) Same as pos(int, float, float, float) but accepts vector type.
MutableQuadView	sprite(int vertexIndex, int spriteIndex, float u, float v) Set sprite atlas coordinates.
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.
MutableQuadView	spriteColor(int vertexIndex, int spriteIndex, int color) Set sprite color.
default MutableQuadView	spriteColor(int spriteIndex, int c0, int c1, int c2, int c3) Convenience: set sprite color for all vertices at once.
MutableQuadView	tag(int tag) Encodes an integer tag with this quad that can later be retrieved via QuadView.tag().

Methods inherited from interface net.fabricmc.fabric.api.renderer.v1.mesh.QuadView

colorIndex, copyNormal, copyPos, copyTo, cullFace, faceNormal, hasNormal, lightFace, lightmap, material, nominalFace, normalX, normalY, normalZ, posByIndex, spriteColor, spriteU, spriteV, tag, toBakedQuad, toVanilla, x, y, z

Field Detail

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:

Constant Field Values

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:

Constant Field Values

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:

Constant Field Values

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:

Constant Field Values

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:

Constant Field Values

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:

Constant Field Values

BAKE_FLIP_V

static final int BAKE_FLIP_V

Same as BAKE_FLIP_U but for V coordinate.

See Also:

Constant Field Values

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:

Constant Field Values

Method Detail

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.client.util.math.Vector3f 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.client.util.math.Vector3f 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.

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.