codechicken.lib.vec.Vector3 - java examples

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

110 Examples 7

19 View Complete Implementation : TileTranslocatorRenderer.java
Copyright MIT License
Author : Chicken-Bones
private static Vector3 getPathNormal(int src, int dst, double d) {
    if ((src ^ 1) == dst)
        return sideVec[(src + 4) % 6].copy();
    double sind = MathHelper.sin(d * Math.PI / 2);
    double cosd = MathHelper.cos(d * Math.PI / 2);
    Vector3 vsrc = sideVec[src ^ 1].copy();
    Vector3 vdst = sideVec[dst ^ 1].copy();
    return vsrc.multiply(sind).add(vdst.multiply(cosd)).normalize();
}

19 View Complete Implementation : RedstoneEtherServerAddons.java
Copyright MIT License
Author : Chicken-Bones
private void updatePlayerMapData(EnreplacedyPlayer player, World world, MapData mapdata, Map<BlockCoord, TXNodeInfo> txnodes, Set<WirelessTransmittingDevice> devices) {
    TreeSet<FreqCoord> mnodes = new TreeSet<FreqCoord>();
    TreeSet<FreqCoord> mdevices = new TreeSet<FreqCoord>();
    int blockwidth = 1 << mapdata.scale;
    int minx = mapdata.xCenter - blockwidth * 64;
    int minz = mapdata.zCenter - blockwidth * 64;
    int maxx = mapdata.xCenter + blockwidth * 64;
    int maxz = mapdata.zCenter + blockwidth * 64;
    for (Entry<BlockCoord, TXNodeInfo> entry : txnodes.entrySet()) {
        BlockCoord node = entry.getKey();
        TXNodeInfo info = entry.getValue();
        if (info.on && node.x > minx && node.x < maxx && node.z > minz && node.z < maxz && RedstoneEther.server().canBroadcastOnFrequency(player, info.freq)) {
            mnodes.add(new FreqCoord(node.x - mapdata.xCenter, node.y, node.z - mapdata.zCenter, info.freq));
        }
    }
    for (Iterator<WirelessTransmittingDevice> iterator = devices.iterator(); iterator.hasNext(); ) {
        WirelessTransmittingDevice device = iterator.next();
        Vector3 pos = device.getPosition();
        if (pos.x > minx && pos.x < maxx && pos.z > minz && pos.z < maxz && RedstoneEther.server().canBroadcastOnFrequency(player, device.getFreq())) {
            mdevices.add(new FreqCoord((int) pos.x, (int) pos.y, (int) pos.z, device.getFreq()));
        }
    }
    WirelessMapNodeStorage mapnodes = getMapNodes(player);
    mapnodes.nodes = mnodes;
    mapnodes.devices = mdevices;
}

19 View Complete Implementation : EntityDigIconFX.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public static void addBlockDestroyEffects(World world, Cuboid6 bounds, TextureAtlreplacedprite[] icons, EffectRenderer effectRenderer) {
    Vector3 diff = bounds.max.copy().subtract(bounds.min);
    Vector3 center = bounds.min.copy().add(bounds.max).multiply(0.5);
    Vector3 density = diff.copy().multiply(4);
    density.x = Math.ceil(density.x);
    density.y = Math.ceil(density.y);
    density.z = Math.ceil(density.z);
    for (int i = 0; i < density.x; ++i) for (int j = 0; j < density.y; ++j) for (int k = 0; k < density.z; ++k) {
        double x = bounds.min.x + (i + 0.5) * diff.x / density.x;
        double y = bounds.min.y + (j + 0.5) * diff.y / density.y;
        double z = bounds.min.z + (k + 0.5) * diff.z / density.z;
        effectRenderer.addEffect(new EnreplacedyDigIconFX(world, x, y, z, x - center.x, y - center.y, z - center.z, icons[world.rand.nextInt(icons.length)]));
    }
}

19 View Complete Implementation : TileCraftingGridRenderer.java
Copyright MIT License
Author : Chicken-Bones
@Override
public void renderTileEnreplacedyAt(TileEnreplacedy tile, double x, double y, double z, float f) {
    TileCraftingGrid tcraft = (TileCraftingGrid) tile;
    TextureUtils.bindAtlas(0);
    IIcon icon = Translocator.blockCraftingGrid.gridIcon;
    Tessellator t = Tessellator.instance;
    t.setTranslation(x, y + 0.001, z);
    t.startDrawingQuads();
    t.setNormal(0, 1, 0);
    t.addVertexWithUV(1, 0, 0, icon.getMinU(), icon.getMinV());
    t.addVertexWithUV(0, 0, 0, icon.getMinU(), icon.getMaxV());
    t.addVertexWithUV(0, 0, 1, icon.getMaxU(), icon.getMaxV());
    t.addVertexWithUV(1, 0, 1, icon.getMaxU(), icon.getMinV());
    t.draw();
    t.setTranslation(0, 0, 0);
    GL11.glEnable(GL12.GL_RESCALE_NORMAL);
    GL11.glPushMatrix();
    GL11.glTranslated(x + 0.5, y, z + 0.5);
    Transformation orient = Rotation.quarterRotations[tcraft.rotation];
    for (int i = 0; i < 9; i++) {
        ItemStack item = tcraft.items[i];
        if (item == null)
            continue;
        int row = i / 3;
        int col = i % 3;
        Vector3 pos = new Vector3((col - 1) * 5 / 16D, 0.1 + 0.01 * Math.sin(i * 1.7 + ClientUtils.getRenderTime() / 5), (row - 1) * 5 / 16D).apply(orient);
        GL11.glPushMatrix();
        GL11.glTranslated(pos.x, pos.y, pos.z);
        GL11.glScaled(0.5, 0.5, 0.5);
        RenderUtils.renderItemUniform(item);
        GL11.glPopMatrix();
    }
    if (tcraft.result != null) {
        GL11.glPushMatrix();
        GL11.glTranslated(0, 0.6 + 0.02 * Math.sin(ClientUtils.getRenderTime() / 10), 0);
        GL11.glScaled(0.8, 0.8, 0.8);
        RenderUtils.renderItemUniform(tcraft.result, ClientUtils.getRenderTime());
        GL11.glPopMatrix();
    }
    GL11.glPopMatrix();
    GL11.glDisable(GL12.GL_RESCALE_NORMAL);
}

19 View Complete Implementation : RenderEnderStorage.java
Copyright MIT License
Author : Chicken-Bones
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 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
private boolean rayTraceCuboid(Vector3 start, Vector3 end, Cuboid6 cuboid) {
    s_dist = Double.MAX_VALUE;
    s_side = -1;
    for (int i = 0; i < 6; i++) traceSide(i, start, end, cuboid);
    return s_side >= 0;
}

19 View Complete Implementation : EntityWirelessTracker.java
Copyright MIT License
Author : Chicken-Bones
public void attachToEnreplacedy(Vector3 pos, Enreplacedy e) {
    attached = true;
    attachedEnreplacedy = e;
    attachedX = (float) (pos.x - e.posX);
    attachedY = (float) (pos.y + height / 2 - (e.posY - e.yOffset + e.height / 2));
    attachedZ = (float) (pos.z - e.posZ);
    attachedYaw = getEnreplacedyRotation();
    if (attachedEnreplacedy instanceof EnreplacedyPlayer)
        attachedPlayerName = attachedEnreplacedy.getCommandSenderName();
    moveToEnreplacedyExterior();
    RedstoneEtherAddons.server().updateTracker(this);
}

19 View Complete Implementation : LC.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public LC compute(Vector3 vec, int side) {
    boolean offset = false;
    switch(side) {
        case 0:
            offset = vec.y <= 0;
            break;
        case 1:
            offset = vec.y >= 1;
            break;
        case 2:
            offset = vec.z <= 0;
            break;
        case 3:
            offset = vec.z >= 1;
            break;
        case 4:
            offset = vec.x <= 0;
            break;
        case 5:
            offset = vec.x >= 1;
            break;
    }
    if (!offset)
        side += 6;
    return computeO(vec, side);
}

19 View Complete Implementation : RedstoneEther.java
Copyright MIT License
Author : Chicken-Bones
public static double pythagorasPow2(BlockCoord node, Vector3 point) {
    return (node.x - point.x) * (node.x - point.x) + (node.y - point.y) * (node.y - point.y) + (node.z - point.z) * (node.z - point.z);
}

19 View Complete Implementation : LightModel.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
/**
 * @param colour The pre-lighting vertex colour. RGBA format
 * @param normal The normal at the vertex
 * @return The lighting applied colour
 */
public int apply(int colour, Vector3 normal) {
    Vector3 n_colour = ambient.copy();
    for (int l = 0; l < lightCount; l++) {
        Light light = lights[l];
        double n_l = light.position.dotProduct(normal);
        double f = n_l > 0 ? 1 : 0;
        n_colour.x += light.ambient.x + f * light.diffuse.x * n_l;
        n_colour.y += light.ambient.y + f * light.diffuse.y * n_l;
        n_colour.z += light.ambient.z + f * light.diffuse.z * n_l;
    }
    if (n_colour.x > 1)
        n_colour.x = 1;
    if (n_colour.y > 1)
        n_colour.y = 1;
    if (n_colour.z > 1)
        n_colour.z = 1;
    n_colour.multiply((colour >>> 24) / 255D, (colour >> 16 & 0xFF) / 255D, (colour >> 8 & 0xFF) / 255D);
    return (int) (n_colour.x * 255) << 24 | (int) (n_colour.y * 255) << 16 | (int) (n_colour.z * 255) << 8 | colour & 0xFF;
}

19 View Complete Implementation : BlockTranslocator.java
Copyright MIT License
Author : Chicken-Bones
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EnreplacedyPlayer player, int side, float hitX, float hitY, float hitZ) {
    if (world.isRemote)
        return true;
    MovingObjectPosition hit = RayTracer.retraceBlock(world, player, x, y, z);
    TileTranslocator ttrans = (TileTranslocator) world.getTileEnreplacedy(x, y, z);
    if (hit != null) {
        if (hit.subHit < 6) {
            Vector3 vhit = new Vector3(hit.hitVec);
            vhit.add(-x - 0.5, -y - 0.5, -z - 0.5);
            vhit.apply(sideRotations[hit.subHit % 6].inverse());
            if (MathHelper.between(-2 / 16D, vhit.x, 2 / 16D) && MathHelper.between(-2 / 16D, vhit.z, 2 / 16D))
                hit.subHit += 6;
        }
        return ttrans.attachments[hit.subHit % 6].activate(player, hit.subHit / 6);
    }
    return false;
}

19 View Complete Implementation : EnderChestRenderer.java
Copyright MIT License
Author : Chicken-Bones
private static void drawButton(int button, int colour, int rot, double lidAngle) {
    float texx = 0.25F * (colour % 4);
    float texy = 0.25F * (colour / 4);
    GL11.glPushMatrix();
    EnderDyeButton ebutton = TileEnderChest.buttons[button].copy();
    ebutton.rotate(0, 0.5625, 0.0625, 1, 0, 0, lidAngle);
    ebutton.rotateMeta(rot);
    Vector3[] verts = ebutton.verts;
    Tessellator tessellator = Tessellator.instance;
    tessellator.startDrawingQuads();
    addVecWithUV(verts[7], texx + 0.0938, texy + 0.0625);
    addVecWithUV(verts[3], texx + 0.0938, texy + 0.1875);
    addVecWithUV(verts[2], texx + 0.1562, texy + 0.1875);
    addVecWithUV(verts[6], texx + 0.1562, texy + 0.0625);
    addVecWithUV(verts[4], texx + 0.0938, texy + 0.0313);
    addVecWithUV(verts[7], texx + 0.0938, texy + 0.0313);
    addVecWithUV(verts[6], texx + 0.1562, texy + 0.0624);
    addVecWithUV(verts[5], texx + 0.1562, texy + 0.0624);
    addVecWithUV(verts[0], texx + 0.0938, texy + 0.2186);
    addVecWithUV(verts[1], texx + 0.1562, texy + 0.2186);
    addVecWithUV(verts[2], texx + 0.1562, texy + 0.1876);
    addVecWithUV(verts[3], texx + 0.0938, texy + 0.1876);
    addVecWithUV(verts[6], texx + 0.1563, texy + 0.0626);
    addVecWithUV(verts[2], texx + 0.1563, texy + 0.1874);
    addVecWithUV(verts[1], texx + 0.1874, texy + 0.1874);
    addVecWithUV(verts[5], texx + 0.1874, texy + 0.0626);
    addVecWithUV(verts[7], texx + 0.0937, texy + 0.0626);
    addVecWithUV(verts[4], texx + 0.0626, texy + 0.0626);
    addVecWithUV(verts[0], texx + 0.0626, texy + 0.1874);
    addVecWithUV(verts[3], texx + 0.0937, texy + 0.1874);
    tessellator.draw();
    GL11.glPopMatrix();
}

19 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public void rayTraceCuboids(Vector3 start, Vector3 end, List<IndexedCuboid6> cuboids, BlockCoord pos, Block block, List<ExtendedMOP> hitList) {
    for (IndexedCuboid6 cuboid : cuboids) {
        ExtendedMOP mop = rayTraceCuboid(start, end, cuboid, pos, cuboid.data);
        if (mop != null)
            hitList.add(mop);
    }
}

19 View Complete Implementation : TileTranslocatorRenderer.java
Copyright MIT License
Author : Chicken-Bones
public static Vector3 getPath(int src, int dst, double d) {
    Vector3 v;
    if (// opposite
    (src ^ 1) == dst)
        v = sideVec[src ^ 1].copy().multiply(d);
    else {
        Vector3 vsrc = sideVec[src ^ 1];
        Vector3 vdst = sideVec[dst ^ 1];
        Vector3 a = vsrc.copy().multiply(5 / 16D);
        Vector3 b = vdst.copy().multiply(6 / 16D);
        double sind = MathHelper.sin(d * Math.PI / 2);
        double cosd = MathHelper.cos(d * Math.PI / 2);
        v = a.multiply(sind).add(b.multiply(cosd - 1)).add(vsrc.copy().multiply(3 / 16D));
    }
    return v.add(sidePos[src]);
}

19 View Complete Implementation : LC.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public LC computeO(Vector3 vec, int side) {
    Vector3 v1 = Rotation.axes[((side & 0xE) + 3) % 6];
    Vector3 v2 = Rotation.axes[((side & 0xE) + 5) % 6];
    float d1 = (float) vec.scalarProject(v1);
    float d2 = 1 - d1;
    float d3 = (float) vec.scalarProject(v2);
    float d4 = 1 - d3;
    return set(side, d2 * d4, d2 * d3, d1 * d4, d1 * d3);
}

19 View Complete Implementation : EntityWirelessTracker.java
Copyright MIT License
Author : Chicken-Bones
public Vector3 getRotatedAttachment() {
    Vector3 relPos = new Vector3(attachedX, attachedY, attachedZ);
    Quat rot = Quat.aroundAxis(0, 1, 0, (getEnreplacedyRotation() - attachedYaw) * torad);
    rot.rotate(relPos);
    return relPos;
}

19 View Complete Implementation : CCRenderState.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public static void setNormal(Vector3 n) {
    hasNormal = true;
    normal.set(n);
}

19 View Complete Implementation : EntityWirelessTracker.java
Copyright MIT License
Author : Chicken-Bones
private boolean tryAttach(Enreplacedy enreplacedy, double extraw, double extrah) {
    Vector3 evec = Vector3.fromEnreplacedyCenter(enreplacedy);
    Vector3 posVec = new Vector3(posX, posY + height / 2, posZ);
    Vector3 lastPosVec = new Vector3(lastTickPosX, lastTickPosY + height / 2, lastTickPosZ);
    Vector3 diffVec = lastPosVec.copy().subtract(posVec);
    double distanceBetweenTicks = diffVec.mag();
    double width = enreplacedy.width + extraw;
    double height = enreplacedy.height + extrah;
    for (double d = 0; d <= distanceBetweenTicks; d += 0.05) {
        Vector3 interpVec = diffVec.copy().normalize().multiply(d).add(lastPosVec);
        double xDiff = Math.abs(evec.x - interpVec.x);
        double yDiff = Math.abs(evec.y - interpVec.y);
        double zDiff = Math.abs(evec.z - interpVec.z);
        if (yDiff <= height / 2 && xDiff <= width / 2 && zDiff <= width / 2) {
            attachToEnreplacedy(interpVec, enreplacedy);
            return true;
        }
    }
    return false;
}

19 View Complete Implementation : PartFrame.java
Copyright GNU General Public License v3.0
Author : amadornes
@Override
public void renderDynamic(Vector3 pos, float frame, int preplaced) {
    renderDynamic(new Vec3d(pos.x, pos.y, pos.z), preplaced, frame);
}

19 View Complete Implementation : RenderTracker.java
Copyright MIT License
Author : Chicken-Bones
@Override
public void doRender(Enreplacedy enreplacedy, double x, double y, double z, float f, float f1) {
    GL11.glPushMatrix();
    GL11.glTranslated(x, y + 0.2, z);
    EnreplacedyWirelessTracker tracker = (EnreplacedyWirelessTracker) enreplacedy;
    if (tracker.isAttachedToEnreplacedy()) {
        Vector3 relVec = tracker.getRotatedAttachment();
        Vector3 yAxis = new Vector3(0, 1, 0);
        Vector3 axis = relVec.copy().crossProduct(yAxis);
        double angle = -(relVec.angle(yAxis) * todeg);
        // undo translation
        GL11.glTranslated(-x, -y - 0.2, -z);
        Vector3 pos = new Vector3(tracker.attachedEnreplacedy.lastTickPosX + (tracker.attachedEnreplacedy.posX - tracker.attachedEnreplacedy.lastTickPosX) * f1, tracker.attachedEnreplacedy.lastTickPosY + (tracker.attachedEnreplacedy.posY - tracker.attachedEnreplacedy.lastTickPosY) * f1 + tracker.attachedEnreplacedy.height / 2 - tracker.attachedEnreplacedy.yOffset - tracker.height, tracker.attachedEnreplacedy.lastTickPosZ + (tracker.attachedEnreplacedy.posZ - tracker.attachedEnreplacedy.lastTickPosZ) * f1);
        pos.add(relVec).add(-RenderManager.renderPosX, -RenderManager.renderPosY, -RenderManager.renderPosZ);
        GL11.glTranslated(pos.x, pos.y, pos.z);
        GL11.glRotatef((float) angle, (float) axis.x, (float) axis.y, (float) axis.z);
    } else if (tracker.item) {
        double bob = sin(ClientUtils.getRenderTime() / 10) * 0.1;
        double rotate = ClientUtils.getRenderTime() / 20 * todeg;
        GL11.glRotatef((float) rotate, 0, 1, 0);
        GL11.glTranslated(0, bob + 0.2, 0);
    }
    GL11.glTranslated(0, -0.2, 0);
    renderTracker(tracker.freq);
    GL11.glPopMatrix();
}

19 View Complete Implementation : RenderUtils.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public static void renderFluidQuad(Vector3 point1, Vector3 point2, Vector3 point3, Vector3 point4, TextureAtlreplacedprite icon, double res) {
    renderFluidQuad(point2, vectors[0].set(point4).subtract(point1), vectors[1].set(point1).subtract(point2), icon, res);
}

19 View Complete Implementation : Vertex5.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public clreplaced Vertex5 implements Copyable<Vertex5> {

    public Vector3 vec;

    public UV uv;

    public Vertex5() {
        this(new Vector3(), new UV());
    }

    public Vertex5(Vector3 vert, UV uv) {
        this.vec = vert;
        this.uv = uv;
    }

    public Vertex5(Vector3 vert, double u, double v) {
        this(vert, new UV(u, v));
    }

    public Vertex5(double x, double y, double z, double u, double v) {
        this(x, y, z, u, v, 0);
    }

    public Vertex5(double x, double y, double z, double u, double v, int tex) {
        this(new Vector3(x, y, z), new UV(u, v, tex));
    }

    public Vertex5 set(double x, double y, double z, double u, double v) {
        vec.set(x, y, z);
        uv.set(u, v);
        return this;
    }

    public Vertex5 set(double x, double y, double z, double u, double v, int tex) {
        vec.set(x, y, z);
        uv.set(u, v, tex);
        return this;
    }

    public Vertex5 set(Vertex5 vert) {
        vec.set(vert.vec);
        uv.set(vert.uv);
        return this;
    }

    public Vertex5(Vertex5 vertex5) {
        this(vertex5.vec.copy(), vertex5.uv.copy());
    }

    public Vertex5 copy() {
        return new Vertex5(this);
    }

    public String toString() {
        MathContext cont = new MathContext(4, RoundingMode.HALF_UP);
        return "Vertex: (" + new BigDecimal(vec.x, cont) + ", " + new BigDecimal(vec.y, cont) + ", " + new BigDecimal(vec.z, cont) + ") " + "(" + new BigDecimal(uv.u, cont) + ", " + new BigDecimal(uv.v, cont) + ") (" + uv.tex + ")";
    }

    public Vertex5 apply(Transformation t) {
        vec.apply(t);
        return this;
    }

    public Vertex5 apply(UVTransformation t) {
        uv.apply(t);
        return this;
    }
}

19 View Complete Implementation : PlayerChunkViewer.java
Copyright MIT License
Author : Chicken-Bones
public void handlePlayerUpdate(String username, int dimension, Vector3 position) {
    synchronized (dimensionChunks) {
        PlayerInfo info = players.get(username);
        if (info == null)
            players.put(username, info = new PlayerInfo(username));
        info.dimension = dimension;
        info.position = position;
    }
}

19 View Complete Implementation : EnderChestRenderer.java
Copyright MIT License
Author : Chicken-Bones
private static void addVecWithUV(Vector3 vec, double u, double v) {
    Tessellator.instance.addVertexWithUV(vec.x, vec.y, vec.z, u, v);
}

19 View Complete Implementation : LightModel.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public clreplaced LightModel implements CCRenderState.IVertexOperation {

    public static final int operationIndex = CCRenderState.registerOperation();

    public static clreplaced Light {

        public Vector3 ambient = new Vector3();

        public Vector3 diffuse = new Vector3();

        public Vector3 position;

        public Light(Vector3 pos) {
            position = pos.copy().normalize();
        }

        public Light setDiffuse(Vector3 vec) {
            diffuse.set(vec);
            return this;
        }

        public Light setAmbient(Vector3 vec) {
            ambient.set(vec);
            return this;
        }
    }

    public static LightModel standardLightModel;

    static {
        standardLightModel = new LightModel().setAmbient(new Vector3(0.4, 0.4, 0.4)).addLight(new Light(new Vector3(0.2, 1, -0.7)).setDiffuse(new Vector3(0.6, 0.6, 0.6))).addLight(new Light(new Vector3(-0.2, 1, 0.7)).setDiffuse(new Vector3(0.6, 0.6, 0.6)));
    }

    private Vector3 ambient = new Vector3();

    private Light[] lights = new Light[8];

    private int lightCount;

    public LightModel addLight(Light light) {
        lights[lightCount++] = light;
        return this;
    }

    public LightModel setAmbient(Vector3 vec) {
        ambient.set(vec);
        return this;
    }

    /**
     * @param colour The pre-lighting vertex colour. RGBA format
     * @param normal The normal at the vertex
     * @return The lighting applied colour
     */
    public int apply(int colour, Vector3 normal) {
        Vector3 n_colour = ambient.copy();
        for (int l = 0; l < lightCount; l++) {
            Light light = lights[l];
            double n_l = light.position.dotProduct(normal);
            double f = n_l > 0 ? 1 : 0;
            n_colour.x += light.ambient.x + f * light.diffuse.x * n_l;
            n_colour.y += light.ambient.y + f * light.diffuse.y * n_l;
            n_colour.z += light.ambient.z + f * light.diffuse.z * n_l;
        }
        if (n_colour.x > 1)
            n_colour.x = 1;
        if (n_colour.y > 1)
            n_colour.y = 1;
        if (n_colour.z > 1)
            n_colour.z = 1;
        n_colour.multiply((colour >>> 24) / 255D, (colour >> 16 & 0xFF) / 255D, (colour >> 8 & 0xFF) / 255D);
        return (int) (n_colour.x * 255) << 24 | (int) (n_colour.y * 255) << 16 | (int) (n_colour.z * 255) << 8 | colour & 0xFF;
    }

    @Override
    public boolean load() {
        if (!CCRenderState.computeLighting)
            return false;
        CCRenderState.pipeline.addDependency(CCRenderState.normalAttrib);
        CCRenderState.pipeline.addDependency(CCRenderState.colourAttrib);
        return true;
    }

    @Override
    public void operate() {
        CCRenderState.setColour(apply(CCRenderState.colour, CCRenderState.normal));
    }

    @Override
    public int operationID() {
        return operationIndex;
    }

    public PlanarLightModel reducePlanar() {
        int[] colours = new int[6];
        for (int i = 0; i < 6; i++) colours[i] = apply(-1, Rotation.axes[i]);
        return new PlanarLightModel(colours);
    }
}

19 View Complete Implementation : TileEnderTank.java
Copyright MIT License
Author : Chicken-Bones
@Override
public void addTraceableCuboids(List<IndexedCuboid6> cuboids) {
    Vector3 pos = new Vector3(xCoord, yCoord, zCoord);
    cuboids.add(new IndexedCuboid6(0, new Cuboid6(0.15, 0, 0.15, 0.85, 0.916, 0.85).add(pos)));
    for (int i = 0; i < 4; i++) cuboids.add(new IndexedCuboid6(i + 1, selectionBoxes[i].copy().apply(Rotation.quarterRotations[rotation ^ 2].at(center)).add(pos)));
}

19 View Complete Implementation : EnderDyeButton.java
Copyright MIT License
Author : Chicken-Bones
public clreplaced EnderDyeButton {

    public EnderDyeButton(int index) {
        button = index;
        verts = new Vector3[8];
        verts[0] = new Vector3(0, -0.25, -0.0625);
        verts[1] = new Vector3(0.125, -0.25, -0.0625);
        verts[2] = new Vector3(0.125, -0.25, 0);
        verts[3] = new Vector3(0, -0.25, 0);
        verts[4] = new Vector3(0, 0, -0.0625);
        verts[5] = new Vector3(0.125, 0, -0.0625);
        verts[6] = new Vector3(0.125, 0, 0);
        verts[7] = new Vector3(0, 0, 0);
        for (int i = 0; i < 8; i++) {
            verts[i].add(0.25 + 0.1875 * index, -0.375, 0.9375);
        }
        Quat quat2 = Quat.aroundAxis(1, 0, 0, -0.5 * 3.14159);
        for (int i = 0; i < 8; i++) {
            quat2.rotate(verts[i]);
        }
    }

    private EnderDyeButton() {
    }

    public void rotateMeta(int angle) {
        rotate(0.5, 0, 0.5, 0, 1, 0, angle * -0.5 * 3.14159);
    }

    /**
     * @param ax
     * @param ay
     * @param az
     * @param angle in radians
     */
    public void rotate(double px, double py, double pz, double ax, double ay, double az, double angle) {
        Quat quat = Quat.aroundAxis(ax, ay, az, angle);
        for (int i = 0; i < 8; i++) {
            verts[i].add(-px, -py, -pz);
            quat.rotate(verts[i]);
            verts[i].add(px, py, pz);
        }
    }

    public EnderDyeButton copy() {
        EnderDyeButton newbutton = new EnderDyeButton();
        newbutton.button = button;
        newbutton.verts = new Vector3[8];
        for (int i = 0; i < 8; i++) {
            newbutton.verts[i] = verts[i].copy();
        }
        return newbutton;
    }

    public void flipCoords(int ax, int ay, int az) {
        for (int i = 0; i < 8; i++) {
            verts[i].add(ax, ay, az);
        }
    }

    public int button;

    public Vector3[] verts;

    public Vector3 getMin() {
        int minindex = 0;
        double mindist = 100;
        for (int i = 0; i < 8; i++) {
            double dist = verts[i].x + verts[i].y + verts[i].z;
            if (dist < mindist) {
                mindist = dist;
                minindex = i;
            }
        }
        return verts[minindex];
    }

    public Vector3 getMax() {
        int maxindex = 0;
        double maxdist = 0;
        for (int i = 0; i < 8; i++) {
            double dist = verts[i].x + verts[i].y + verts[i].z;
            if (dist > maxdist) {
                maxdist = dist;
                maxindex = i;
            }
        }
        return verts[maxindex];
    }
}

19 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
private void traceSide(int side, Vector3 start, Vector3 end, Cuboid6 cuboid) {
    vec.set(start);
    Vector3 hit = null;
    switch(side) {
        case 0:
            hit = vec.XZintercept(end, cuboid.min.y);
            break;
        case 1:
            hit = vec.XZintercept(end, cuboid.max.y);
            break;
        case 2:
            hit = vec.XYintercept(end, cuboid.min.z);
            break;
        case 3:
            hit = vec.XYintercept(end, cuboid.max.z);
            break;
        case 4:
            hit = vec.YZintercept(end, cuboid.min.x);
            break;
        case 5:
            hit = vec.YZintercept(end, cuboid.max.x);
            break;
    }
    if (hit == null)
        return;
    switch(side) {
        case 0:
        case 1:
            if (!MathHelper.between(cuboid.min.x, hit.x, cuboid.max.x) || !MathHelper.between(cuboid.min.z, hit.z, cuboid.max.z))
                return;
            break;
        case 2:
        case 3:
            if (!MathHelper.between(cuboid.min.x, hit.x, cuboid.max.x) || !MathHelper.between(cuboid.min.y, hit.y, cuboid.max.y))
                return;
            break;
        case 4:
        case 5:
            if (!MathHelper.between(cuboid.min.y, hit.y, cuboid.max.y) || !MathHelper.between(cuboid.min.z, hit.z, cuboid.max.z))
                return;
            break;
    }
    double dist = vec2.set(hit).subtract(start).magSquared();
    if (dist < s_dist) {
        s_side = side;
        s_dist = dist;
        s_vec.set(vec);
    }
}

19 View Complete Implementation : TileCraftingGrid.java
Copyright MIT License
Author : Chicken-Bones
public void dropItems() {
    Vector3 drop = Vector3.fromTileEnreplacedyCenter(this);
    for (ItemStack item : items) if (item != null)
        InventoryUtils.dropItem(item, worldObj, drop);
}

19 View Complete Implementation : InventoryUtils.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
/**
 * Spawns an itemstack in the world at a location
 */
public static void dropItem(ItemStack stack, World world, Vector3 dropLocation) {
    EnreplacedyItem item = new EnreplacedyItem(world, dropLocation.x, dropLocation.y, dropLocation.z, stack);
    item.motionX = world.rand.nextGaussian() * 0.05;
    item.motionY = world.rand.nextGaussian() * 0.05 + 0.2F;
    item.motionZ = world.rand.nextGaussian() * 0.05;
    world.spawnEnreplacedyInWorld(item);
}

19 View Complete Implementation : TileTranslocatorRenderer.java
Copyright MIT License
Author : Chicken-Bones
private void renderLink(int src, int dst, double time, int x, int y, int z) {
    double d = ((time + src + dst * 2) % 10) / 6;
    // 0 is head
    for (int n = 0; n < 20; n++) {
        double dn = d - n * 0.1;
        int spriteX = (int) (7 - n * 1.5 - d * 2);
        if (!MathHelper.between(0, dn, 1) || spriteX < 0)
            continue;
        Vector3 pos = getPath(src, dst, dn).add(x, y, z);
        // d*0.6+0.4;
        double b = 1;
        // d*0.6+0.4;
        double s = 1;
        double u1 = spriteX / 8D;
        double u2 = u1 + 1 / 8D;
        double v1 = 0;
        double v2 = 1;
        RenderParticle.render(pos.x, pos.y, pos.z, gradient.getColour((dn - 0.5) * 1.2 + 0.5).multiplyC(b), s * 0.12, u1, v1, u2, v2);
    }
}

19 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public static Vec3 getCorrectedHeadVec(EnreplacedyPlayer player) {
    Vector3 v = Vector3.fromEnreplacedy(player);
    if (player.worldObj.isRemote) {
        // compatibility with eye height changing mods
        v.y += player.getEyeHeight() - player.getDefaultEyeHeight();
    } else {
        v.y += player.getEyeHeight();
        if (player instanceof EnreplacedyPlayerMP && player.isSneaking())
            v.y -= 0.08;
    }
    return v.vec3();
}

19 View Complete Implementation : TileTranslocatorRenderer.java
Copyright MIT License
Author : Chicken-Bones
private void drawLiquidSpiral(int src, int dst, FluidStack stack, double start, double end, double time, double theta0, double x, double y, double z) {
    IIcon tex = RenderUtils.prepareFluidRender(stack, 255);
    CCRenderState.startDrawing(7);
    Tessellator t = Tessellator.instance;
    t.setTranslation(x, y, z);
    Vector3[] last = new Vector3[] { new Vector3(), new Vector3(), new Vector3(), new Vector3() };
    Vector3[] next = new Vector3[] { new Vector3(), new Vector3(), new Vector3(), new Vector3() };
    double tess = 0.05;
    Vector3 a = getPerp(src, dst);
    boolean rev = sum(a.copy().crossProduct(getPathNormal(src, dst, 0))) != sum(sideVec[src]);
    for (double di = end; di <= start; di += tess) {
        Vector3 b = getPathNormal(src, dst, di);
        Vector3 c = getPath(src, dst, di);
        if (rev)
            b.negate();
        double r = (2 * di - time / 10 + theta0 + dst / 6) * 2 * Math.PI;
        double sz = 0.1;
        Vector3 p = c.add(a.copy().multiply(MathHelper.sin(r) * sz)).add(b.copy().multiply(MathHelper.cos(r) * sz));
        double s1 = 0.02;
        double s2 = -0.02;
        next[0].set(p).add(a.x * s1 + b.x * s1, a.y * s1 + b.y * s1, a.z * s1 + b.z * s1);
        next[1].set(p).add(a.x * s2 + b.x * s1, a.y * s2 + b.y * s1, a.z * s2 + b.z * s1);
        next[2].set(p).add(a.x * s2 + b.x * s2, a.y * s2 + b.y * s2, a.z * s2 + b.z * s2);
        next[3].set(p).add(a.x * s1 + b.x * s2, a.y * s1 + b.y * s2, a.z * s1 + b.z * s2);
        if (di > end) {
            double u1 = tex.getInterpolatedU(Math.abs(di) * 16);
            double u2 = tex.getInterpolatedU(Math.abs(di - tess) * 16);
            for (int i = 0; i < 4; i++) {
                int j = (i + 1) % 4;
                Vector3 axis = next[j].copy().subtract(next[i]);
                double v1 = tex.getInterpolatedV(Math.abs(next[i].scalarProject(axis)) * 16);
                double v2 = tex.getInterpolatedV(Math.abs(next[j].scalarProject(axis)) * 16);
                t.addVertexWithUV(next[i].x, next[i].y, next[i].z, u1, v1);
                t.addVertexWithUV(next[j].x, next[j].y, next[j].z, u1, v2);
                t.addVertexWithUV(last[j].x, last[j].y, last[j].z, u2, v2);
                t.addVertexWithUV(last[i].x, last[i].y, last[i].z, u2, v1);
            }
        }
        Vector3[] tmp = last;
        last = next;
        next = tmp;
    }
    CCRenderState.draw();
    t.setTranslation(0, 0, 0);
    RenderUtils.postFluidRender();
}

19 View Complete Implementation : PartFrame.java
Copyright GNU General Public License v3.0
Author : amadornes
@Override
public boolean renderStatic(Vector3 pos, int preplaced) {
    if (!canRenderInPreplaced(preplaced))
        return false;
    RenderHelper renderer = RenderHelper.instance;
    renderer.reset();
    renderer.setRenderCoords(getWorld(), (int) pos.x, (int) pos.y, (int) pos.z);
    boolean result = renderStatic(renderer, preplaced);
    renderer.fullReset();
    return result;
}

19 View Complete Implementation : TileTranslocatorRenderer.java
Copyright MIT License
Author : Chicken-Bones
private double sum(Vector3 v) {
    return v.x + v.y + v.z;
}

19 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public clreplaced RayTracer {

    private Vector3 vec = new Vector3();

    private Vector3 vec2 = new Vector3();

    private Vector3 s_vec = new Vector3();

    private double s_dist;

    private int s_side;

    private IndexedCuboid6 c_cuboid;

    private static ThreadLocal<RayTracer> t_inst = new ThreadLocal<RayTracer>();

    public static RayTracer instance() {
        RayTracer inst = t_inst.get();
        if (inst == null)
            t_inst.set(inst = new RayTracer());
        return inst;
    }

    private void traceSide(int side, Vector3 start, Vector3 end, Cuboid6 cuboid) {
        vec.set(start);
        Vector3 hit = null;
        switch(side) {
            case 0:
                hit = vec.XZintercept(end, cuboid.min.y);
                break;
            case 1:
                hit = vec.XZintercept(end, cuboid.max.y);
                break;
            case 2:
                hit = vec.XYintercept(end, cuboid.min.z);
                break;
            case 3:
                hit = vec.XYintercept(end, cuboid.max.z);
                break;
            case 4:
                hit = vec.YZintercept(end, cuboid.min.x);
                break;
            case 5:
                hit = vec.YZintercept(end, cuboid.max.x);
                break;
        }
        if (hit == null)
            return;
        switch(side) {
            case 0:
            case 1:
                if (!MathHelper.between(cuboid.min.x, hit.x, cuboid.max.x) || !MathHelper.between(cuboid.min.z, hit.z, cuboid.max.z))
                    return;
                break;
            case 2:
            case 3:
                if (!MathHelper.between(cuboid.min.x, hit.x, cuboid.max.x) || !MathHelper.between(cuboid.min.y, hit.y, cuboid.max.y))
                    return;
                break;
            case 4:
            case 5:
                if (!MathHelper.between(cuboid.min.y, hit.y, cuboid.max.y) || !MathHelper.between(cuboid.min.z, hit.z, cuboid.max.z))
                    return;
                break;
        }
        double dist = vec2.set(hit).subtract(start).magSquared();
        if (dist < s_dist) {
            s_side = side;
            s_dist = dist;
            s_vec.set(vec);
        }
    }

    private boolean rayTraceCuboid(Vector3 start, Vector3 end, Cuboid6 cuboid) {
        s_dist = Double.MAX_VALUE;
        s_side = -1;
        for (int i = 0; i < 6; i++) traceSide(i, start, end, cuboid);
        return s_side >= 0;
    }

    public ExtendedMOP rayTraceCuboid(Vector3 start, Vector3 end, Cuboid6 cuboid, BlockCoord pos, Object data) {
        return rayTraceCuboid(start, end, cuboid) ? new ExtendedMOP(s_vec, s_side, pos, data, s_dist) : null;
    }

    public ExtendedMOP rayTraceCuboid(Vector3 start, Vector3 end, Cuboid6 cuboid, Enreplacedy enreplacedy, Object data) {
        return rayTraceCuboid(start, end, cuboid) ? new ExtendedMOP(enreplacedy, s_vec, data, s_dist) : null;
    }

    public void rayTraceCuboids(Vector3 start, Vector3 end, List<IndexedCuboid6> cuboids, BlockCoord pos, Block block, List<ExtendedMOP> hitList) {
        for (IndexedCuboid6 cuboid : cuboids) {
            ExtendedMOP mop = rayTraceCuboid(start, end, cuboid, pos, cuboid.data);
            if (mop != null)
                hitList.add(mop);
        }
    }

    public static MovingObjectPosition retraceBlock(World world, EnreplacedyPlayer player, BlockPos pos) {
        IBlockState b = world.getBlockState(pos);
        Vec3 headVec = getCorrectedHeadVec(player);
        Vec3 lookVec = player.getLook(1.0F);
        double reach = getBlockReachDistance(player);
        Vec3 endVec = headVec.addVector(lookVec.xCoord * reach, lookVec.yCoord * reach, lookVec.zCoord * reach);
        return b.getBlock().collisionRayTrace(world, pos, headVec, endVec);
    }

    private static double getBlockReachDistance_server(EnreplacedyPlayerMP player) {
        return player.theItemInWorldManager.getBlockReachDistance();
    }

    @SideOnly(Side.CLIENT)
    private static double getBlockReachDistance_client() {
        return Minecraft.getMinecraft().playerController.getBlockReachDistance();
    }

    public static MovingObjectPosition retrace(EnreplacedyPlayer player) {
        return retrace(player, getBlockReachDistance(player));
    }

    public static MovingObjectPosition retrace(EnreplacedyPlayer player, double reach) {
        Vec3 headVec = getCorrectedHeadVec(player);
        Vec3 lookVec = player.getLook(1);
        Vec3 endVec = headVec.addVector(lookVec.xCoord * reach, lookVec.yCoord * reach, lookVec.zCoord * reach);
        return player.worldObj.rayTraceBlocks(headVec, endVec, true, false, true);
    }

    public static Vec3 getCorrectedHeadVec(EnreplacedyPlayer player) {
        Vector3 v = Vector3.fromEnreplacedy(player);
        if (player.worldObj.isRemote) {
            // compatibility with eye height changing mods
            v.y += player.getEyeHeight() - player.getDefaultEyeHeight();
        } else {
            v.y += player.getEyeHeight();
            if (player instanceof EnreplacedyPlayerMP && player.isSneaking())
                v.y -= 0.08;
        }
        return v.vec3();
    }

    public static Vec3 getStartVec(EnreplacedyPlayer player) {
        return getCorrectedHeadVec(player);
    }

    public static double getBlockReachDistance(EnreplacedyPlayer player) {
        return player.worldObj.isRemote ? getBlockReachDistance_client() : player instanceof EnreplacedyPlayerMP ? getBlockReachDistance_server((EnreplacedyPlayerMP) player) : 5D;
    }

    public static Vec3 getEndVec(EnreplacedyPlayer player) {
        Vec3 headVec = getCorrectedHeadVec(player);
        Vec3 lookVec = player.getLook(1.0F);
        double reach = getBlockReachDistance(player);
        return headVec.addVector(lookVec.xCoord * reach, lookVec.yCoord * reach, lookVec.zCoord * reach);
    }
}

19 View Complete Implementation : EntityWirelessTracker.java
Copyright MIT License
Author : Chicken-Bones
private void trackEnreplacedy() {
    Vector3 relPos = getRotatedAttachment();
    setPosition(attachedEnreplacedy.posX + relPos.x, attachedEnreplacedy.posY + attachedEnreplacedy.height / 2 - attachedEnreplacedy.yOffset + relPos.y - height, attachedEnreplacedy.posZ + relPos.z);
}

19 View Complete Implementation : LC.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public LC compute(Vector3 vec, Vector3 normal) {
    int side = CCModel.findSide(normal);
    if (side < 0)
        return set(12, 1, 0, 0, 0);
    return compute(vec, side);
}

19 View Complete Implementation : EntityWirelessTracker.java
Copyright MIT License
Author : Chicken-Bones
private void moveToEnreplacedyExterior() {
    Vector3 attachPosVec2 = getRotatedAttachment().normalize().multiply(Math.max(attachedEnreplacedy.width, attachedEnreplacedy.height));
    Vector3 diffVec = attachPosVec2.copy().negate();
    double distanceBetweenTicks = diffVec.mag();
    double width = attachedEnreplacedy.width;
    double height = attachedEnreplacedy.height;
    for (double d = 0; d <= distanceBetweenTicks; d += 0.05) {
        Vector3 interpVec = diffVec.copy().normalize().multiply(d).add(attachPosVec2);
        double xDiff = Math.abs(interpVec.x);
        double yDiff = Math.abs(interpVec.y);
        double zDiff = Math.abs(interpVec.z);
        if (yDiff <= height / 2 && xDiff <= width / 2 && zDiff <= width / 2) {
            attachedYaw = getEnreplacedyRotation();
            attachedX = (float) (interpVec.x);
            attachedY = (float) (interpVec.y);
            attachedZ = (float) (interpVec.z);
            return;
        }
    }
}

19 View Complete Implementation : CCRenderState.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
/**
 * The core of the CodeChickenLib render system.
 * Rendering operations are written to avoid object allocations by reusing static variables.
 */
public clreplaced CCRenderState {

    private static int nextOperationIndex;

    public static int registerOperation() {
        return nextOperationIndex++;
    }

    public static int operationCount() {
        return nextOperationIndex;
    }

    /**
     * Represents an operation to be run for each vertex that operates on and modifies the current state
     */
    public static interface IVertexOperation {

        /**
         * Load any required references and add dependencies to the pipeline based on the current model (may be null)
         * Return false if this operation is redundant in the pipeline with the given model
         */
        public boolean load();

        /**
         * Perform the operation on the current render state
         */
        public void operate();

        /**
         * Get the unique id representing this type of operation. Duplicate operation IDs within the pipeline may have unexpected results.
         * ID shoulld be obtained from CCRenderState.registerOperation() and stored in a static variable
         */
        public int operationID();
    }

    private static ArrayList<VertexAttribute<?>> vertexAttributes = new ArrayList<VertexAttribute<?>>();

    private static int registerVertexAttribute(VertexAttribute<?> attr) {
        vertexAttributes.add(attr);
        return vertexAttributes.size() - 1;
    }

    public static VertexAttribute<?> getAttribute(int index) {
        return vertexAttributes.get(index);
    }

    /**
     * Management clreplaced for a vertex attrute such as colour, normal etc
     * This clreplaced should handle the loading of the attrute from an array provided by IVertexSource.getAttributes or the computation of this attrute from others
     * @param <T> The array type for this attrute eg. int[], Vector3[]
     */
    public static abstract clreplaced VertexAttribute<T> implements IVertexOperation {

        public final int attributeIndex = registerVertexAttribute(this);

        private final int operationIndex = registerOperation();

        /**
         * Set to true when the attrute is part of the pipeline. Should only be managed by CCRenderState when constructing the pipeline
         */
        public boolean active = false;

        /**
         * Construct a new array for storage of vertex attrutes in a model
         */
        public abstract T newArray(int length);

        @Override
        public int operationID() {
            return operationIndex;
        }
    }

    public static void arrayCopy(Object src, int srcPos, Object dst, int destPos, int length) {
        System.arraycopy(src, srcPos, dst, destPos, length);
        if (dst instanceof Copyable[]) {
            Object[] oa = (Object[]) dst;
            Copyable<Object>[] c = (Copyable[]) dst;
            for (int i = destPos; i < destPos + length; i++) if (c[i] != null)
                oa[i] = c[i].copy();
        }
    }

    public static <T> T copyOf(VertexAttribute<T> attr, T src, int length) {
        T dst = attr.newArray(length);
        arrayCopy(src, 0, dst, 0, ((Object[]) src).length);
        return dst;
    }

    public static interface IVertexSource {

        public Vertex5[] getVertices();

        /**
         * Gets an array of vertex attrutes
         * @param attr The vertex attrute to get
         * @param <T> The attrute array type
         * @return An array, or null if not computed
         */
        public <T> T getAttributes(VertexAttribute<T> attr);

        /**
         * @return True if the specified attrute is provided by this model, either by returning an array from getAttributes or by setting the state in prepareVertex
         */
        public boolean hasAttribute(VertexAttribute<?> attr);

        /**
         * Callback to set CCRenderState for a vertex before the pipeline runs
         */
        public void prepareVertex();
    }

    public static VertexAttribute<Vector3[]> normalAttrib = new VertexAttribute<Vector3[]>() {

        private Vector3[] normalRef;

        @Override
        public Vector3[] newArray(int length) {
            return new Vector3[length];
        }

        @Override
        public boolean load() {
            normalRef = model.getAttributes(this);
            if (model.hasAttribute(this))
                return normalRef != null;
            if (model.hasAttribute(sideAttrib)) {
                pipeline.addDependency(sideAttrib);
                return true;
            }
            throw new IllegalStateException("Normals requested but neither normal or side attrutes are provided by the model");
        }

        @Override
        public void operate() {
            if (normalRef != null)
                setNormal(normalRef[vertexIndex]);
            else
                setNormal(Rotation.axes[side]);
        }
    };

    public static VertexAttribute<int[]> colourAttrib = new VertexAttribute<int[]>() {

        private int[] colourRef;

        @Override
        public int[] newArray(int length) {
            return new int[length];
        }

        @Override
        public boolean load() {
            colourRef = model.getAttributes(this);
            return colourRef != null || !model.hasAttribute(this);
        }

        @Override
        public void operate() {
            if (colourRef != null)
                setColour(ColourRGBA.multiply(baseColour, colourRef[vertexIndex]));
            else
                setColour(baseColour);
        }
    };

    public static VertexAttribute<int[]> lightingAttrib = new VertexAttribute<int[]>() {

        private int[] colourRef;

        @Override
        public int[] newArray(int length) {
            return new int[length];
        }

        @Override
        public boolean load() {
            if (!computeLighting || !useColour || !model.hasAttribute(this))
                return false;
            colourRef = model.getAttributes(this);
            if (colourRef != null) {
                pipeline.addDependency(colourAttrib);
                return true;
            }
            return false;
        }

        @Override
        public void operate() {
            setColour(ColourRGBA.multiply(colour, colourRef[vertexIndex]));
        }
    };

    public static VertexAttribute<int[]> sideAttrib = new VertexAttribute<int[]>() {

        private int[] sideRef;

        @Override
        public int[] newArray(int length) {
            return new int[length];
        }

        @Override
        public boolean load() {
            sideRef = model.getAttributes(this);
            if (model.hasAttribute(this))
                return sideRef != null;
            pipeline.addDependency(normalAttrib);
            return true;
        }

        @Override
        public void operate() {
            if (sideRef != null)
                side = sideRef[vertexIndex];
            else
                side = CCModel.findSide(normal);
        }
    };

    /**
     * Uses the position of the lightmatrix to compute LC if not provided
     */
    public static VertexAttribute<LC[]> lightCoordAttrib = new VertexAttribute<LC[]>() {

        private LC[] lcRef;

        // for computation
        private Vector3 vec = new Vector3();

        private Vector3 pos = new Vector3();

        @Override
        public LC[] newArray(int length) {
            return new LC[length];
        }

        @Override
        public boolean load() {
            lcRef = model.getAttributes(this);
            if (model.hasAttribute(this))
                return lcRef != null;
            pos.set(lightMatrix.pos.x, lightMatrix.pos.y, lightMatrix.pos.z);
            pipeline.addDependency(sideAttrib);
            pipeline.addRequirement(Transformation.operationIndex);
            return true;
        }

        @Override
        public void operate() {
            if (lcRef != null)
                lc.set(lcRef[vertexIndex]);
            else
                lc.compute(vec.set(vert.vec).sub(pos), side);
        }
    };

    // pipeline state
    public static IVertexSource model;

    public static int firstVertexIndex;

    public static int lastVertexIndex;

    public static int vertexIndex;

    public static CCRenderPipeline pipeline = new CCRenderPipeline();

    // context
    public static int baseColour;

    public static int alphaOverride;

    public static boolean useNormals;

    public static boolean computeLighting;

    public static boolean useColour;

    public static LightMatrix lightMatrix = new LightMatrix();

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

    public static boolean hasNormal;

    public static Vector3 normal = new Vector3();

    public static boolean hasColour;

    public static int colour;

    public static boolean hasBrightness;

    public static int brightness;

    // attrute storage
    public static int side;

    public static LC lc = new LC();

    public static void reset() {
        model = null;
        pipeline.reset();
        useNormals = hasNormal = hasBrightness = hasColour = false;
        useColour = computeLighting = true;
        baseColour = alphaOverride = -1;
    }

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

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

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

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

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

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

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

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

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

    public static void writeVert() {
        WorldRenderer r = Tessellator.getInstance().getWorldRenderer();
        if (hasNormal)
            r.normal((float) normal.x, (float) normal.y, (float) normal.z);
        if (hasColour)
            r.color(colour >>> 24, colour >> 16 & 0xFF, colour >> 8 & 0xFF, alphaOverride >= 0 ? alphaOverride : colour & 0xFF);
        if (hasBrightness)
            r.lightmap(brightness >> 16 & 65535, brightness & 65535);
    }

    public static void setNormal(double x, double y, double z) {
        hasNormal = true;
        normal.set(x, y, z);
    }

    public static void setNormal(Vector3 n) {
        hasNormal = true;
        normal.set(n);
    }

    public static void setColour(int c) {
        hasColour = true;
        colour = c;
    }

    public static void setBrightness(int b) {
        hasBrightness = true;
        brightness = b;
    }

    public static void setBrightness(IBlockAccess world, BlockPos pos) {
        setBrightness(world.getBlockState(pos).getBlock().getMixedBrightnessForBlock(world, pos));
    }

    public static void pullLightmap() {
        setBrightness((int) OpenGlHelper.lastBrightnessY << 16 | (int) OpenGlHelper.lastBrightnessX);
    }

    public static void pushLightmap() {
        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, brightness & 0xFFFF, brightness >>> 16);
    }

    /**
     * Compact helper for setting dynamic rendering context. Uses normals and doesn't compute lighting
     */
    public static void setDynamic() {
        useNormals = true;
        computeLighting = false;
    }

    public static void changeTexture(String texture) {
        changeTexture(new ResourceLocation(texture));
    }

    public static void changeTexture(ResourceLocation texture) {
        Minecraft.getMinecraft().renderEngine.bindTexture(texture);
    }

    public static WorldRenderer startDrawing() {
        return startDrawing(7, DefaultVertexFormats.POSITION_TEX);
    }

    public static WorldRenderer startDrawing(int mode, VertexFormat format) {
        WorldRenderer r = Tessellator.getInstance().getWorldRenderer();
        r.begin(mode, format);
        if (hasColour)
            r.color(colour >>> 24, colour >> 16 & 0xFF, colour >> 8 & 0xFF, alphaOverride >= 0 ? alphaOverride : colour & 0xFF);
        if (hasBrightness)
            r.lightmap(brightness >> 16 & 65535, brightness & 65535);
        return r;
    }

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

19 View Complete Implementation : RedstoneEtherServerAddons.java
Copyright MIT License
Author : Chicken-Bones
public void tickTriangs() {
    for (Entry<String, AddonPlayerInfo> entry : playerInfos.entrySet()) {
        EnreplacedyPlayer player = ServerUtils.getPlayer(entry.getKey());
        for (Integer freq : entry.getValue().triangSet) {
            double spinto;
            if (!RedstoneEther.server().isFreqOn(freq)) {
                spinto = -1;
            } else if (isRemoteOn(player, freq)) {
                spinto = -2;
            } else {
                Vector3 strengthvec = getBroadcastVector(player, freq);
                if (// in another dimension
                strengthvec == null) {
                    // spin to a random place
                    spinto = -2;
                } else {
                    // spin to the transmitter vec
                    spinto = (player.rotationYaw + 180) * MathHelper.torad - Math.atan2(-strengthvec.x, strengthvec.z);
                }
            }
            WRAddonSPH.sendTriangAngleTo(player, freq, (float) spinto);
        }
    }
}

19 View Complete Implementation : MicroMaterialLeaves.java
Copyright GNU Lesser General Public License v3.0
Author : AgeCraft
@SideOnly(Side.CLIENT)
public int getColourClient(Vector3 pos, int preplaced) {
    World world = EQUtilClient.getWorld();
    if (world != null && pos != null) {
        if (TreeRegistry.instance.get((meta() - (meta() & 3)) / 4).useBiomeColor) {
            int r = 0;
            int g = 0;
            int b = 0;
            for (int i = -1; i <= 1; i++) {
                for (int j = -1; j <= 1; j++) {
                    int color = world.getBiomeGenForCoords((int) pos.x + j, (int) pos.z + i).getBiomeFoliageColor((int) pos.x, (int) pos.y, (int) pos.z);
                    r += (color & 0xFF0000) >> 16;
                    g += (color & 0xFF00) >> 8;
                    b += color & 0xFF;
                }
            }
            return ((r / 9 & 0xFF) << 16 | (g / 9 & 0xFF) << 8 | b / 9 & 0xFF) << 8 | 0xFF;
        }
        return TreeRegistry.instance.get((meta() - (meta() & 3)) / 4).leafColor << 8 | 0xFF;
    } else {
        return block().getRenderColor(meta()) << 8 | 0xFF;
    }
}

19 View Complete Implementation : RedstoneEtherServerAddons.java
Copyright MIT License
Author : Chicken-Bones
public Vector3 getBroadcastVector(EnreplacedyPlayer player, int freq) {
    Vector3 vecAmplitude = new Vector3(0, 0, 0);
    Vector3 vecPlayer = new Vector3(player.posX, 0, player.posZ);
    for (Iterator<FreqCoord> iterator = RedstoneEther.server().getActiveTransmittersOnFreq(freq, player.dimension).iterator(); iterator.hasNext(); ) {
        FreqCoord node = iterator.next();
        Vector3 vecTransmitter = new Vector3(node.x + 0.5, 0, node.z + 0.5);
        double distancePow2 = vecTransmitter.subtract(vecPlayer).magSquared();
        vecAmplitude.add(vecTransmitter.multiply(1 / distancePow2));
    }
    for (Iterator<WirelessTransmittingDevice> iterator = RedstoneEther.server().getTransmittingDevicesOnFreq(freq).iterator(); iterator.hasNext(); ) {
        WirelessTransmittingDevice device = iterator.next();
        if (device.getAttachedEnreplacedy() == player)
            return null;
        if (device.getDimension() != player.dimension)
            continue;
        Vector3 vecTransmitter = device.getPosition();
        vecTransmitter.y = 0;
        double distancePow2 = vecTransmitter.subtract(vecPlayer).magSquared();
        vecAmplitude.add(vecTransmitter.multiply(1 / distancePow2));
    }
    if (vecAmplitude.isZero())
        return null;
    return vecAmplitude;
}

19 View Complete Implementation : EntityDigIconFX.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public static void addBlockHitEffects(World world, Cuboid6 bounds, int side, TextureAtlreplacedprite icon, EffectRenderer effectRenderer) {
    float border = 0.1F;
    Vector3 diff = bounds.max.copy().subtract(bounds.min).add(-2 * border);
    diff.x *= world.rand.nextDouble();
    diff.y *= world.rand.nextDouble();
    diff.z *= world.rand.nextDouble();
    Vector3 pos = diff.add(bounds.min).add(border);
    if (side == 0)
        diff.y = bounds.min.y - border;
    if (side == 1)
        diff.y = bounds.max.y + border;
    if (side == 2)
        diff.z = bounds.min.z - border;
    if (side == 3)
        diff.z = bounds.max.z + border;
    if (side == 4)
        diff.x = bounds.min.x - border;
    if (side == 5)
        diff.x = bounds.max.x + border;
    effectRenderer.addEffect(new EnreplacedyDigIconFX(world, pos.x, pos.y, pos.z, 0, 0, 0, icon).multiplyVelocity(0.2F).multipleParticleScaleBy(0.6F));
}

19 View Complete Implementation : LightModel.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public LightModel setAmbient(Vector3 vec) {
    ambient.set(vec);
    return this;
}

19 View Complete Implementation : MicroMaterialColorOverlay.java
Copyright GNU Lesser General Public License v3.0
Author : AgeCraft
@Override
public void renderMicroFace(Vector3 pos, int preplaced, Cuboid6 bounds) {
    MaterialRenderHelper.start(pos, preplaced, icont()).blockColour(getColour(preplaced)).lighting().render();
    if (hasOverlay) {
        MaterialRenderHelper.start(pos, preplaced, overlayIconTransformation).blockColour(0xFFFFFF).lighting().render();
    }
}

19 View Complete Implementation : MicroMaterialLeaves.java
Copyright GNU Lesser General Public License v3.0
Author : AgeCraft
@Override
public void renderMicroFace(Vector3 pos, int preplaced, Cuboid6 bounds) {
    int colour = getColour(preplaced);
    if (FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) {
        colour = getColourClient(pos, preplaced);
    }
    MaterialRenderHelper.start(pos, preplaced, icont()).blockColour(colour).lighting().render();
}

19 View Complete Implementation : PlayerChunkViewerTracker.java
Copyright MIT License
Author : Chicken-Bones
public void updatePlayer(EnreplacedyPlayer player) {
    PacketCustom packet = new PacketCustom(channel, 6);
    packet.writeString(player.getCommandSenderName());
    packet.writeInt(player.dimension);
    Vector3 pos = Vector3.fromEnreplacedy(player);
    packet.writeFloat((float) pos.x);
    packet.writeFloat((float) pos.y);
    packet.writeFloat((float) pos.z);
    packet.sendToPlayer(owner);
}

19 View Complete Implementation : RayTracer.java
Copyright GNU Lesser General Public License v2.1
Author : Chicken-Bones
public ExtendedMOP rayTraceCuboid(Vector3 start, Vector3 end, Cuboid6 cuboid, BlockCoord pos, Object data) {
    return rayTraceCuboid(start, end, cuboid) ? new ExtendedMOP(s_vec, s_side, pos, data, s_dist) : null;
}

19 View Complete Implementation : EnderKnobSlot.java
Copyright MIT License
Author : Chicken-Bones
public static AxisAlignedBB cornersToAABB(Vector3[] corners) {
    Vector3 min = corners[0].copy();
    Vector3 max = corners[0].copy();
    for (int i = 1; i < corners.length; i++) {
        Vector3 vec = corners[i];
        if (vec.x < min.x)
            min.x = vec.x;
        else if (vec.x > max.x)
            max.x = vec.x;
        if (vec.y < min.y)
            min.y = vec.y;
        else if (vec.y > max.y)
            max.y = vec.y;
        if (vec.z < min.z)
            min.z = vec.z;
        else if (vec.z > max.z)
            max.z = vec.z;
    }
    return AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
}