java类net.minecraft.client.renderer.block.model.BakedQuad的实例源码

public boolean isBreakingAnimation(BakedQuad p_isBreakingAnimation_1_)
{
    if (this.breakingAnimation < 0)
    {
        if (p_isBreakingAnimation_1_ instanceof BakedQuadRetextured)
        {
            this.breakingAnimation = 1;
        }
        else
        {
            this.breakingAnimation = 0;
        }
    }

    return this.breakingAnimation == 1;
}

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);
    }
}

private BakedQuad makeQuad(BakedQuad p_makeQuad_1_, int p_makeQuad_2_, boolean p_makeQuad_3_)
{
    int[] aint = p_makeQuad_1_.getVertexData();
    int i = p_makeQuad_1_.getTintIndex();
    EnumFacing enumfacing = p_makeQuad_1_.getFace();
    TextureAtlasSprite textureatlassprite = p_makeQuad_1_.getSprite();

    if (!this.isFullSprite(p_makeQuad_1_))
    {
        p_makeQuad_2_ = 0;
    }

    aint = this.transformVertexData(aint, p_makeQuad_2_, p_makeQuad_3_);
    BakedQuad bakedquad = new BakedQuad(aint, i, enumfacing, textureatlassprite);
    return bakedquad;
}

public static IBakedModel makeModelCube(TextureAtlasSprite p_makeModelCube_0_, int p_makeModelCube_1_)
{
    List list = new ArrayList();
    EnumFacing[] aenumfacing = EnumFacing.VALUES;
    Map<EnumFacing, List<BakedQuad>> map = new HashMap();

    for (int i = 0; i < aenumfacing.length; ++i)
    {
        EnumFacing enumfacing = aenumfacing[i];
        List list1 = new ArrayList();
        list1.add(makeBakedQuad(enumfacing, p_makeModelCube_0_, p_makeModelCube_1_));
        map.put(enumfacing, list1);
    }

    ItemOverrideList itemoverridelist = new ItemOverrideList(new ArrayList());
    IBakedModel ibakedmodel = new SimpleBakedModel(list, map, true, true, p_makeModelCube_0_, ItemCameraTransforms.DEFAULT, itemoverridelist);
    return ibakedmodel;
}

@Override
protected List<BakedQuad> getQuads(IBlockState state) {
    List<BakedQuad> quads = new ArrayList<>();
    switch(MinecraftForgeClient.getRenderLayer()) {
        case SOLID:
            //Base
            quads.addAll(QuadBuilder.withFormat(format)
                    .setFrom(0, 0, 0)
                    .setTo(16, 16, 16)
                    .addAll(base)
                    .bake()
            );
            break;
        case CUTOUT_MIPPED:
            //Overlay
            quads.addAll(QuadBuilder.withFormat(format)
                    .setFrom(0, 0, 0)
                    .setTo(16, 16, 16)
                    .setHasBrightness(true)
                    .addAll(overlay)
                    .bake()
            );
            break;
    }
    return quads;
}

@Override
public List<BakedQuad> getQuads(IBlockState blockState, EnumFacing side, long rand)
{
    if (side != null) return ImmutableList.of();
    if (quads == null)
    {
        quads = buildQuads(this.state);
    }
    if (blockState instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState) blockState;
        if (exState.getUnlistedNames().contains(Properties.AnimationProperty))
        {

            IModelState newState = exState.getValue(Properties.AnimationProperty);
            if (newState != null)
            {
                newState = new ModelStateComposition(this.state, newState);
                return buildQuads(newState);
            }
        }
    }
    return quads;
}

private static void replaceTexture(List<BakedQuad> p_replaceTexture_0_, TextureAtlasSprite p_replaceTexture_1_, TextureAtlasSprite p_replaceTexture_2_)
{
    List<BakedQuad> list = new ArrayList();

    for (BakedQuad bakedquad : p_replaceTexture_0_)
    {
        if (bakedquad.getSprite() != p_replaceTexture_1_)
        {
            list.add(bakedquad);
            break;
        }

        BakedQuad bakedquad1 = new BakedQuadRetextured(bakedquad, p_replaceTexture_2_);
        list.add(bakedquad1);
    }

    p_replaceTexture_0_.clear();
    p_replaceTexture_0_.addAll(list);
}

private void renderModelBrightnessColorQuads(float p_178264_1_, float p_178264_2_, float p_178264_3_, float p_178264_4_, List<BakedQuad> p_178264_5_)
{
    Tessellator tessellator = Tessellator.getInstance();
    WorldRenderer worldrenderer = tessellator.getWorldRenderer();

    for (BakedQuad bakedquad : p_178264_5_)
    {
        worldrenderer.begin(7, DefaultVertexFormats.ITEM);
        worldrenderer.addVertexData(bakedquad.getVertexData());

        if (bakedquad.hasTintIndex())
        {
            worldrenderer.putColorRGB_F4(p_178264_2_ * p_178264_1_, p_178264_3_ * p_178264_1_, p_178264_4_ * p_178264_1_);
        }
        else
        {
            worldrenderer.putColorRGB_F4(p_178264_1_, p_178264_1_, p_178264_1_);
        }

        Vec3i vec3i = bakedquad.getFace().getDirectionVec();
        worldrenderer.putNormal((float)vec3i.getX(), (float)vec3i.getY(), (float)vec3i.getZ());
        tessellator.draw();
    }
}

public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand)
{
    BakedFluid model = this;
    if(state instanceof IExtendedBlockState)
    {
        IExtendedBlockState exState = (IExtendedBlockState)state;
        int[] cornerRound = getCorners(Optional.of(exState));
        int flowRound = getFlow(Optional.of(exState));
        long key = flowRound + 1024;
        for(int i = 3; i >= 0; i--)
        {
            key <<= 10;
            key |= cornerRound[i];
        }
        key <<= 1;
        key |= 1;
        model = modelCache.getUnchecked(key);
    }
    if(side == null) return ImmutableList.of();
    return model.faceQuads.get(side);
}

private BakedQuad makeQuad(BakedQuad p_makeQuad_1_, int p_makeQuad_2_, boolean p_makeQuad_3_)
{
    int[] aint = p_makeQuad_1_.getVertexData();
    int i = p_makeQuad_1_.getTintIndex();
    EnumFacing enumfacing = p_makeQuad_1_.getFace();
    TextureAtlasSprite textureatlassprite = p_makeQuad_1_.getSprite();

    if (!this.isFullSprite(p_makeQuad_1_))
    {
        return p_makeQuad_1_;
    }
    else
    {
        aint = this.transformVertexData(aint, p_makeQuad_2_, p_makeQuad_3_);
        BakedQuad bakedquad = new BakedQuad(aint, i, enumfacing, textureatlassprite);
        return bakedquad;
    }
}

private void renderModelBrightnessColorQuads(float brightness, float red, float green, float blue, List<BakedQuad> listQuads)
{
    Tessellator tessellator = Tessellator.getInstance();
    VertexBuffer vertexbuffer = tessellator.getBuffer();
    int i = 0;

    for (int j = listQuads.size(); i < j; ++i)
    {
        BakedQuad bakedquad = (BakedQuad)listQuads.get(i);
        vertexbuffer.begin(7, DefaultVertexFormats.ITEM);
        vertexbuffer.addVertexData(bakedquad.getVertexData());

        if (bakedquad.hasTintIndex())
        {
            vertexbuffer.putColorRGB_F4(red * brightness, green * brightness, blue * brightness);
        }
        else
        {
            vertexbuffer.putColorRGB_F4(brightness, brightness, brightness);
        }

        Vec3i vec3i = bakedquad.getFace().getDirectionVec();
        vertexbuffer.putNormal((float)vec3i.getX(), (float)vec3i.getY(), (float)vec3i.getZ());
        tessellator.draw();
    }
}

public boolean isBreakingAnimation(BakedQuad p_isBreakingAnimation_1_)
{
    if (this.breakingAnimation < 0)
    {
        if (p_isBreakingAnimation_1_ instanceof BreakingFour)
        {
            this.breakingAnimation = 1;
        }
        else
        {
            this.breakingAnimation = 0;
        }
    }

    return this.breakingAnimation == 1;
}

private void renderQuad(WorldRenderer renderer, BakedQuad quad, int color)
{
    if (renderer.isMultiTexture())
    {
        renderer.addVertexData(quad.getVertexDataSingle());
        renderer.putSprite(quad.getSprite());
    }
    else
    {
        renderer.addVertexData(quad.getVertexData());
    }

    if (Reflector.IColoredBakedQuad.exists() && Reflector.IColoredBakedQuad.isInstance(quad))
    {
        forgeHooksClient_putQuadColor(renderer, quad, color);
    }
    else
    {
        renderer.putColor4(color);
    }

    this.putQuadNormal(renderer, quad);
}

public static void renderQuadColorSlow(VertexBuffer wr, BakedQuad quad, int auxColor)
{
    ItemConsumer cons;
    if(wr == Tessellator.getInstance().getBuffer())
    {
        cons = getItemConsumer();
    }
    else
    {
        cons = new ItemConsumer(new VertexBufferConsumer(wr));
    }
    float b = (float)(auxColor & 0xFF) / 0xFF;
    float g = (float)((auxColor >>> 8) & 0xFF) / 0xFF;
    float r = (float)((auxColor >>> 16) & 0xFF) / 0xFF;
    float a = (float)((auxColor >>> 24) & 0xFF) / 0xFF;

    cons.setAuxColor(r, g, b, a);
    quad.pipe(cons);
}

public static synchronized BakedQuad[] getConnectedTexture(IBlockAccess p_getConnectedTexture_0_, IBlockState p_getConnectedTexture_1_, BlockPos p_getConnectedTexture_2_, BakedQuad p_getConnectedTexture_3_, RenderEnv p_getConnectedTexture_4_)
{
    TextureAtlasSprite textureatlassprite = p_getConnectedTexture_3_.getSprite();

    if (textureatlassprite == null)
    {
        return p_getConnectedTexture_4_.getArrayQuadsCtm(p_getConnectedTexture_3_);
    }
    else
    {
        Block block = p_getConnectedTexture_1_.getBlock();

        if (skipConnectedTexture(p_getConnectedTexture_0_, p_getConnectedTexture_1_, p_getConnectedTexture_2_, p_getConnectedTexture_3_, p_getConnectedTexture_4_))
        {
            p_getConnectedTexture_3_ = getQuad(emptySprite, p_getConnectedTexture_3_);
            return p_getConnectedTexture_4_.getArrayQuadsCtm(p_getConnectedTexture_3_);
        }
        else
        {
            EnumFacing enumfacing = p_getConnectedTexture_3_.getFace();
            BakedQuad[] abakedquad = getConnectedTextureMultiPass(p_getConnectedTexture_0_, p_getConnectedTexture_1_, p_getConnectedTexture_2_, enumfacing, p_getConnectedTexture_3_, p_getConnectedTexture_4_);
            return abakedquad;
        }
    }
}

public boolean isBreakingAnimation(BakedQuad p_isBreakingAnimation_1_)
{
    if (this.breakingAnimation < 0)
    {
        if (p_isBreakingAnimation_1_ instanceof BreakingFour)
        {
            this.breakingAnimation = 1;
        }
        else
        {
            this.breakingAnimation = 0;
        }
    }

    return this.breakingAnimation == 1;
}

private BakedQuad createQuad(Vec3d v1, Vec3d v2, Vec3d v3, Vec3d v4, TextureAtlasSprite sprite) {
    Vec3d normal = v3.subtract(v2).crossProduct(v1.subtract(v2)).normalize();

    UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format);
    builder.setTexture(sprite);
    putVertex(builder, normal, v1.x, v1.y, v1.z, sprite, 0, 0);
    putVertex(builder, normal, v2.x, v2.y, v2.z, sprite, 0, 16);
    putVertex(builder, normal, v3.x, v3.y, v3.z, sprite, 16, 16);
    putVertex(builder, normal, v4.x, v4.y, v4.z, sprite, 16, 0);
    return builder.build();
}

public static BakedQuad makeBakedQuad(EnumFacing p_makeBakedQuad_0_, TextureAtlasSprite p_makeBakedQuad_1_, int p_makeBakedQuad_2_)
{
    Vector3f vector3f = new Vector3f(0.0F, 0.0F, 0.0F);
    Vector3f vector3f1 = new Vector3f(16.0F, 16.0F, 16.0F);
    BlockFaceUV blockfaceuv = new BlockFaceUV(new float[] {0.0F, 0.0F, 16.0F, 16.0F}, 0);
    BlockPartFace blockpartface = new BlockPartFace(p_makeBakedQuad_0_, p_makeBakedQuad_2_, "#" + p_makeBakedQuad_0_.getName(), blockfaceuv);
    ModelRotation modelrotation = ModelRotation.X0_Y0;
    BlockPartRotation blockpartrotation = null;
    boolean flag = false;
    boolean flag1 = true;
    FaceBakery facebakery = new FaceBakery();
    BakedQuad bakedquad = facebakery.makeBakedQuad(vector3f, vector3f1, blockpartface, p_makeBakedQuad_1_, p_makeBakedQuad_0_, modelrotation, blockpartrotation, flag, flag1);
    return bakedquad;
}

@Override
public List<BakedQuad> bakeItemQuads(EnumFacing face, ItemStack stack) {

    int damage = stack.getItemDamage();
    if (damage < 0 || damage > RedstoneEther.numfreqs) {
        damage = 0;
    }

    return ItemQuadBakery.bakeItem(ImmutableList.of(TriangTexManager.getIconFromDamage(damage)));
}

@Override
public List<BakedQuad> bakeItemQuads(EnumFacing face, ItemStack stack) {
    TextureAtlasSprite sprite;
    int freq = stack.getItemDamage();
    if (freq <= 0 || freq > RedstoneEther.numfreqs) {
        sprite = RemoteTexManager.getIcon(-1, false);
    } else {
        sprite = RemoteTexManager.getIcon(RedstoneEther.get(true).getFreqColourId(freq), ItemWirelessRemote.getTransmitting(stack));
    }
    return ItemQuadBakery.bakeItem(ImmutableList.of(sprite));
}

@Override
public IBakedModel bake(IModelState state, VertexFormat format,
        java.util.function.Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {

    ImmutableMap<TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state);

    TRSRTransformation transform = (TRSRTransformation.identity());

    ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder();

    if (headTexture != null && haftTexture != null && handleTexture != null) {

        ImmutableList.Builder<ResourceLocation> texBuilder = ImmutableList.builder();
        if (haftTexture != null) {
            texBuilder.add(haftTexture);
        }
        if (headTexture != null) {
            texBuilder.add(headTexture);
        }
        if (handleTexture != null) {
            texBuilder.add(handleTexture);
        }
        if (adornmentTexture != null) {
            texBuilder.add(adornmentTexture);
        }
        ImmutableList<ResourceLocation> textures = texBuilder.build();

        IBakedModel model = (new ItemLayerModel(textures)).bake(state, format, bakedTextureGetter);
        builder.addAll(model.getQuads(null, null, 0));
    }

    return new BakedAxeModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap),
            Maps.<String, IBakedModel>newHashMap());
}

public static void putBakedQuad(IVertexConsumer consumer, BakedQuad quad)
{
    try
    {
        consumer.setTexture(quad.getSprite());
    }
    catch(AbstractMethodError e)
    {
        // catch missing method errors caused by change to IVertexConsumer
    }
    consumer.setQuadOrientation(quad.getFace());
    if(quad.hasTintIndex())
    {
        consumer.setQuadTint(quad.getTintIndex());
    }
    consumer.setApplyDiffuseLighting(quad.shouldApplyDiffuseLighting());
    //int[] eMap = mapFormats(consumer.getVertexFormat(), DefaultVertexFormats.ITEM);
    float[] data = new float[4];
    VertexFormat formatFrom = consumer.getVertexFormat();
    VertexFormat formatTo = quad.getFormat();
    int countFrom = formatFrom.getElementCount();
    int countTo = formatTo.getElementCount();
    int[] eMap = formatMaps.getUnchecked(Pair.of(formatFrom, formatTo));
    for(int v = 0; v < 4; v++)
    {
        for(int e = 0; e < countFrom; e++)
        {
            if(eMap[e] != countTo)
            {
                unpack(quad.getVertexData(), data, quad.getFormat(), v, eMap[e]);
                consumer.put(e, data);
            }
            else
            {
                consumer.put(e);
            }
        }
    }
}

@Override
public IBakedModel bake(IModelState state, VertexFormat format,
        java.util.function.Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {

    ImmutableMap<TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state);

    TRSRTransformation transform = (TRSRTransformation.identity());

    ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder();

    if (headTexture != null && haftTexture != null && handleTexture != null) {

        ImmutableList.Builder<ResourceLocation> texBuilder = ImmutableList.builder();
        if (haftTexture != null) {
            texBuilder.add(haftTexture);
        }
        if (headTexture != null) {
            texBuilder.add(headTexture);
        }
        if (handleTexture != null) {
            texBuilder.add(handleTexture);
        }
        if (adornmentTexture != null) {
            texBuilder.add(adornmentTexture);
        }
        ImmutableList<ResourceLocation> textures = texBuilder.build();

        IBakedModel model = (new ItemLayerModel(textures)).bake(state, format, bakedTextureGetter);
        builder.addAll(model.getQuads(null, null, 0));
    }

    return new BakedPickaxeModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap),
            Maps.<String, IBakedModel>newHashMap());
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {
    if (state instanceof IExtendedBlockState) {
        List<IBakedModel> subModels = getSubModels((IExtendedBlockState) state);
        List<BakedQuad> quads = new ArrayList<BakedQuad>();

        for (IBakedModel model : subModels) {
            quads.addAll(model.getQuads(state, side, rand));
        }

        return quads;
    }
    return Collections.EMPTY_LIST;
}

public BakedAxeModel(AxeModel parent, ImmutableList<BakedQuad> quads, VertexFormat format,
        ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transforms,
        Map<String, IBakedModel> cache) {
    this.quads = quads;
    this.format = format;
    this.parent = parent;
    this.transforms = itemTransforms();
    this.cache = cache;
}

private IBakedModel getModel(@Nonnull ItemStack stack) {
    String key = getKey(stack);
    int meta = stack.getMetadata();
    if (!modelCache.containsKey(key)) {
        if (DankTextures.DANKNULL_PANELS == null) {
            DankTextures.getInstance().registerIcons(RenderUtils.getBlocksTextureMap());
        }
        List<BakedQuad> quads = ItemQuadBakery.bakeItem(DankTextures.DANKNULL_PANELS[meta]);
        modelCache.put(key, new PerspectiveAwareBakedModel(quads, props));
    }
    return modelCache.get(key);
}

public SimpleBakedModel(List<BakedQuad> p_i46077_1_, List<List<BakedQuad>> p_i46077_2_, boolean p_i46077_3_, boolean p_i46077_4_, TextureAtlasSprite p_i46077_5_, ItemCameraTransforms p_i46077_6_)
{
    this.generalQuads = p_i46077_1_;
    this.faceQuads = p_i46077_2_;
    this.ambientOcclusion = p_i46077_3_;
    this.gui3d = p_i46077_4_;
    this.texture = p_i46077_5_;
    this.cameraTransforms = p_i46077_6_;
}

@SubscribeEvent
public void onModelBake(ModelBakeEvent event)
{
    ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder();
    builder.addAll(ItemLayerModel.getQuadsForSprite(0, txInstrument, DefaultVertexFormats.ITEM, Optional.empty()));
    event.getModelRegistry().putObject(new ModelResourceLocation("clef:instrument", "inventory"), new BakedModelInstrument(builder.build(), txInstrument, ImmutableMap.copyOf(new HashMap<>()), null, null));
}

private void addGeneralBreakingFours(IBakedModel p_177647_1_, TextureAtlasSprite p_177647_2_)
{
    for (BakedQuad bakedquad : p_177647_1_.getGeneralQuads())
    {
        this.addGeneralQuad(new BreakingFour(bakedquad, p_177647_2_));
    }
}

@Override
public List<BakedQuad> getQuads(IBlockState state, EnumFacing side, long rand) {

    List<TexturedCuboid> cuboidList = new ArrayList<TexturedCuboid>();
    TexturedCuboid boxStraightYAxis = new TexturedCuboid(0.25F, 0F, 0.25F, 0.5F, 1F, 0.5F, itemTexMap);
    cuboidList.add(boxStraightYAxis);
    return ModelFactory.convertCuboidListToModel(DefaultVertexFormats.BLOCK, cuboidList, false);
}