import codechicken.lib.lighting.LightModel; //导入依赖的package包/类
public static void init()
{
	INSTANCE = new RenderGlowPanel();
	TextureUtils.addIconRegistrar(INSTANCE);

	Map<String, CCModel> models = CCModel.parseObjModels(MekanismUtils.getResource(ResourceType.MODEL, "glow_panel.obj"), 7, null);

	frameModels = new CCModel[6];
	frameModels[0] = models.get("frame").backfacedCopy().apply(Vector3.center.translation()).shrinkUVs(0.0005);
	CCModel.generateSidedModels(frameModels, 0, Vector3.center);

	lightModels = new CCModel[6];
	lightModels[0] = models.get("light").backfacedCopy().apply(Vector3.center.translation()).shrinkUVs(0.0005);
	CCModel.generateSidedModels(lightModels, 0, Vector3.center);

	for(CCModel c : frameModels)
	{
		c.computeLighting(LightModel.standardLightModel);
	}
}
 

import codechicken.lib.lighting.LightModel; //导入依赖的package包/类
/**
 * Computes lighting using the normals add a light model
 * If the model is rotated, the lighting will no longer be valid
 * @return The model
 */
public CCModel computeLighting(LightModel light)
{
    Vector3[] normals = normals();
    int[] colours = getAttributes(CCRenderState.lightingAttrib);
    if(colours == null) {
        colours = getOrAllocate(CCRenderState.lightingAttrib);
        Arrays.fill(colours, -1);
    }
    for(int k = 0; k < verts.length; k++)
        colours[k] = light.apply(colours[k], normals[k]);
    return this;
}
 

import codechicken.lib.lighting.LightModel; //导入依赖的package包/类
/**
 * Computes lighting using the normals add a light model
 * If the model is rotated, the lighting will no longer be valid
 *
 * @return The model
 */
public CCModel computeLighting(LightModel light) {
    Vector3[] normals = normals();
    int[] colours = getAttributes(LightingAttribute.attributeKey);
    if (colours == null) {
        colours = getOrAllocate(LightingAttribute.attributeKey);
        Arrays.fill(colours, -1);
    }
    for (int k = 0; k < verts.length; k++) {
        colours[k] = light.apply(colours[k], normals[k]);
    }
    return this;
}
 

import codechicken.lib.lighting.LightModel; //导入依赖的package包/类
/**
 * Computes lighting using the normals add a light model
 * If the model is rotated, the lighting will no longer be valid
 *
 * @return The model
 */
public CCModel computeLighting(LightModel light)
{
    Vector3[] normals = normals();
    int[] colours = getAttributes(CCRenderState.lightingAttrib);
    if (colours == null)
    {
        colours = getOrAllocate(CCRenderState.lightingAttrib);
        Arrays.fill(colours, -1);
    }
    for (int k = 0; k < verts.length; k++)
        colours[k] = light.apply(colours[k], normals[k]);
    return this;
}
 

import codechicken.lib.lighting.LightModel; //导入依赖的package包/类
private static void renderQuad(BakedQuad quad, IBlockAccess world, IBlockState state, BlockPos pos, VertexBuffer buffer, long rand, boolean useAO) {
    AOLightMatrix matrix = new AOLightMatrix();
    matrix.locate(world, pos, useAO);
    CCQuad ccQuad = new CCQuad(quad);
    ccQuad.quadulate();
    ccQuad.computeNormals();
    VertexFormat format = buffer.getVertexFormat();
    BlockColors colours = Minecraft.getMinecraft().getBlockColors();
    LightModel lightModel = quad.shouldApplyDiffuseLighting() ? standardLightModel : noDifuseLightModel;
    int quadTintRenderPass = quad.getTintIndex();
    int tintMultiplier = -1;
    if (quadTintRenderPass != -1) {
        tintMultiplier = colours.colorMultiplier(state, world, pos, quadTintRenderPass);
    }
    for (int v = 0; v < 4; v++) {
        Vertex5 vert = ccQuad.vertices[v].copy();
        Vector3 normal = ccQuad.normals[v].copy();
        Colour colour = ccQuad.colours[v].copy().multiply(new ColourRGBA(lightModel.apply(tintMultiplier, normal)));
        LC lc = new LC();
        lc.compute(vert.vec, normal);
        TripleABC<Integer, Integer, ?> lm = matrix.apply(lc, colour);
        int finalColour = lm.getA();
        int brightness = lm.getB();
        for (int e = 0; e < format.getElementCount(); e++) {
            VertexFormatElement element = format.getElement(e);
            switch (element.getUsage()){
                case POSITION:
                    buffer.pos(vert.vec.x, vert.vec.y, vert.vec.z);
                    break;
                case UV:
                    if (element.getIndex() == 0) {
                        buffer.tex(vert.uv.u, vert.uv.v);
                    } else {
                        buffer.lightmap(brightness >> 16 & 65535, brightness & 65535);
                    }
                    break;
                case COLOR:
                    buffer.color(finalColour >>> 24, finalColour >> 16 & 0xFF, finalColour >> 8 & 0xFF, finalColour & 0xFF);
                    break;
                case NORMAL:
                    buffer.normal((float) normal.x, (float) normal.y, (float) normal.z);
                    break;
                case PADDING:
                    break;
                default:
                    throw new UnsupportedOperationException("Generic vertex format element");
            }
        }
        buffer.endVertex();
    }
    buffer.putPosition(pos.getX(), pos.getY(), pos.getZ());
}