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

@Override
public void render(ItemStack stack, float patrtialTicks) {
    GlStateManager.pushMatrix();
    RenderItem renderItem = Minecraft.getMinecraft().getRenderItem();
    renderItem.renderItem(stack, parent);
    InventoryBPortableBarrel barrel = BlocksItemsBetterChests.betterportablebarrel.getInventoryFor(stack, null);
    if (barrel != null && barrel.getChestPart().isItemSet()) {
        InventoryPartBarrel part = barrel.getChestPart();
        GlStateManager.pushMatrix();
        GlStateManager.translate(0, 0, -0.05);
        GlStateManager.scale(0.8, 0.8, 0.8);

        renderItem.renderItem(part.getDummy(), TransformType.FIXED);

        GlStateManager.enableBlend();
        GlStateManager.popMatrix();
    }
    GlStateManager.popMatrix();
}

@SubscribeEvent
public void renderPlayer(RenderPlayerEvent.Post event) {
    EntityPlayer player = event.getEntityPlayer();

    ItemStack bag = getBagInInv(player);

    if (!bag.isEmpty()) {
        GL11.glPushMatrix();

        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glTranslatef(0.0F, 17 * ONE_PIXEL, 0.0F);
        GL11.glRotatef( - player.renderYawOffset, 0.0F, 1.0F, 0.0F);
        GL11.glTranslatef(0.0F, 0.0F, -4 * ONE_PIXEL);
        if (player.isSneaking()) {
            GL11.glTranslatef(0, -5 * ONE_PIXEL, 0);
            GL11.glRotatef(28.6F, 1.0F, 0.0F, 0.0F);
            GL11.glTranslatef(0, 0, -3 * ONE_PIXEL);
        }

        Minecraft.getMinecraft().getRenderItem().renderItem(bag, TransformType.FIXED);
        GL11.glPopMatrix();
    }
}

@Override
public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, World world, EntityLivingBase entity) {
    final Pair<ItemStack, Integer> r = ItemDevNull.getContents(stack);
    final int depth = Math.max(1, r.getRight());

    if (depth >= ItemDevNull.STACK_LIMIT)
        return emptyFrameModels2d.get(ItemDevNull.STACK_LIMIT);

    final int modelId = depth - 1;
    final ItemStack innerStack = r.getLeft();
    if (innerStack.isEmpty())
        return emptyFrameModels2d.get(modelId);

    final IBakedModel innerModel = getItemModel(innerStack, world, entity);

    final ModelKey key = new ModelKey(innerModel, modelId, innerStack.getCount(), TransformType.NONE);
    return wrappedModelCache.getUnchecked(key).getLeft();
}

@Override
public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
    final Map<TransformType, Matrix4f> transforms = extractInventoryTransforms(state, format, bakedTextureGetter);

    List<TextureAtlasSprite> textures = Lists.newArrayList();
    Optional<TextureAtlasSprite> maybeParticle = Optional.empty();

    for (Map.Entry<String, TextureAtlasSprite> e : this.textures.bakeWithKeys(bakedTextureGetter).entrySet()) {
        if (e.getKey().equals("particle")) {
            maybeParticle = Optional.of(e.getValue());
        } else {
            textures.add(e.getValue());
        }
    }

    final TextureAtlasSprite missing = bakedTextureGetter.apply(TextureMap.LOCATION_MISSING_TEXTURE);
    final TextureAtlasSprite particle = maybeParticle.orElse(missing);

    if (textures.isEmpty()) textures.add(missing);

    return new Baked(particle, textures, format, transforms);
}

private static Map<TransformType, Matrix4f> extractInventoryTransformsFromState(IModelState state) {
    final Map<TransformType, Matrix4f> output = Maps.newHashMap();
    for (TransformType type : TransformType.values()) {
        Matrix4f mat = null;
        final Optional<TRSRTransformation> maybeTransform = state.apply(Optional.of(type));
        if (maybeTransform.isPresent()) {
            final TRSRTransformation transform = maybeTransform.get();
            if (!transform.equals(TRSRTransformation.identity())) {
                mat = TRSRTransformation.blockCornerToCenter(transform).getMatrix();
            }
        }

        output.put(type, mat);
    }
    return output;
}

public MultiLayerBakedModel(Map<BlockRenderLayer, IBakedModel> models, IBakedModel base, IBakedModel missing, ImmutableMap<TransformType, TRSRTransformation> cameraTransforms) {
    super(base, cameraTransforms);
    this.models = ImmutableMap.copyOf(models);
    this.missing = missing;

    final List<BakedQuad> quads = Lists.newArrayList();

    for (BlockRenderLayer layer : BlockRenderLayer.values()) {
        final IBakedModel model = models.get(layer);
        if (model != null) {
            buildQuadsForLayer(quads, model);
        }
    }

    this.quads = ImmutableList.copyOf(quads);
}

@Override
public IBakedModel bake(final IModelState state, final VertexFormat format, final Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
    final Map<TransformType, IBakedModel> bakedModels = Maps.transformValues(models, location -> bakeModel(location, state, format, bakedTextureGetter));

    IModel missing = ModelLoaderRegistry.getMissingModel();
    IBakedModel bakedMissing = missing.bake(missing.getDefaultState(), format, bakedTextureGetter);

    final IBakedModel bakedBase;
    if (base.isPresent()) {
        bakedBase = bakeModel(base.get(), state, format, bakedTextureGetter);
    } else {
        bakedBase = bakedMissing;
    }

    return new PerspectiveAwareBakedModel(
            bakedModels,
            bakedBase,
            PerspectiveMapWrapper.getTransforms(state));
}

@Override
public void doRenderLayer(@Nonnull RenderPlayer renderPlayer, EntityEquipmentSlot equipmentSlot, @Nonnull ItemStack piece,
    @Nonnull AbstractClientPlayer entitylivingbaseIn, float p_177141_2_, float p_177141_3_, float partialTicks, float p_177141_5_, float p_177141_6_,
    float p_177141_7_, float scale) {
  if (equipmentSlot != null) {
    return;
  }

  GlStateManager.pushMatrix();

  if (entitylivingbaseIn.isSneaking()) {
    GlStateManager.translate(0.0F, 0.2F, 0.0F);
  }

  renderPlayer.getMainModel().bipedHead.postRender(0.0625F);
  GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);

  GlStateManager.rotate(90.0F, 1.0F, 0.0F, 0.0F);
  GlStateManager.scale(0.75f, 0.9f, 2);
  GlStateManager.translate(0.0F, 2.7f * 0.0625F, .49 * 0.0625F);

  Minecraft.getMinecraft().getItemRenderer().renderItem(entitylivingbaseIn, piece, TransformType.NONE);

  GlStateManager.popMatrix();
}

public BakedProgrammingPuzzle(ModelProgrammingPuzzle parent, ImmutableList<BakedQuad> quads,
                              TextureAtlasSprite particle, VertexFormat format,
                              ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transforms,
                              Map<String, IBakedModel> cache) {
    this.quads = quads;
    this.particle = particle;
    this.format = format;
    this.parent = parent;
    this.transforms = transforms;
    this.cache = cache;
    this.overridesList = new PuzzleOverrideList(Collections.emptyList(), this);
}

public static CCModelState block() {
    ImmutableMap.Builder<TransformType, TRSRTransformation> defaultBlockBuilder = ImmutableMap.builder();
    defaultBlockBuilder.put(TransformType.GUI, TransformUtils.get(0, 0, 0, 30, 225, 0, 0.625f));
    defaultBlockBuilder.put(TransformType.GROUND, TransformUtils.get(0, 3, 0, 0, 0, 0, 0.25f));
    defaultBlockBuilder.put(TransformType.FIXED, TransformUtils.get(0, 0, 5, 90, 0, 0, 0.75f));
    defaultBlockBuilder.put(TransformType.THIRD_PERSON_RIGHT_HAND, TransformUtils.get(0, 2.5f, 3f, 75, 45, 0, 0.375f));
    defaultBlockBuilder.put(TransformType.THIRD_PERSON_LEFT_HAND, TransformUtils.leftify(TransformUtils.get(0, 2.5f, 3F, 75, 45, 0, 0.375f)));
    defaultBlockBuilder.put(TransformType.FIRST_PERSON_RIGHT_HAND, TransformUtils.get(0, 4f, 0, 0, 45, 0, 0.4f));
    defaultBlockBuilder.put(TransformType.FIRST_PERSON_LEFT_HAND, TransformUtils.get(0, 4f, 0, 0, 225, 0, 0.4f));
    return new CCModelState(defaultBlockBuilder.build());
}