MutableQuadViewImpl

public abstract class MutableQuadViewImpl extends QuadViewImpl implements QuadEmitter

Almost-concrete implementation of a mutable quad. The only missing part is emit, because that depends on where/how it is used. (Mesh encoding vs. render-time transformation).

Functions

begin

final void begin(Array<int> data, int baseIndex)

clear

void clear()

colorIndex

abstract int colorIndex()

final int colorIndex()

abstract QuadEmitter colorIndex(int p)

abstract MutableQuadView colorIndex(int p)

final MutableQuadViewImpl colorIndex(int colorIndex)

copyNormal

abstract Vec3f copyNormal(int p, Vec3f p1)

Vec3f copyNormal(int vertexIndex, Vec3f target)

copyPos

abstract Vec3f copyPos(int p, Vec3f p1)

Vec3f copyPos(int vertexIndex, Vec3f target)

copyTo

abstract void copyTo(MutableQuadView p)

void copyTo(MutableQuadView target)

cullFace

abstract Direction cullFace()

final Direction cullFace()

abstract QuadEmitter cullFace(Direction p)

abstract MutableQuadView cullFace(Direction p)

final MutableQuadViewImpl cullFace(Direction face)

data

Array<int> data()

Reference to underlying array.

emit

abstract QuadEmitter emit()

faceNormal

abstract Vec3f faceNormal()

final Vec3f faceNormal()

fromVanilla

abstract QuadEmitter fromVanilla(Array<int> p, int p1, boolean p2)

abstract MutableQuadView fromVanilla(Array<int> p, int p1, boolean p2)

final MutableQuadViewImpl fromVanilla(BakedQuad quad, RenderMaterial material, Direction cullFace)

@Deprecated()

final MutableQuadViewImpl fromVanilla(Array<int> quadData, int startIndex, boolean isItem)

will be removed in 1.

geometryFlags

int geometryFlags()

gets flags used for lighting - lazily computed via computeShapeFlags.

hasNormal

abstract boolean hasNormal(int p)

boolean hasNormal(int vertexIndex)

hasShade

boolean hasShade()

hasVertexNormals

boolean hasVertexNormals()

True if any vertex normal has been set.

lightFace

abstract Direction lightFace()

final Direction lightFace()

lightmap

abstract int lightmap(int p)

int lightmap(int vertexIndex)

abstract QuadEmitter lightmap(int p, int p1)

abstract MutableQuadView lightmap(int p, int p1)

MutableQuadViewImpl lightmap(int vertexIndex, int lightmap)

load

final void load()

Like load but assumes array and index already set.Only does the decoding part.

material

abstract RenderMaterial material()

final RenderMaterialImpl.Value material()

abstract QuadEmitter material(RenderMaterial p)

abstract MutableQuadView material(RenderMaterial p)

final MutableQuadViewImpl material(RenderMaterial material)

nominalFace

abstract Direction nominalFace()

final Direction nominalFace()

abstract QuadEmitter nominalFace(Direction p)

abstract MutableQuadView nominalFace(Direction p)

final MutableQuadViewImpl nominalFace(Direction face)

normal

QuadEmitter normal(int vertexIndex, Vec3f vec)

abstract MutableQuadView normal(int p, float p1, float p2, float p3)

MutableQuadViewImpl normal(int vertexIndex, float x, float y, float z)

normalFlags

int normalFlags()

normalX

abstract float normalX(int p)

float normalX(int vertexIndex)

normalY

abstract float normalY(int p)

float normalY(int vertexIndex)

normalZ

abstract float normalZ(int p)

float normalZ(int vertexIndex)

populateMissingNormals

final void populateMissingNormals()

Internal helper method.

pos

abstract QuadEmitter pos(int p, float p1, float p2, float p3)

abstract MutableQuadView pos(int p, float p1, float p2, float p3)

MutableQuadViewImpl pos(int vertexIndex, float x, float y, float z)

posByIndex

abstract float posByIndex(int p, int p1)

float posByIndex(int vertexIndex, int coordinateIndex)

shade

void shade(boolean shade)

sprite

abstract QuadEmitter sprite(int p, int p1, float p2, float p3)

abstract MutableQuadView sprite(int p, int p1, float p2, float p3)

MutableQuadViewImpl sprite(int vertexIndex, int spriteIndex, float u, float v)

spriteBake

abstract QuadEmitter spriteBake(int p, Sprite p1, int p2)

abstract MutableQuadView spriteBake(int p, Sprite p1, int p2)

MutableQuadViewImpl spriteBake(int spriteIndex, Sprite sprite, int bakeFlags)

spriteColor

abstract int spriteColor(int p, int p1)

int spriteColor(int vertexIndex, int spriteIndex)

abstract QuadEmitter spriteColor(int p, int p1, int p2)

abstract MutableQuadView spriteColor(int p, int p1, int p2)

MutableQuadViewImpl spriteColor(int vertexIndex, int spriteIndex, int color)

spriteU

abstract float spriteU(int p, int p1)

float spriteU(int vertexIndex, int spriteIndex)

spriteUnitSquare

QuadEmitter spriteUnitSquare(int spriteIndex)

spriteV

abstract float spriteV(int p, int p1)

float spriteV(int vertexIndex, int spriteIndex)

square

QuadEmitter square(Direction nominalFace, float left, float bottom, float right, float top, float depth)

tag

abstract int tag()

final int tag()

abstract QuadEmitter tag(int p)

abstract MutableQuadView tag(int p)

final MutableQuadViewImpl tag(int tag)

toBakedQuad

BakedQuad toBakedQuad(int spriteIndex, Sprite sprite, boolean isItem)

toVanilla

abstract void toVanilla(int p, Array<int> p1, int p2, boolean p3)

final void toVanilla(int textureIndex, Array<int> target, int targetIndex, boolean isItem)

vertexStart

int vertexStart()

abstract float x(int p)

float x(int vertexIndex)

abstract float y(int p)

float y(int vertexIndex)

abstract float z(int p)

float z(int vertexIndex)

Sources

jvm source