codechicken.lib.render.pipeline.IVertexOperation - java examples

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

68 Examples 7

19 View Complete Implementation : PipelineUtil.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public static IVertexOperation[] color(IVertexOperation[] ops, int rgbColor) {
    return ArrayUtils.add(ops, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(rgbColor)));
}

19 View Complete Implementation : InvPipeRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderPipe(CCRenderState renderState, IVertexOperation[] pipeline, int insulationColor, int connectMask) {
}

18 View Complete Implementation : CoverItemFilter.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    this.texture.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

18 View Complete Implementation : MetaTileEntityMagicEnergyAbsorber.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
@SideOnly(Side.CLIENT)
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    IVertexOperation[] colouredPipeline = ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering())));
    getRenderer().render(renderState, translation, colouredPipeline);
}

18 View Complete Implementation : MetaTileEntityTransformer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    if (isTransformUp) {
        Textures.ENERGY_OUT_MULTI.renderSided(getFrontFacing(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier() - 1]));
        Textures.ENERGY_IN.renderSided(getFrontFacing().getOpposite(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier()]));
    } else {
        Textures.ENERGY_IN_MULTI.renderSided(getFrontFacing(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier()]));
        Textures.ENERGY_OUT.renderSided(getFrontFacing().getOpposite(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier() - 1]));
    }
}

18 View Complete Implementation : MetaTileEntityBatteryBuffer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.ENERGY_OUT.renderSided(getFrontFacing(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier()]));
}

18 View Complete Implementation : CableRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
private static void renderCableCube(int connections, CCRenderState renderState, IVertexOperation[] pipeline, IVertexOperation[] wire, IVertexOperation[] overlays, EnumFacing side, float thickness) {
    if ((connections & 1 << side.getIndex()) > 0) {
        boolean renderFrontSide = (connections & 1 << (6 + side.getIndex())) > 0;
        Cuboid6 cuboid6 = BlockCable.getSideBox(side, thickness);
        for (EnumFacing renderedSide : EnumFacing.VALUES) {
            if (renderedSide == side) {
                if (renderFrontSide) {
                    renderCableSide(renderState, wire, renderedSide, cuboid6);
                    renderCableSide(renderState, overlays, renderedSide, cuboid6);
                }
            } else if (renderedSide != side.getOpposite()) {
                renderCableSide(renderState, pipeline, renderedSide, cuboid6);
            }
        }
    }
}

18 View Complete Implementation : CoverPump.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.PUMP_OVERLAY.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

18 View Complete Implementation : MetaTileEntityBlockBreaker.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.ROCK_CRUSHER_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
    Textures.PIPE_OUT_OVERLAY.renderSided(getOutputFacing(), renderState, translation, pipeline);
}

18 View Complete Implementation : MetaTileEntityFluidHatch.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    if (shouldRenderOverlay()) {
        SimpleOverlayRenderer renderer = isExportHatch ? Textures.PIPE_OUT_OVERLAY : Textures.PIPE_IN_OVERLAY;
        renderer.renderSided(getFrontFacing(), renderState, translation, pipeline);
    }
}

18 View Complete Implementation : MetaTileEntityCokeOven.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.COKE_OVEN_OVERLAY.render(renderState, translation, pipeline, getFrontFacing(), isActive());
}

18 View Complete Implementation : CoverRoboticArm.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.ARM_OVERLAY.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

18 View Complete Implementation : MetaTileEntityLargeBoiler.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.MULTIBLOCK_WORKABLE_OVERLAY.render(renderState, translation, pipeline, getFrontFacing(), isActive);
}

18 View Complete Implementation : MetaTileEntityItemCollector.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    SimpleOverlayRenderer renderer = isWorking ? Textures.BLOWER_ACTIVE_OVERLAY : Textures.BLOWER_OVERLAY;
    renderer.renderSided(EnumFacing.UP, renderState, translation, pipeline);
    Textures.AIR_VENT_OVERLAY.renderSided(EnumFacing.DOWN, renderState, translation, pipeline);
    Textures.PIPE_OUT_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
}

18 View Complete Implementation : SimpleGeneratorMetaTileEntity.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    this.overlayRenderer.render(renderState, translation, pipeline, getFrontFacing(), workableHandler.isActive());
    Textures.ENERGY_OUT.renderSided(getFrontFacing(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier()]));
}

18 View Complete Implementation : MetaTileEntityChest.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
}

17 View Complete Implementation : MetaTileEntityMultiblockPart.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    getBaseTexture().render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering()))));
}

17 View Complete Implementation : CoverBehavior.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@SideOnly(Side.CLIENT)
public void renderCoverPlate(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    TextureAtlreplacedprite casingSide = getPlateSprite();
    for (EnumFacing coverPlateSide : EnumFacing.VALUES) {
        boolean isAttachedSide = attachedSide.getAxis() == coverPlateSide.getAxis();
        if (isAttachedSide) {
            Textures.renderFace(renderState, translation, pipeline, coverPlateSide, plateBox, casingSide);
        } else if (coverHolder.getCoverAtSide(coverPlateSide) == null) {
            Textures.renderFace(renderState, translation, pipeline, coverPlateSide, plateBox, casingSide);
        }
    }
}

17 View Complete Implementation : MetaTileEntityCokeOvenHatch.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.HATCH_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
}

17 View Complete Implementation : MetaTileEntityQuantumChest.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    Textures.VOLTAGE_CASINGS[tier].render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering()))));
    translation.translate(0.5, 0.001, 0.5);
    translation.rotate(Math.toRadians(rotations[getFrontFacing().getIndex() - 2]), new Vector3(0.0, 1.0, 0.0));
    translation.translate(-0.5, 0.0, -0.5);
    Textures.SCREEN.renderSided(EnumFacing.UP, renderState, translation, pipeline);
}

17 View Complete Implementation : MetaTileEntityTank.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    int baseColor = GTUtility.convertRGBtoOpaqueRGBA_CL(getActualPaintingColor());
    getTankRenderer().render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(baseColor)), connectionMask);
}

17 View Complete Implementation : SimpleMachineMetaTileEntity.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
@SideOnly(Side.CLIENT)
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    if (outputFacing != null) {
        Textures.PIPE_OUT_OVERLAY.renderSided(outputFacing, renderState, translation, pipeline);
        if (autoOutpureplacedems) {
            Textures.ITEM_OUTPUT_OVERLAY.renderSided(outputFacing, renderState, translation, pipeline);
        }
        if (autoOutputFluids) {
            Textures.FLUID_OUTPUT_OVERLAY.renderSided(outputFacing, renderState, translation, pipeline);
        }
    }
}

17 View Complete Implementation : MetaTileEntityWorkbench.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    int paintingColor = getResultRenderingColor();
    pipeline = ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(paintingColor)));
    Textures.CRAFTING_TABLE.render(renderState, translation, pipeline, Cuboid6.full);
}

17 View Complete Implementation : ChestRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, EnumFacing rotation, float capRotation) {
    translation.translate(0.5, 0.5, 0.5);
    translation.rotate(Math.toRadians(90.0 * rotations.indexOf(rotation)), Rotation.axes[1]);
    translation.translate(-0.5, -0.5, -0.5);
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        TextureAtlreplacedprite baseSprite = renderSide.getAxis() == Axis.Y ? textures[renderSide.getIndex()] : renderSide == EnumFacing.NORTH ? textures[3] : textures[2];
        Textures.renderFace(renderState, translation, pipeline, renderSide, mainBox, baseSprite);
    }
    translation.translate(0.5, 9 / 16.0, 15 / 16.0);
    translation.rotate(Math.toRadians(capRotation), Rotation.axes[5]);
    translation.translate(-0.5, -9 / 16.0, -15 / 16.0);
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        TextureAtlreplacedprite capSprite = renderSide.getAxis() == Axis.Y ? textures[4 + renderSide.getIndex()] : renderSide == EnumFacing.NORTH ? textures[3] : textures[2];
        TextureAtlreplacedprite lockSprite = textures[6];
        Textures.renderFace(renderState, translation, pipeline, renderSide, capBox, capSprite);
        Textures.renderFace(renderState, translation, pipeline, renderSide, lockBox, lockSprite);
    }
}

17 View Complete Implementation : SafeRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, EnumFacing rotation, float capRotation) {
    translation.translate(0.5, 0.5, 0.5);
    translation.rotate(Math.toRadians(90.0 * rotations.indexOf(rotation)), Rotation.axes[1]);
    translation.translate(-0.5, -0.5, -0.5);
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        TextureAtlreplacedprite baseSprite = renderSide.getAxis() == Axis.Y ? textures[renderSide.getIndex()] : renderSide == EnumFacing.NORTH ? textures[3] : textures[2];
        Textures.renderFace(renderState, translation, pipeline, renderSide, mainBoxOuter, baseSprite);
        if (renderSide == EnumFacing.NORTH)
            continue;
        Textures.renderFace(renderState, translation, pipeline, renderSide, mainBoxInner, baseSprite);
    }
    translation.translate(4 / 16.0, 7 / 16.0, 3 / 16.0);
    translation.rotate(Math.toRadians(capRotation), Rotation.axes[1]);
    translation.translate(-4 / 16.0, -7 / 16.0, -3 / 16.0);
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        TextureAtlreplacedprite doorSprite = renderSide == EnumFacing.NORTH ? textures[6] : renderSide == EnumFacing.SOUTH ? textures[5] : textures[4];
        Textures.renderFace(renderState, translation, pipeline, renderSide, doorBox, doorSprite);
    }
}

17 View Complete Implementation : SimpleOverlayRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderSided(EnumFacing side, Cuboid6 bounds, CCRenderState renderState, IVertexOperation[] pipeline, Matrix4 translation) {
    Textures.renderFace(renderState, translation, pipeline, side, bounds, sprite);
}

17 View Complete Implementation : SimpleSidedCubeRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
@SideOnly(Side.CLIENT)
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 bounds) {
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        RenderSide overlayFace = RenderSide.bySide(renderSide);
        TextureAtlreplacedprite renderSprite = sprites.get(overlayFace);
        Textures.renderFace(renderState, translation, pipeline, renderSide, bounds, renderSprite);
    }
}

17 View Complete Implementation : MetaTileEntityEnergyHatch.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    if (shouldRenderOverlay()) {
        SimpleOverlayRenderer renderer = isExportHatch ? Textures.ENERGY_OUT_MULTI : Textures.ENERGY_IN_MULTI;
        renderer.renderSided(getFrontFacing(), renderState, translation, PipelineUtil.color(pipeline, GTValues.VC[getTier()]));
    }
}

17 View Complete Implementation : MetaTileEntityRotorHolder.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.ROTOR_HOLDER_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
    Textures.LARGE_TURBINE_ROTOR_RENDERER.renderSided(renderState, translation, pipeline, getFrontFacing(), getController() != null, isHasRotor(), isRotorLooping(), rotorColor);
}

17 View Complete Implementation : CoverConveyor.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.CONVEYOR_OVERLAY.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

17 View Complete Implementation : CoverFacade.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCoverPlate(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
}

17 View Complete Implementation : SteamBoiler.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    IVertexOperation[] colouredPipeline = ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering())));
    getBaseRenderer().render(renderState, translation, colouredPipeline);
    renderer.render(renderState, translation, pipeline, getFrontFacing(), isBurning());
}

17 View Complete Implementation : MultiblockControllerBase.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    getBaseTexture(null).render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering()))));
}

17 View Complete Implementation : CoverFluidFilter.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    this.texture.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

17 View Complete Implementation : CoverMachineController.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.MACHINE_CONTROLLER_OVERLAY.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

17 View Complete Implementation : CableRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
private static void renderCableSide(CCRenderState renderState, IVertexOperation[] pipeline, EnumFacing side, Cuboid6 cuboid6) {
    BlockFace blockFace = blockFaces.get();
    blockFace.loadCuboidFace(cuboid6, side.getIndex());
    renderState.setPipeline(blockFace, 0, blockFace.verts.length, pipeline);
    renderState.render();
}

17 View Complete Implementation : CoverSolarPanel.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.SOLAR_PANEL.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

17 View Complete Implementation : MetaTileEntityAirCollector.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    EnumFacing frontFacing = getFrontFacing();
    for (EnumFacing side : EnumFacing.VALUES) {
        if (side.getAxis().isHorizontal()) {
            Textures.AIR_VENT_OVERLAY.renderSided(side, renderState, translation, pipeline);
        } else {
            Textures.FILTER_OVERLAY.renderSided(side, renderState, translation, pipeline);
        }
    }
    Textures.PIPE_OUT_OVERLAY.renderSided(frontFacing, renderState, translation, pipeline);
}

17 View Complete Implementation : MetaTileEntityFisher.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.SCREEN.renderSided(EnumFacing.UP, renderState, translation, pipeline);
    Textures.PIPE_OUT_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
    Textures.PIPE_IN_OVERLAY.renderSided(EnumFacing.DOWN, renderState, translation, pipeline);
}

17 View Complete Implementation : MetaTileEntityTeslaCoil.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
@SideOnly(Side.CLIENT)
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    Textures.TESLA_COIL.render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering()))));
}

16 View Complete Implementation : TieredMetaTileEntity.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    IVertexOperation[] colouredPipeline = ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering())));
    getBaseRenderer().render(renderState, translation, colouredPipeline);
}

16 View Complete Implementation : WorkableTieredMetaTileEntity.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    renderer.render(renderState, translation, pipeline, getFrontFacing(), workable.isActive());
}

16 View Complete Implementation : LargeTurbineRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderSided(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, EnumFacing side, boolean hasBase, boolean hasRotor, boolean isActive, int rotorRGB) {
    Matrix4 cornerOffset = null;
    switch(side.getAxis()) {
        case X:
            cornerOffset = translation.copy().translate(0.01 * side.getFrontOffsetX(), -1.0, -1.0);
            cornerOffset.scale(1.0, 3.0, 3.0);
            break;
        case Z:
            cornerOffset = translation.copy().translate(-1.0, -1.0, 0.01 * side.getFrontOffsetZ());
            cornerOffset.scale(3.0, 3.0, 1.0);
            break;
        case Y:
            cornerOffset = translation.copy().translate(-1.0, 0.01 * side.getFrontOffsetY(), -1.0);
            cornerOffset.scale(3.0, 1.0, 3.0);
            break;
    }
    if (hasBase) {
        Textures.renderFace(renderState, cornerOffset, pipeline, side, Cuboid6.full, baseRingSprite);
        renderState.brightness = 0xF000F0;
        renderState.colour = 0xFFFFFFFF;
        Textures.renderFace(renderState, cornerOffset, new IVertexOperation[0], side, Cuboid6.full, baseBackgroundSprite);
    }
    if (hasRotor) {
        TextureAtlreplacedprite sprite = isActive ? activeBladeSprite : idleBladeSprite;
        IVertexOperation[] color = ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(rotorRGB)));
        Textures.renderFace(renderState, cornerOffset, color, side, Cuboid6.full, sprite);
    }
}

16 View Complete Implementation : OrientedOverlayRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, EnumFacing frontFacing, boolean isActive) {
    render(renderState, translation, pipeline, Cuboid6.full, frontFacing, isActive);
}

16 View Complete Implementation : OrientedOverlayRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] ops, Cuboid6 bounds, EnumFacing frontFacing, boolean isActive) {
    for (EnumFacing renderSide : EnumFacing.VALUES) {
        OverlayFace overlayFace = OverlayFace.bySide(renderSide, frontFacing);
        if (sprites.containsKey(overlayFace)) {
            TextureAtlreplacedprite renderSprite = sprites.get(overlayFace).getSprite(isActive);
            Textures.renderFace(renderState, translation, ops, renderSide, bounds, renderSprite);
        }
    }
}

16 View Complete Implementation : SimpleCubeRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@SideOnly(Side.CLIENT)
public void renderSided(EnumFacing side, Matrix4 translation, Cuboid6 bounds, CCRenderState renderState, IVertexOperation[] pipeline) {
    Textures.renderFace(renderState, translation, pipeline, side, bounds, sprite);
}

16 View Complete Implementation : SimpleOverlayRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderSided(EnumFacing side, CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    renderSided(side, Cuboid6.full, renderState, pipeline, translation);
}

16 View Complete Implementation : TankRenderer.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
public void renderFluid(CCRenderState renderState, Matrix4 translation, int connectionMask, double fillPercent, FluidStack fluidStack) {
    if (fluidStack != null) {
        double fluidLevelOffset = (offset(EnumFacing.UP, connectionMask) + offset(EnumFacing.DOWN, connectionMask));
        double fluidLevel = fillPercent * (1.0 - fluidLevelOffset);
        Cuboid6 fluidCuboid = new Cuboid6(offset(EnumFacing.WEST, connectionMask), 0.0, offset(EnumFacing.NORTH, connectionMask), 1.0 - offset(EnumFacing.EAST, connectionMask), 1.0, 1.0 - offset(EnumFacing.SOUTH, connectionMask));
        if (fluidStack.getFluid().isGaseous(fluidStack)) {
            double maxHeight = offset(EnumFacing.UP, connectionMask);
            fluidCuboid.min.y = 1.0 - maxHeight - fluidLevel;
            fluidCuboid.max.y = maxHeight;
        } else {
            double minHeight = offset(EnumFacing.DOWN, connectionMask);
            fluidCuboid.min.y = minHeight;
            fluidCuboid.max.y = minHeight + fluidLevel;
        }
        ColourMultiplier multiplier = new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(fluidStack.getFluid().getColor(fluidStack)));
        IVertexOperation[] fluidPipeline = new IVertexOperation[] { multiplier };
        TextureAtlreplacedprite fluidSprite = TextureUtils.getTexture(fluidStack.getFluid().getStill(fluidStack));
        for (EnumFacing renderSide : EnumFacing.VALUES) {
            if (hasFaceBit(connectionMask, renderSide))
                continue;
            Textures.renderFace(renderState, translation, fluidPipeline, renderSide, fluidCuboid, fluidSprite);
        }
    }
}

16 View Complete Implementation : Textures.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@SideOnly(Side.CLIENT)
public static void renderFace(CCRenderState renderState, Matrix4 translation, IVertexOperation[] ops, EnumFacing face, Cuboid6 bounds, TextureAtlreplacedprite sprite) {
    BlockFace blockFace = blockFaces.get();
    blockFace.loadCuboidFace(bounds, face.getIndex());
    renderState.setPipeline(blockFace, 0, blockFace.verts.length, ArrayUtils.addAll(ops, new TransformationList(translation), new IconTransformation(sprite)));
    renderState.render();
}

16 View Complete Implementation : CoverFacade.java
Copyright GNU Lesser General Public License v3.0
Author : GregTechCE
@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    BlockRenderLayer oldLayer = MinecraftForgeClient.getRenderLayer();
    ForgeHooksClient.setRenderLayer(layer);
    FacadeRenderer.renderBlockCover(renderState, translation, coverHolder.getWorld(), coverHolder.getPos(), attachedSide.getIndex(), facadeState, plateBox);
    ForgeHooksClient.setRenderLayer(oldLayer);
}