codechicken.lib.render.CCRenderState

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

166 Examples 7

19 Source : EnderTankItemRender.java
with MIT License
from TheCBProject

@Override
public void renderItem(ItemStack stack, TransformType transformType, MatrixStack mStack, IRenderTypeBuffer getter, int packedLight, int packedOverlay) {
    CCRenderState ccrs = CCRenderState.instance();
    ccrs.reset();
    ccrs.brightness = packedLight;
    ccrs.overlay = packedOverlay;
    Frequency freq = Frequency.readFromStack(stack);
    FluidStack fluid = TankSynchroniser.getClientLiquid(freq);
    Matrix4 mat = new Matrix4(mStack);
    RenderTileEnderTank.renderTank(ccrs, mat, getter, 2, (float) (MathHelper.torad * 90F), 0, freq, 0);
    mat.translate(-0.5, 0, -0.5);
    RenderTileEnderTank.renderFluid(ccrs, mat, getter, fluid);
}

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

@Override
public boolean load(CCRenderState ccrs) {
    return !isRedundant();
}

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

@Override
public void operate(CCRenderState ccrs) {
    apply(ccrs.vert.uv);
    ccrs.sprite = null;
}

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

@Override
public void operate(CCRenderState ccrs) {
    super.operate(ccrs);
    ccrs.sprite = icon;
}

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

@Override
public void operate(CCRenderState ccrs) {
    UV uv = ccrs.vert.uv;
    int index = ccrs.vertexIndex;
    TextureAtlreplacedprite sprite = getSpriteForVertexIndex(index);
    if (sprite == null) {
        return;
    }
    uv.u = sprite.getInterpolatedU(uv.u * 16);
    uv.v = sprite.getInterpolatedV(uv.v * 16);
    ccrs.sprite = getSpriteForVertexIndex(ccrs.vertexIndex);
}

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

@Override
public boolean load(CCRenderState ccrs) {
    ccrs.pipeline.addRequirement(ccrs.normalAttrib.operationID());
    return !isRedundant();
}

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

@Override
public void operate(CCRenderState ccrs) {
    apply(ccrs.vert.vec);
    if (ccrs.normalAttrib.active) {
        applyN(ccrs.normal);
    }
}

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

@Override
public void operate(CCRenderState ccrs) {
    ccrs.colour = ColourRGBA.multiply(ccrs.colour, colour);
}

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

@Override
public boolean load(CCRenderState ccrs) {
    if (colour == -1) {
        return false;
    }
    ccrs.pipeline.addDependency(ccrs.colourAttrib);
    return true;
}

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

@SuppressWarnings("ForLoopReplaceableByForEach")
public clreplaced CCRenderPipeline {

    private final CCRenderState renderState;

    @Deprecated
    private final PipelineBuilder builder;

    // Hack removed.
    @Deprecated
    public boolean forceFormatAttributes = true;

    private final List<VertexAttribute<?>> attribs = new ArrayList<>();

    private final List<IVertexOperation> ops = new ArrayList<>();

    private final List<PipelineNode> nodes = new ArrayList<>();

    private final List<IVertexOperation> sorted = new ArrayList<>();

    private PipelineNode loading;

    public CCRenderPipeline(CCRenderState renderState) {
        this.renderState = renderState;
        builder = new PipelineBuilder(renderState);
    }

    public void setPipeline(IVertexOperation... ops) {
        this.ops.clear();
        Collections.addAll(this.ops, ops);
        rebuild();
    }

    public void reset() {
        ops.clear();
        unbuild();
    }

    private void unbuild() {
        for (int i = 0; i < attribs.size(); i++) {
            VertexAttribute<?> attrib = attribs.get(i);
            attrib.active = false;
        }
        attribs.clear();
        sorted.clear();
    }

    public void rebuild() {
        if (renderState.model == null || renderState.fmt == null)
            return;
        unbuild();
        if (renderState.cFmt.hasNormal) {
            addAttribute(renderState.normalAttrib);
        }
        if (renderState.cFmt.hasColor) {
            addAttribute(renderState.colourAttrib);
        }
        if (renderState.computeLighting) {
            addAttribute(renderState.lightingAttrib);
        }
        if (ops.isEmpty()) {
            return;
        }
        // ensure enough nodes for all ops
        while (nodes.size() < IVertexOperation.operationCount()) {
            nodes.add(new PipelineNode());
        }
        // addDependency adds things to this.
        // noinspection ForLoopReplaceableByForEach
        for (int i = 0; i < ops.size(); i++) {
            IVertexOperation op = ops.get(i);
            loading = nodes.get(op.operationID());
            boolean loaded = op.load(renderState);
            if (loaded) {
                loading.op = op;
            }
            if (op instanceof VertexAttribute) {
                if (loaded) {
                    attribs.add((VertexAttribute<?>) op);
                } else {
                    ((VertexAttribute<?>) op).active = false;
                }
            }
        }
        for (int i = 0; i < nodes.size(); i++) {
            PipelineNode node = nodes.get(i);
            node.add();
        }
    }

    public void addRequirement(int opRef) {
        loading.deps.add(nodes.get(opRef));
    }

    public void addDependency(VertexAttribute<?> attrib) {
        loading.deps.add(nodes.get(attrib.operationID()));
        addAttribute(attrib);
    }

    public void addAttribute(VertexAttribute<?> attrib) {
        if (!attrib.active) {
            ops.add(attrib);
            attrib.active = true;
        }
    }

    public void operate() {
        for (int i = 0; i < sorted.size(); i++) {
            IVertexOperation aSorted = sorted.get(i);
            aSorted.operate(renderState);
        }
    }

    @Deprecated
    public PipelineBuilder builder() {
        ops.clear();
        return builder;
    }

    @Deprecated
    public clreplaced PipelineBuilder {

        private final CCRenderState renderState;

        public PipelineBuilder(CCRenderState renderState) {
            this.renderState = renderState;
        }

        public PipelineBuilder add(IVertexOperation op) {
            ops.add(op);
            return this;
        }

        public PipelineBuilder add(IVertexOperation... ops) {
            Collections.addAll(CCRenderPipeline.this.ops, ops);
            return this;
        }

        public void build() {
            rebuild();
        }

        public void render() {
            rebuild();
            renderState.render();
        }
    }

    private clreplaced PipelineNode {

        public ArrayList<PipelineNode> deps = new ArrayList<>();

        public IVertexOperation op;

        public void add() {
            if (op == null) {
                return;
            }
            for (int i = 0; i < deps.size(); i++) {
                PipelineNode dep = deps.get(i);
                dep.add();
            }
            deps.clear();
            sorted.add(op);
            op = null;
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

@Override
public boolean load(CCRenderState ccrs) {
    if (!ccrs.computeLighting || !ccrs.cFmt.hasColor || !ccrs.model.hasAttribute(attributeKey)) {
        return false;
    }
    colourRef = ccrs.model.getAttributes(attributeKey);
    if (colourRef != null) {
        ccrs.pipeline.addDependency(ccrs.colourAttrib);
        return true;
    }
    return false;
}

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

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

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

@Override
public boolean load(CCRenderState ccrs) {
    lcRef = ccrs.model.getAttributes(attributeKey);
    if (ccrs.model.hasAttribute(attributeKey)) {
        return lcRef != null;
    }
    pos.set(ccrs.lightMatrix.pos);
    ccrs.pipeline.addDependency(ccrs.sideAttrib);
    ccrs.pipeline.addRequirement(Transformation.operationIndex);
    return true;
}

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

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

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

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

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

@Override
public void operate(CCRenderState ccrs) {
    ccrs.brightness = sample(ccrs.side);
}

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

@Override
public boolean load(CCRenderState ccrs) {
    ccrs.pipeline.addDependency(ccrs.sideAttrib);
    return true;
}

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

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

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

@Override
public void operate(CCRenderState ccrs) {
    ccrs.colour = ColourRGBA.multiply(ccrs.colour, colours[ccrs.side]);
}

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

@Override
public void operate(CCRenderState ccrs) {
    super.operate(ccrs);
    ccrs.brightness = brightness(ccrs.side);
}

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

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

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

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

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

@Override
public void operate(CCRenderState ccrs) {
    LC lc = ccrs.lc;
    float[] a = ao(lc.side);
    float f = (a[0] * lc.fa + a[1] * lc.fb + a[2] * lc.fc + a[3] * lc.fd);
    int[] b = brightness(lc.side);
    ccrs.colour = ColourRGBA.multiplyC(ccrs.colour, f);
    // System.out.println("0x808080FF * " + f + " = 0x" + Integer.toHexString(state.colour));
    ccrs.brightness = (int) (b[0] * lc.fa + b[1] * lc.fb + b[2] * lc.fc + b[3] * lc.fd) & 0xFF00FF;
}

19 Source : ChunkLoaderItemModel.java
with MIT License
from TheCBProject

@Override
public void renderItem(ItemStack stack, TransformType transformType, MatrixStack mStack, IRenderTypeBuffer getter, int packedLight, int packedOverlay) {
    renderWrapped(stack, transformType, mStack, getter, packedLight, packedOverlay, false);
    double rot = ClientUtils.getRenderTime() / 6F;
    double height;
    double size;
    if (!spotLoader) {
        height = 0.9;
        size = 0.08;
    } else {
        height = 0.55;
        size = 0.05;
    }
    CCRenderState ccrs = CCRenderState.instance();
    ccrs.brightness = packedLight;
    ccrs.overlay = packedOverlay;
    ccrs.reset();
    Matrix4 pearlMat = RenderUtils.getMatrix(new Matrix4(mStack), new Vector3(0.5, height, 0.5), new Rotation(rot, Vector3.Y_POS), size);
    ccrs.brightness = 15728880;
    ccrs.bind(TileChunkLoaderRenderer.pearlType, getter);
    CCModelLibrary.icosahedron4.render(ccrs, pearlMat);
    ccrs.reset();
}

19 Source : FacadeItemModel.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderItem(ItemStack rawStack, TransformType transformType) {
    ItemStack itemStack = ModCompatibility.getRealItemStack(rawStack);
    if (!(itemStack.gereplacedem() instanceof MetaItem<?>)) {
        return;
    }
    ItemStack facadeStack = FacadeItem.getFacadeStack(itemStack);
    CCRenderState renderState = CCRenderState.instance();
    renderState.reset();
    renderState.startDrawing(GL11.GL_QUADS, DefaultVertexFormats.ITEM);
    try {
        FacadeRenderer.renderItemCover(renderState, EnumFacing.NORTH.getIndex(), facadeStack, ICoverable.getCoverPlateBox(EnumFacing.NORTH, 2.0 / 16.0));
    } catch (Throwable ignored) {
    }
    renderState.draw();
}

19 Source : MetaTileEntityCokeOvenHatch.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
    Textures.HATCH_OVERLAY.renderSided(getFrontFacing(), renderState, translation, pipeline);
}

19 Source : FueledMultiblockController.java
with GNU Lesser General Public License v3.0
from 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(), isStructureFormed() && workableHandler.isActive());
}

19 Source : MetaTileEntityMultiblockPart.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    getBaseTexture().render(renderState, translation, ArrayUtils.add(pipeline, new ColourMultiplier(GTUtility.convertRGBtoOpaqueRGBA_CL(getPaintingColorForRendering()))));
}

19 Source : MetaTileEntityItemBus.java
with GNU Lesser General Public License v3.0
from 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);
    }
}

19 Source : MetaTileEntityEnergyHatch.java
with GNU Lesser General Public License v3.0
from 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()]));
    }
}

19 Source : MetaTileEntityTeslaCoil.java
with GNU Lesser General Public License v3.0
from 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()))));
}

19 Source : MetaTileEntityHull.java
with GNU Lesser General Public License v3.0
from 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()]));
}

19 Source : MetaTileEntityArmorTable.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderMetaTileEnreplacedy(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline) {
    super.renderMetaTileEnreplacedy(renderState, translation, pipeline);
}

19 Source : MetaTileEntityAirCollector.java
with GNU Lesser General Public License v3.0
from 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);
}

19 Source : AdvCCRSConsumer.java
with GNU Lesser General Public License v3.0
from GregTechCE

public clreplaced AdvCCRSConsumer implements IVertexConsumer {

    private final CCRenderState ccrs;

    private Matrix4 translation = new Matrix4();

    public AdvCCRSConsumer(CCRenderState ccrs) {
        this.ccrs = ccrs;
    }

    @Override
    public VertexFormat getVertexFormat() {
        return ccrs.getVertexFormat();
    }

    @Override
    public void setTexture(TextureAtlreplacedprite texture) {
        ccrs.sprite = texture;
    }

    @Override
    public void put(int e, float... data) {
        VertexFormat format = getVertexFormat();
        VertexFormatElement fmte = format.getElement(e);
        switch(fmte.getUsage()) {
            case POSITION:
                ccrs.vert.vec.set(data).apply(translation);
                break;
            case UV:
                if (fmte.getIndex() == 0) {
                    ccrs.vert.uv.set(data[0], data[1]);
                } else {
                    ccrs.brightness = (int) (data[1] * 0xFFFF / 2) << 16 | (int) (data[0] * 0xFFFF / 2);
                }
                break;
            case COLOR:
                ccrs.colour = Colour.packRGBA(data);
                break;
            case NORMAL:
                ccrs.normal.set(data);
                break;
            case PADDING:
                break;
            default:
                throw new UnsupportedOperationException("Generic vertex format element");
        }
        if (e == format.getElementCount() - 1) {
            ccrs.writeVert();
        }
    }

    public void setTranslation(Matrix4 translation) {
        this.translation = translation;
    }

    @Override
    public void setQuadTint(int tint) {
    }

    @Override
    public void setQuadOrientation(EnumFacing orientation) {
    }

    @Override
    public void setApplyDiffuseLighting(boolean diffuse) {
    }
}

19 Source : CoverSolarPanel.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.SOLAR_PANEL.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

19 Source : CoverShutter.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    Textures.SHUTTER.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

19 Source : CoverFluidFilter.java
with GNU Lesser General Public License v3.0
from GregTechCE

public void renderCover(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
    this.texture.renderSided(attachedSide, plateBox, renderState, pipeline, translation);
}

19 Source : CoverFacade.java
with GNU Lesser General Public License v3.0
from GregTechCE

@Override
public void renderCoverPlate(CCRenderState renderState, Matrix4 translation, IVertexOperation[] pipeline, Cuboid6 plateBox, BlockRenderLayer layer) {
}

19 Source : CoverFacade.java
with GNU Lesser General Public License v3.0
from 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);
}

19 Source : Textures.java
with GNU Lesser General Public License v3.0
from 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();
}

19 Source : SimpleSidedCubeRenderer.java
with GNU Lesser General Public License v3.0
from 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);
    }
}

19 Source : SimpleOverlayRenderer.java
with GNU Lesser General Public License v3.0
from GregTechCE

@SideOnly(Side.CLIENT)
public void renderSided(EnumFacing side, Cuboid6 bounds, CCRenderState renderState, IVertexOperation[] pipeline, Matrix4 translation) {
    Textures.renderFace(renderState, translation, pipeline, side, bounds, sprite);
}

19 Source : SimpleOrientedCubeRenderer.java
with GNU Lesser General Public License v3.0
from GregTechCE

@SideOnly(Side.CLIENT)
public void render(CCRenderState renderState, Matrix4 translation, IVertexOperation[] ops, Cuboid6 bounds, EnumFacing frontFacing) {
    Textures.renderFace(renderState, translation, ops, EnumFacing.UP, bounds, sprites[CubeSide.TOP.ordinal()]);
    Textures.renderFace(renderState, translation, ops, EnumFacing.DOWN, bounds, sprites[CubeSide.BOTTOM.ordinal()]);
    Textures.renderFace(renderState, translation, ops, frontFacing, bounds, sprites[CubeSide.FRONT.ordinal()]);
    Textures.renderFace(renderState, translation, ops, frontFacing.getOpposite(), bounds, sprites[CubeSide.BACK.ordinal()]);
    Textures.renderFace(renderState, translation, ops, frontFacing.rotateY(), bounds, sprites[CubeSide.LEFT.ordinal()]);
    Textures.renderFace(renderState, translation, ops, frontFacing.rotateYCCW(), bounds, sprites[CubeSide.RIGHT.ordinal()]);
}

19 Source : SimpleCubeRenderer.java
with GNU Lesser General Public License v3.0
from 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);
}

See More Examples