Java LightUtil类代码示例

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static void renderQuads(VertexBuffer renderer, List<BakedQuad> quads, int color, ItemStack stack) {
	boolean flag = (color == -1) && (!stack.isEmpty());
	int i = 0;
	for (int j = quads.size(); i < j; i++) {
		BakedQuad bakedquad = quads.get(i);
		int k = color;
		if ((flag) && (bakedquad.hasTintIndex())) {
			ItemColors itemColors = Minecraft.getMinecraft().getItemColors();
			k = itemColors.getColorFromItemstack(stack, bakedquad.getTintIndex());
			if (EntityRenderer.anaglyphEnable) {
				k = TextureUtil.anaglyphColor(k);
			}
			k |= 0xFF000000;
		}
		LightUtil.renderQuadColor(renderer, bakedquad, k);
	}
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private void renderQuads(BufferBuilder renderer, List<BakedQuad> quads, int color, ItemStack stack)
{
    boolean flag = color == -1 && !stack.isEmpty();
    int i = 0;

    for (int j = quads.size(); i < j; ++i)
    {
        BakedQuad bakedquad = quads.get(i);
        int k = color;

        if (flag && bakedquad.hasTintIndex())
        {
            k = this.mc.getItemColors().getColorFromItemstack(stack, bakedquad.getTintIndex());

            if (EntityRenderer.anaglyphEnable)
                k = TextureUtil.anaglyphColor(k);
            k = k | -16777216;
        }
        LightUtil.renderQuadColor(renderer, bakedquad, k);
    }
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static void renderModel(IBakedModel model, int color)
    {
        Tessellator tessellator = Tessellator.getInstance();
        VertexBuffer buffer = tessellator.getBuffer();
        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM);
//        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM);
//        GlStateManager.disableLighting();

        List<BakedQuad> quads = model.getQuads(null,null,0);

        for (BakedQuad quad : quads)
        {
            LightUtil.renderQuadColor(buffer, quad, color);
        }

        tessellator.draw();
    }
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static List<BakedQuad> shadeQuadFaces(List<BakedQuad> quads) {
    LinkedList<BakedQuad> shadedQuads = new LinkedList<>();
    for (BakedQuad quad : quads) {
        int[] rawData = quad.getVertexData();
        for (int v = 0; v < 4; v++) {
            for (int e = 0; e < quad.getFormat().getElementCount(); e++) {
                VertexFormatElement element = quad.getFormat().getElement(e);
                if (element.getUsage() == EnumUsage.COLOR) {
                    float[] data = new float[4];
                    LightUtil.unpack(rawData, data, quad.getFormat(), v, e);

                    data = diffuseFaceLight(quad.getFace(), data);

                    LightUtil.pack(data, rawData, quad.getFormat(), v, e);
                }
            }
        }
        shadedQuads.add(new BakedQuad(rawData, quad.getTintIndex(), quad.getFace(), quad.getSprite(), quad.shouldApplyDiffuseLighting(), quad.getFormat()));
    }

    return shadedQuads;
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public final UnpackedBakedQuad transformQuad(BakedQuad quad) {
    // Fetch required information
    final VertexFormat format = quad.getFormat();
    final float[][][] vertexData = new float[4][format.getElementCount()][4];

    // Objects to be reused in the loop
    final Vector4f temp = new Vector4f();

    //unpack and transform vertex data
    for (int v = 0; v < 4; v++) {
        for (int e = 0; e < format.getElementCount(); e++) {
            LightUtil.unpack(quad.getVertexData(), vertexData[v][e], format, v, e);
            transformUnpackedVertexDataElement(format.getElement(e).getUsage(), vertexData[v][e], temp);
        }
    }
    //create new quad with the transformed vertex data
    return new UnpackedBakedQuad(vertexData, quad.getTintIndex(), quad.getFace(), quad.getSprite(), quad.shouldApplyDiffuseLighting(), format);
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private void putVertexData(@Nonnull Builder builder, @Nonnull Vertex v, float w) {
  VertexFormat format = builder.getVertexFormat();
  for (int e = 0; e < format.getElementCount(); e++) {
    switch (format.getElement(e).getUsage()) {
    case POSITION:
      builder.put(e, (float) v.x(), (float) v.y(), (float) v.z(), 1);
      break;
    case COLOR:
      float d = LightUtil.diffuseLight(v.nx(), v.ny(), v.nz());
      builder.put(e, d * color.x, d * color.y, d * color.z, color.w);
      break;
    case UV:
      builder.put(e, tex.getInterpolatedU(v.u() * 16) * w, tex.getInterpolatedV(v.v() * 16) * w, 0, w);
      break;
    case NORMAL:
      builder.put(e, v.nx(), v.ny(), v.nz(), 0);
      break;
    default:
      builder.put(e);
    }
  }
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private static void renderModel(IBakedModel model, VertexFormat fmt, int color)
{
    Tessellator tessellator = Tessellator.getInstance();
    BufferBuilder worldrenderer = tessellator.getBuffer();
    worldrenderer.begin(GL11.GL_QUADS, fmt);
    for (BakedQuad bakedquad : model.getQuads(null, null, 0))
    {
        LightUtil.renderQuadColor(worldrenderer, bakedquad, color);
    }
    tessellator.draw();
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private void renderQuads(final World world, final IBlockState actualState, final BlockPos pos, final List<BakedQuad> quads, final int alpha)
{
    final Tessellator tessellator = Tessellator.getInstance();
    final BufferBuilder buffer = tessellator.getBuffer();

    for (final BakedQuad quad : quads)
    {
        buffer.begin(GL11.GL_QUADS, quad.getFormat());

        final int color = quad.hasTintIndex() ? this.getTint(world, actualState, pos, alpha, quad.getTintIndex()) : alpha | 0xffffff;
        LightUtil.renderQuadColor(buffer, quad, color);

        tessellator.draw();
    }
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private static BakedQuad transform(final BakedQuad quad, final IVertexTransformer transformer)
{
    final VertexFormat format = quad.getFormat();
    final UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
    LightUtil.putBakedQuad(new VertexTransformerWrapper(builder, quad, transformer), quad);
    return builder.build();
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private static final void renderQuads(final List<BakedQuad> quads, final int alpha)
{
    final Tessellator tessellator = Tessellator.getInstance();
    final BufferBuilder buffer = tessellator.getBuffer();

    if (quads == null || quads.isEmpty())
        return;
    buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.ITEM);
    quads.forEach(quad -> LightUtil.renderQuadColor(buffer, quad, alpha | 0xffffff));
    tessellator.draw();
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
protected boolean checkDepth(BakedQuad quad, Vector3 hit, EnumFacing hitFace) {
    int[] quadData = quad.getVertexData();
    VertexFormat format = quad.getFormat();
    int e = VertexDataUtils.getPositionElement(format);

    Vector3 posVec = new Vector3();
    float[] pos = new float[4];
    for (int v = 0; v < 4; v++) {
        LightUtil.unpack(quadData, pos, format, v, e);
        posVec.add(pos[0], pos[1], pos[2]);
    }
    posVec.divide(4);

    double diff = 0;
    switch (hitFace.getAxis()) {
        case X:
            diff = Math.abs(hit.x - posVec.x);
            break;
        case Y:
            diff = Math.abs(hit.y - posVec.y);
            break;
        case Z:
            diff = Math.abs(hit.z - posVec.z);
            break;
    }
    return !(diff > 0.01);
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static void fullyPackQuads(int[] packedData, float[][][] unpackedData, VertexFormat format) {
    for (int e = 0; e < format.getElementCount(); e++) {
        for (int v = 0; v < 4; v++) {
            LightUtil.pack(unpackedData[v][e], packedData, format, v, e);
        }
    }
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static void fullyUnPackQuads(int[] packedData, float[][][] unpackedData, VertexFormat format) {
    for (int e = 0; e < format.getElementCount(); e++) {
        for (int v = 0; v < 4; v++) {
            LightUtil.unpack(packedData, unpackedData[v][e], format, v, e);
        }
    }
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
public static void renderBakedModel(IBakedModel bakedModel) {
	Tessellator tessellator = Tessellator.getInstance();

	BufferBuilder worldrenderer = tessellator.getBuffer();
	// VertexFormat VF = new VertexFormat();
	// worldrenderer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR_NORMAL);// bakedModel.getFormat());
	// OPTION A
	BakedQuad bakedQuad1 = (BakedQuad) bakedModel.getQuads(null, null, 0).get(0);

	// DARK no normal :( due to baked quad not having it worldrenderer.begin(GL11.GL_QUADS, MYFORMAT);// bakedModel.getFormat());
	worldrenderer.begin(GL11.GL_QUADS, bakedQuad1.getFormat());

	// for (BakedQuad bakedQuad : bakedModel.getQuads(null, null, 0)) {
	// worldrenderer.addVertexData(bakedQuad.getVertexData());
	//
	// }
	// alt version if ever needed

	for (BakedQuad bakedQuad : bakedModel.getQuads(null, null, 0)) {
		int j = -1;
		j = j | -16777216;
		LightUtil.renderQuadColor(worldrenderer, bakedQuad, j);

	}

	tessellator.draw();
}
 

import net.minecraftforge.client.model.pipeline.LightUtil; //导入依赖的package包/类
private int computeOcclusionHash(EnumFacing face)
{
    List<BakedQuad> quads = getQuads(face);
    QuadListKeyBuilder keyBuilder = new QuadListKeyBuilder(face);
    for(BakedQuad q : quads)
    {
        LightUtil.putBakedQuad(keyBuilder, q);
    }
    return keyBuilder.getQuadListKey();
}