Java LightUtil.unpack方法代码示例

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包/类
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 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包/类
/**
 * Bakes the data inside the VertexBuffer to a baked quad.
 *
 * @return The list of quads baked.
 */
public List<BakedQuad> bake() {
    if (isDrawing) {
        CCLLog.log(Level.WARN, new IllegalStateException("Bake called before finishDrawing!"), "Someone is calling bake before finishDrawing!");
        finishDrawing();
    }
    State state = getVertexState();
    VertexFormat format = state.getVertexFormat();
    if (!format.hasUvOffset(0)) {
        throw new IllegalStateException("Unable to bake format that does not have UV mappings!");
    }
    int[] rawBuffer = Arrays.copyOf(state.getRawBuffer(), state.getRawBuffer().length);

    List<BakedQuad> quads = new LinkedList<>();
    TextureAtlasSprite sprite = TextureUtils.getMissingSprite();

    int curr = 0;
    int next = format.getNextOffset();
    int i = 0;
    while (rawBuffer.length >= next) {
        int[] quadData = Arrays.copyOfRange(rawBuffer, curr, next);
        Vector3 normal = new Vector3();
        if (format.hasNormal()) {
            //Grab first normal.
            float[] normalData = new float[4];
            LightUtil.unpack(quadData, normalData, format, 0, VertexDataUtils.getNormalElement(format));
            normal = Vector3.fromArray(normalData);
        } else {
            //No normal provided in format, so we calculate.
            float[][] posData = new float[4][4];
            for (int v = 0; v < 4; v++) {
                LightUtil.unpack(quadData, posData[v], format, v, VertexDataUtils.getPositionElement(format));
            }
            normal.set(VectorUtils.calculateNormal(Vector3.fromArray(posData[0]), Vector3.fromArray(posData[1]), Vector3.fromArray(posData[3])));
        }
        if (useSprites) {
            //Attempt to get sprite for vertex.
            if (spriteMap.containsKey(i)) {
                //Use provided sprite for vertex.
                sprite = spriteMap.get(i);
            } else {
                //Sprite not found for vertex, so we attempt to calculate the sprite.
                float[] uvData = new float[4];
                LightUtil.unpack(quadData, uvData, format, 0, VertexDataUtils.getUVElement(format));
                UV uv = new UV(uvData[0], uvData[1]);
                sprite = VertexDataUtils.getSpriteForUV(TextureUtils.getTextureMap(), uv);
            }
        }
        //Use normal to calculate facing.
        EnumFacing facing = VectorUtils.calcNormalSide(normal);
        if (facing == null) {
            facing = EnumFacing.UP;
        }
        BakedQuad quad = new BakedQuad(quadData, -1, facing, sprite, useDiffuseLighting, format);
        quads.add(quad);
        curr = next;
        next += format.getNextOffset();
        i++;
    }
    return ImmutableList.copyOf(quads);
}