codechicken.lib.vec.Vertex5

Here are the examples of the java api codechicken.lib.vec.Vertex5 taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

9 Examples 7

19 Source : ButtonModelLibrary.java
with MIT License
from TheCBProject

private static void generateButton() {
    button = CCModel.quadModel(20);
    Vector3 min = TileFrequencyOwner.selection_button.min;
    Vector3 max = TileFrequencyOwner.selection_button.max;
    Vector3[] corners = new Vector3[8];
    corners[0] = new Vector3(min.x, min.y, min.z);
    corners[1] = new Vector3(max.x, min.y, min.z);
    corners[3] = new Vector3(min.x, max.y, min.z);
    corners[2] = new Vector3(max.x, max.y, min.z);
    corners[4] = new Vector3(min.x, min.y, max.z);
    corners[5] = new Vector3(max.x, min.y, max.z);
    corners[7] = new Vector3(min.x, max.y, max.z);
    corners[6] = new Vector3(max.x, max.y, max.z);
    int i = 0;
    Vertex5[] verts = button.verts;
    verts[i++] = new Vertex5(corners[7], 0.0938, 0.0625);
    verts[i++] = new Vertex5(corners[6], 0.1562, 0.0625);
    verts[i++] = new Vertex5(corners[2], 0.1562, 0.1875);
    verts[i++] = new Vertex5(corners[3], 0.0938, 0.1875);
    verts[i++] = new Vertex5(corners[4], 0.0938, 0.0313);
    verts[i++] = new Vertex5(corners[5], 0.1562, 0.0624);
    verts[i++] = new Vertex5(corners[6], 0.1562, 0.0624);
    verts[i++] = new Vertex5(corners[7], 0.0938, 0.0313);
    verts[i++] = new Vertex5(corners[0], 0.0938, 0.2186);
    verts[i++] = new Vertex5(corners[3], 0.0938, 0.1876);
    verts[i++] = new Vertex5(corners[2], 0.1562, 0.1876);
    verts[i++] = new Vertex5(corners[1], 0.1562, 0.2186);
    verts[i++] = new Vertex5(corners[6], 0.1563, 0.0626);
    verts[i++] = new Vertex5(corners[5], 0.1874, 0.0626);
    verts[i++] = new Vertex5(corners[1], 0.1874, 0.1874);
    verts[i++] = new Vertex5(corners[2], 0.1563, 0.1874);
    verts[i++] = new Vertex5(corners[7], 0.0937, 0.0626);
    verts[i++] = new Vertex5(corners[3], 0.0937, 0.1874);
    verts[i++] = new Vertex5(corners[0], 0.0626, 0.1874);
    verts[i++] = new Vertex5(corners[4], 0.0626, 0.0626);
    button.computeNormals();
}

19 Source : BakedVertexSource.java
with GNU Lesser General Public License v2.1
from TheCBProject

/**
 * Created by covers1624 on 12/5/20.
 */
public clreplaced BakedVertexSource implements IVertexSource, ISmartVertexConsumer {

    private static final ThreadLocal<BakedVertexSource> instances = ThreadLocal.withInitial(BakedVertexSource::new);

    private final Quad unpacker = new Quad(CachedFormat.lookup(DefaultVertexFormats.BLOCK));

    private int vertexIndex = -1;

    private Vertex5[] vertices = new Vertex5[0];

    private Object[][] attributes = new Object[0][0];

    private TextureAtlreplacedprite[] sprites = new TextureAtlreplacedprite[0];

    private BakedVertexSource() {
        ensureAttr(AttributeKeyRegistry.numAttributes() - 1);
        // Ensure enough space for a full standard block model.
        ensureSpace(24);
    }

    public static BakedVertexSource instance() {
        return instances.get();
    }

    @Override
    public Vertex5[] getVertices() {
        return vertices;
    }

    @Override
    public <T> T getAttributes(AttributeKey<T> attr) {
        ensureAttr(attr.attributeKeyIndex);
        return unsafeCast(attributes[attr.attributeKeyIndex]);
    }

    @Override
    public boolean hasAttribute(AttributeKey<?> attr) {
        return attr == NormalAttribute.attributeKey || attr == ColourAttribute.attributeKey || attr == LightCoordAttribute.attributeKey;
    }

    @Override
    public void prepareVertex(CCRenderState ccrs) {
    }

    public void reset() {
        vertexIndex = -1;
    }

    public int availableVertices() {
        return vertexIndex + 1;
    }

    private void onFull() {
        if (vertexIndex == -1) {
            vertexIndex = 0;
        }
        ensureSpace(availableVertices() + 4);
        for (int i = 0; i < 4; i++) {
            int v = vertexIndex++;
            Quad.Vertex vertex = unpacker.vertices[i];
            Vertex5 vertex5 = vertices[v];
            vertex5.vec.set(vertex.vec);
            vertex5.uv.set(vertex.uv);
            Vector3 normal = getAttr(NormalAttribute.attributeKey)[v];
            normal.set(vertex.normal);
            getAttr(LightCoordAttribute.attributeKey)[v].compute(vertex5.vec, normal);
            getAttr(ColourAttribute.attributeKey)[v] = Colour.packRGBA(vertex.color);
        }
    }

    private void ensureAttr(int aIdx) {
        if (attributes.length <= aIdx) {
            attributes = Arrays.copyOf(attributes, aIdx + 1);
        }
    }

    // Expands array storage.
    private void ensureSpace(int numVertices) {
        // If we don't have enough, or are full, expand.
        if (vertices.length <= numVertices) {
            int fillStart = vertexIndex == -1 ? 0 : vertexIndex;
            vertices = Arrays.copyOf(vertices, numVertices);
            fill(vertices, fillStart, numVertices, Vertex5::new);
            for (int aIdx = 0; aIdx < attributes.length; aIdx++) {
                Object[] attr = attributes[aIdx];
                AttributeKey<?> key = AttributeKeyRegistry.getAttributeKey(aIdx);
                if (attr == null) {
                    attr = unsafeCast(key.newArray(numVertices));
                } else {
                    attr = Arrays.copyOf(attr, numVertices);
                }
                attributes[aIdx] = attr;
                // Fill non primitive vertex attributes with new things.
                if (key == NormalAttribute.attributeKey) {
                    fill(attr, fillStart, numVertices, Vector3::new);
                } else if (key == LightCoordAttribute.attributeKey) {
                    fill(attr, fillStart, numVertices, LC::new);
                }
            }
            sprites = Arrays.copyOf(sprites, numVertices);
        }
    }

    private <T> T getAttr(AttributeKey<T> key) {
        return unsafeCast(attributes[key.attributeKeyIndex]);
    }

    @Override
    public void put(Quad quad) {
        unpacker.put(quad);
        onFull();
    }

    @Override
    public void put(int element, float... data) {
        unpacker.put(element, data);
        if (unpacker.full) {
            onFull();
        }
    }

    // @formatter:off
    @Override
    public VertexFormat getVertexFormat() {
        return DefaultVertexFormats.BLOCK;
    }

    @Override
    public void setQuadTint(int tint) {
        unpacker.setQuadTint(tint);
    }

    @Override
    public void setQuadOrientation(Direction orientation) {
        unpacker.setQuadOrientation(orientation);
    }

    @Override
    public void setApplyDiffuseLighting(boolean diffuse) {
        unpacker.setApplyDiffuseLighting(diffuse);
    }

    @Override
    public void setTexture(TextureAtlreplacedprite texture) {
        unpacker.setTexture(texture);
    }

    // @formatter:on
    private static void fill(Object[] arr, int start, int end, Supplier<Object> supplier) {
        for (int i = start; i < end; i++) {
            arr[i] = supplier.get();
        }
    }
}

19 Source : PlanarFaceBakery.java
with GNU Lesser General Public License v2.1
from TheCBProject

public static BakedQuad bakeFace(Direction face, TextureAtlreplacedprite sprite, VertexFormat format, Colour colour) {
    UVTransformation t = new IconTransformation(sprite);
    double x1 = Cuboid6.full.min.x;
    double x2 = Cuboid6.full.max.x;
    double y1 = Cuboid6.full.min.y;
    double y2 = Cuboid6.full.max.y;
    double z1 = Cuboid6.full.min.z;
    double z2 = Cuboid6.full.max.z;
    double u1;
    double u2;
    double v1;
    double v2;
    Vertex5 vert1;
    Vertex5 vert2;
    Vertex5 vert3;
    Vertex5 vert4;
    switch(face) {
        case DOWN:
            u1 = x1;
            v1 = z1;
            u2 = x2;
            v2 = z2;
            vert1 = new Vertex5(x1, y1, z2, u1, v2);
            vert2 = new Vertex5(x1, y1, z1, u1, v1);
            vert3 = new Vertex5(x2, y1, z1, u2, v1);
            vert4 = new Vertex5(x2, y1, z2, u2, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
        case UP:
            u1 = x1;
            v1 = z1;
            u2 = x2;
            v2 = z2;
            vert1 = new Vertex5(x2, y2, z2, u2, v2);
            vert2 = new Vertex5(x2, y2, z1, u2, v1);
            vert3 = new Vertex5(x1, y2, z1, u1, v1);
            vert4 = new Vertex5(x1, y2, z2, u1, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
        case NORTH:
            u1 = 1 - x1;
            v1 = 1 - y2;
            u2 = 1 - x2;
            v2 = 1 - y1;
            vert1 = new Vertex5(x1, y1, z1, u1, v2);
            vert2 = new Vertex5(x1, y2, z1, u1, v1);
            vert3 = new Vertex5(x2, y2, z1, u2, v1);
            vert4 = new Vertex5(x2, y1, z1, u2, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
        case SOUTH:
            u1 = x1;
            v1 = 1 - y2;
            u2 = x2;
            v2 = 1 - y1;
            vert1 = new Vertex5(x2, y1, z2, u2, v2);
            vert2 = new Vertex5(x2, y2, z2, u2, v1);
            vert3 = new Vertex5(x1, y2, z2, u1, v1);
            vert4 = new Vertex5(x1, y1, z2, u1, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
        case WEST:
            u1 = z1;
            v1 = 1 - y2;
            u2 = z2;
            v2 = 1 - y1;
            vert1 = new Vertex5(x1, y1, z2, u2, v2);
            vert2 = new Vertex5(x1, y2, z2, u2, v1);
            vert3 = new Vertex5(x1, y2, z1, u1, v1);
            vert4 = new Vertex5(x1, y1, z1, u1, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
        case EAST:
            u1 = 1 - z1;
            v1 = 1 - y2;
            u2 = 1 - z2;
            v2 = 1 - y1;
            vert1 = new Vertex5(x2, y1, z1, u1, v2);
            vert2 = new Vertex5(x2, y2, z1, u1, v1);
            vert3 = new Vertex5(x2, y2, z2, u2, v1);
            vert4 = new Vertex5(x2, y1, z2, u2, v2);
            return VertexDataUtils.buildQuad(format, sprite, face, colour, t, vert1, vert2, vert3, vert4);
    }
    return null;
}

18 Source : CCRenderState.java
with GNU Lesser General Public License v2.1
from TheCBProject

/**
 * The core of the CodeChickenLib render system.
 * Where possible replacedign a local var of CCRenderState to avoid millions of calls to instance();
 * Uses a ThreadLocal system to replacedign each thread their own CCRenderState so we can use it in Mulreplacedhreaded chunk batching.
 * TODO, proper piping of BakedQuads and CCBakedQuads.
 */
public clreplaced CCRenderState {

    private static final ThreadLocal<CCRenderState> instances = ThreadLocal.withInitial(CCRenderState::new);

    // Each attrib needs to be replacedigned in this order to have a valid operation index.
    public final VertexAttribute<Vector3[]> normalAttrib = new NormalAttribute();

    public final VertexAttribute<int[]> colourAttrib = new ColourAttribute();

    public final VertexAttribute<int[]> lightingAttrib = new LightingAttribute();

    public final VertexAttribute<int[]> sideAttrib = new SideAttribute();

    public final VertexAttribute<LC[]> lightCoordAttrib = new LightCoordAttribute();

    // pipeline state
    public IVertexSource model;

    public int firstVertexIndex;

    public int lastVertexIndex;

    public int vertexIndex;

    public CCRenderPipeline pipeline;

    public IVertexBuilder r;

    public VertexFormat fmt;

    public CachedFormat cFmt;

    // context
    /**
     * The base color, multiplied by the {@link ColourAttribute} from the bound model if present otherwise used as-is.
     */
    public int baseColour;

    /**
     * An override for the alpha colour component.
     */
    public int alphaOverride;

    /**
     * Lets the {@link LightMatrix} or {@link PlanarLightModel} know if this {@link CCRenderState} should compute lighting.
     */
    public boolean computeLighting;

    /**
     * A standard {@link LightMatrix} instance to be shared on this pipeline.
     */
    public LightMatrix lightMatrix = new LightMatrix();

    // vertex outputs
    public final Vertex5 vert = new Vertex5();

    public final Vector3 normal = new Vector3();

    public int colour;

    public int brightness;

    public int overlay;

    // attribute storage
    public int side;

    public LC lc = new LC();

    public TextureAtlreplacedprite sprite;

    private CCRenderState() {
        pipeline = new CCRenderPipeline(this);
    }

    public static CCRenderState instance() {
        return instances.get();
    }

    /**
     * Bind this {@link CCRenderState} instance to the {@link Tessellator} buffer
     * and prepare to start drawing vertices for the given <code>mode</code> and {@link VertexFormat}.
     *
     * @param mode   The GL integer mode. E.g: GL_QUADS, GL_TRIANGLES, and so on.
     * @param format The {@link VertexFormat}.
     * @return The {@link BufferBuilder} instance from {@link Tessellator}.
     */
    public BufferBuilder startDrawing(int mode, VertexFormat format) {
        BufferBuilder r = Tessellator.getInstance().getBuffer();
        r.begin(mode, format);
        bind(r);
        return r;
    }

    /**
     * Bind this {@link CCRenderState} instance to the given {@link BufferBuilder}
     * and prepare to start drawing vertices for the given <code>mode</code> and {@link VertexFormat}.
     *
     * @param mode   The GL integer mode. E.g: GL_QUADS, GL_TRIANGLES, and so on.
     * @param format The {@link VertexFormat}.
     * @param buffer The {@link BufferBuilder} to bind to.
     * @return The same {@link BufferBuilder} that was preplaceded in.
     */
    public BufferBuilder startDrawing(int mode, VertexFormat format, BufferBuilder buffer) {
        buffer.begin(mode, format);
        bind(buffer);
        return buffer;
    }

    /**
     * Bind this {@link CCRenderState} instance to the given {@link BufferBuilder}.
     *
     * @param r The {@link BufferBuilder}.
     */
    public void bind(BufferBuilder r) {
        bind(r, r.getVertexFormat());
    }

    /**
     * Bind this {@link CCRenderState} to the given {@link IVertexBuilder} and {@link VertexFormat}.
     *
     * @param consumer The {@link IVertexBuilder} to bind to.
     * @param format   The {@link VertexFormat} of the {@link IVertexBuilder}.
     */
    public void bind(IVertexBuilder consumer, VertexFormat format) {
        r = consumer;
        fmt = format;
        cFmt = CachedFormat.lookup(format);
    }

    /**
     * Bind this {@link CCRenderState} to the given {@link RenderType}.
     *
     * @param renderType The {@link RenderType} to bind to.
     * @param getter     The {@link IRenderTypeBuffer} instance.
     */
    public void bind(RenderType renderType, IRenderTypeBuffer getter) {
        bind(getter.getBuffer(renderType), renderType.getVertexFormat());
    }

    /**
     * Bind this {@link CCRenderState} to the given {@link RenderType}, applying
     * the given MatrixStack.
     *
     * @param renderType The {@link RenderType} to bind to.
     * @param getter     The {@link IRenderTypeBuffer} instance.
     * @param mStack     The {@link MatrixStack} to apply.
     */
    public void bind(RenderType renderType, IRenderTypeBuffer getter, MatrixStack mStack) {
        bind(new TransformingVertexBuilder(getter.getBuffer(renderType), mStack), renderType.getVertexFormat());
    }

    /**
     * Bind this {@link CCRenderState} to the given {@link RenderType}, applying
     * the given MatrixStack.
     *
     * @param renderType The {@link RenderType} to bind to.
     * @param getter     The {@link IRenderTypeBuffer} instance.
     * @param mat        The {@link Matrix4} to apply.
     */
    public void bind(RenderType renderType, IRenderTypeBuffer getter, Matrix4 mat) {
        bind(new TransformingVertexBuilder(getter.getBuffer(renderType), mat), renderType.getVertexFormat());
    }

    /**
     * Resets this {@link CCRenderState} instance's pipeline and internal state.
     */
    public void reset() {
        model = null;
        pipeline.reset();
        computeLighting = true;
        colour = baseColour = alphaOverride = -1;
    }

    public void preRenderWorld(IBlockDisplayReader world, BlockPos pos) {
        this.reset();
        this.colour = 0xFFFFFFFF;
        this.setBrightness(world, pos);
    }

    public void setPipeline(IVertexOperation... ops) {
        pipeline.setPipeline(ops);
    }

    public void setPipeline(IVertexSource model, int start, int end, IVertexOperation... ops) {
        pipeline.reset();
        setModel(model, start, end);
        pipeline.setPipeline(ops);
    }

    public void bindModel(IVertexSource model) {
        if (this.model != model) {
            this.model = model;
            pipeline.rebuild();
        }
    }

    public void setModel(IVertexSource source) {
        setModel(source, 0, source.getVertices().length);
    }

    public void setModel(IVertexSource source, int start, int end) {
        bindModel(source);
        setVertexRange(start, end);
    }

    public void setVertexRange(int start, int end) {
        firstVertexIndex = start;
        lastVertexIndex = end;
    }

    public void render(IVertexOperation... ops) {
        setPipeline(ops);
        render();
    }

    public void render() {
        Vertex5[] verts = model.getVertices();
        for (vertexIndex = firstVertexIndex; vertexIndex < lastVertexIndex; vertexIndex++) {
            model.prepareVertex(this);
            vert.set(verts[vertexIndex]);
            runPipeline();
            writeVert();
        }
    }

    public void runPipeline() {
        pipeline.operate();
    }

    public void writeVert() {
        if (r instanceof ISpriteAwareVertexBuilder) {
            ((ISpriteAwareVertexBuilder) r).sprite(sprite);
        }
        ImmutableList<VertexFormatElement> elements = fmt.getElements();
        for (int e = 0; e < elements.size(); e++) {
            VertexFormatElement fmte = elements.get(e);
            switch(fmte.getUsage()) {
                case POSITION:
                    r.pos(vert.vec.x, vert.vec.y, vert.vec.z);
                    break;
                case UV:
                    int idx = fmte.getIndex();
                    switch(idx) {
                        case 0:
                            r.tex((float) vert.uv.u, (float) vert.uv.v);
                            break;
                        case 1:
                            r.overlay(overlay);
                            break;
                        case 2:
                            r.lightmap(brightness);
                            break;
                    }
                    break;
                case COLOR:
                    if (r instanceof BufferBuilder && ((BufferBuilder) r).defaultColor) {
                        // -_- replaced mojang..
                        ((BufferBuilder) r).nextVertexFormatIndex();
                    } else {
                        r.color(colour >>> 24, colour >> 16 & 0xFF, colour >> 8 & 0xFF, alphaOverride >= 0 ? alphaOverride : colour & 0xFF);
                    }
                    break;
                case NORMAL:
                    r.normal((float) normal.x, (float) normal.y, (float) normal.z);
                    break;
                case PADDING:
                    break;
                default:
                    throw new UnsupportedOperationException("Generic vertex format element");
            }
        }
        r.endVertex();
    }

    @Deprecated
    public void pushColour() {
        GlStateManager.color4f((colour >>> 24) / 255F, (colour >> 16 & 0xFF) / 255F, (colour >> 8 & 0xFF) / 255F, (alphaOverride >= 0 ? alphaOverride : colour & 0xFF) / 255F);
    }

    public void setBrightness(IBlockDisplayReader world, BlockPos pos) {
        brightness = WorldRenderer.getPackedLightmapCoords(world, world.getBlockState(pos), pos);
    }

    public void setBrightness(Enreplacedy enreplacedy, float frameDelta) {
        brightness = Minecraft.getInstance().getRenderManager().getPackedLight(enreplacedy, frameDelta);
    }

    public void setFluidColour(FluidStack fluidStack) {
        setFluidColour(fluidStack, 0xFF);
    }

    public void setFluidColour(FluidStack fluidStack, int alpha) {
        this.baseColour = fluidStack.getFluid().getAttributes().getColor(fluidStack) << 8 | alpha;
    }

    public void setColour(Colour colour) {
        this.colour = colour.rgba();
    }

    public ColourRGBA getColour() {
        return new ColourRGBA(colour);
    }

    public IVertexBuilder getConsumer() {
        return r;
    }

    public VertexFormat getVertexFormat() {
        return fmt;
    }

    public void draw() {
        Tessellator.getInstance().draw();
    }
}

18 Source : CCRenderState.java
with GNU Lesser General Public License v2.1
from TheCBProject

public void render() {
    Vertex5[] verts = model.getVertices();
    for (vertexIndex = firstVertexIndex; vertexIndex < lastVertexIndex; vertexIndex++) {
        model.prepareVertex(this);
        vert.set(verts[vertexIndex]);
        runPipeline();
        writeVert();
    }
}

17 Source : VertexDataUtils.java
with GNU Lesser General Public License v2.1
from TheCBProject

private static void putVertex(BakedQuadBuilder builder, VertexFormat format, Direction face, Vertex5 vert, Colour colour) {
// for (int e = 0; e < format.getElementCount(); e++) {
// VertexFormatElement element = format.getElement(e);
// switch (element.getUsage()) {
// 
// case POSITION:
// Vector3 vec = vert.vec;
// builder.put(e, (float) vec.x, (float) vec.y, (float) vec.z, 1);
// break;
// case NORMAL:
// builder.put(e, face.getXOffset(), face.getYOffset(), face.getZOffset(), 0);
// break;
// case COLOR:
// builder.put(e, (colour.r & 0xFF) / 255F, (colour.g & 0xFF) / 255F, (colour.b & 0xFF) / 255F, (colour.a & 0xFF) / 255F);
// break;
// case UV:
// UV uv = vert.uv;
// builder.put(e, (float) uv.u, (float) uv.v, 0, 1);
// break;
// default:
// builder.put(e);
// break;
// }
// }
}

17 Source : VertexDataUtils.java
with GNU Lesser General Public License v2.1
from TheCBProject

public static BakedQuad buildQuad(VertexFormat format, TextureAtlreplacedprite sprite, Direction face, Colour colour, UVTransformation t, Vertex5 v1, Vertex5 v2, Vertex5 v3, Vertex5 v4) {
    // BakedQuadBuilder builder = new BakedQuadBuilder(format);
    // builder.setQuadTint(-1);
    // builder.setQuadOrientation(face);
    // builder.setTexture(sprite);
    // 
    // t.apply(v1.uv);
    // t.apply(v2.uv);
    // t.apply(v3.uv);
    // t.apply(v4.uv);
    // putVertex(builder, format, face, v1, colour);
    // putVertex(builder, format, face, v2, colour);
    // putVertex(builder, format, face, v3, colour);
    // putVertex(builder, format, face, v4, colour);
    // 
    // return copyQuad(builder.build());
    return null;
}

15 Source : ModelHelper.java
with GNU Lesser General Public License v2.1
from TheCBProject

/**
 * Quadulates a CCModel.
 * Only Position and UV data is copied.
 *
 * @param inModel The in model.
 * @return The new model.
 */
public static CCModel quadulate(CCModel inModel) {
    if (inModel.vertexMode == 7) {
        throw new IllegalArgumentException("Cannot quadulate a quad model. Check if the model is triangles before calling this");
    }
    List<Vertex5> verts = new LinkedList<>();
    Iterator<Vertex5> iter = verts.iterator();
    while (iter.hasNext()) {
        verts.add(iter.next());
        verts.add(iter.next());
        Vertex5 copy = iter.next();
        verts.add(copy);
        verts.add(copy.copy());
    }
    CCModel outModel = CCModel.quadModel(verts.size());
    outModel.verts = verts.toArray(outModel.verts);
    return outModel;
}

15 Source : BakedVertexSource.java
with GNU Lesser General Public License v2.1
from TheCBProject

private void onFull() {
    if (vertexIndex == -1) {
        vertexIndex = 0;
    }
    ensureSpace(availableVertices() + 4);
    for (int i = 0; i < 4; i++) {
        int v = vertexIndex++;
        Quad.Vertex vertex = unpacker.vertices[i];
        Vertex5 vertex5 = vertices[v];
        vertex5.vec.set(vertex.vec);
        vertex5.uv.set(vertex.uv);
        Vector3 normal = getAttr(NormalAttribute.attributeKey)[v];
        normal.set(vertex.normal);
        getAttr(LightCoordAttribute.attributeKey)[v].compute(vertex5.vec, normal);
        getAttr(ColourAttribute.attributeKey)[v] = Colour.packRGBA(vertex.color);
    }
}