@Override public Pair<IBakedModel, Matrix4f> handlePerspective(TransformType cameraTransformType) { TRSRTransformation tr = transforms.get(cameraTransformType); Matrix4f mat = null; if (tr != null && tr != TRSRTransformation.identity()) mat = TRSRTransformation.blockCornerToCenter(tr).getMatrix(); return Pair.of((IBakedModel) this, mat); }
private IFlexibleBakedModel bakeNormal( ModelBlock model, IModelState perState, final TRSRTransformation modelState, List<TRSRTransformation> newTransforms, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter, boolean uvLocked) { TextureAtlasSprite particle = bakedTextureGetter.apply(new ResourceLocation(model.resolveTextureName("particle"))); SimpleBakedModel.Builder builder = (new SimpleBakedModel.Builder(model)).setTexture(particle); for (int i = 0; i < model.getElements().size(); i++) { BlockPart part = model.getElements().get(i); TRSRTransformation transformation = modelState; if (newTransforms.get(i) != null) { transformation = transformation.compose(newTransforms.get(i)); } for (Map.Entry<EnumFacing, BlockPartFace> e : (Iterable<Map.Entry<EnumFacing, BlockPartFace>>) part.mapFaces.entrySet()) { TextureAtlasSprite textureatlassprite1 = bakedTextureGetter.apply( new ResourceLocation(model.resolveTextureName(e.getValue().texture))); if (e.getValue().cullFace == null || !TRSRTransformation.isInteger(transformation.getMatrix())) { builder.addGeneralQuad( makeBakedQuad( part, e.getValue(), textureatlassprite1, e.getKey(), transformation, uvLocked)); } else { builder.addFaceQuad( modelState.rotate(e.getValue().cullFace), makeBakedQuad( part, e.getValue(), textureatlassprite1, e.getKey(), transformation, uvLocked)); } } } return new ISmartBlockModel.PerspectiveWrapper( new IPerspectiveAwareModel.MapWrapper( new IFlexibleBakedModel.Wrapper(builder.makeBakedModel(), format), perState)) { public IBakedModel handleBlockState(IBlockState state) { return VanillaModelWrapper.this.handleBlockState(parent, modelState, state); } }; }
public WeightedRandomModel(ModelResourceLocation parent, Variants variants) { this.variants = variants.getVariants(); ImmutableList.Builder<Pair<IModel, IModelState>> builder = ImmutableList.builder(); for (Variant v : (List<Variant>) variants.getVariants()) { ResourceLocation loc = v.getModelLocation(); locations.add(loc); IModel model = null; try { model = getModel(loc); } catch (Exception e) { /* * Vanilla eats this, which makes it only show variants that have models. * But that doesn't help debugging, so we maintain the missing model * so that resource pack makers have a hint that their states are broken. */ FMLLog.warning( "Unable to load block model: \'" + loc + "\' for variant: \'" + parent + "\': " + e.toString()); model = getMissingModel(); } if (v instanceof ISmartVariant) { model = ((ISmartVariant) v).process(model, ModelLoader.this); try { resolveDependencies(model); } catch (IOException e) { FMLLog.getLogger() .error("Exception resolving indirect dependencies for model" + loc, e); } textures.addAll(model.getTextures()); // Kick this, just in case. } models.add(model); builder.add(Pair.of(model, v.getState())); } if (models.size() == 0) // If all variants are missing, add one with the missing model and default rotation. { IModel missing = getMissingModel(); models.add(missing); builder.add(Pair.<IModel, IModelState>of(missing, TRSRTransformation.identity())); } defaultState = new MultiModelState(builder.build()); }
public IFlexibleBakedModel bake( IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { if (!Attributes.moreSpecific(format, Attributes.DEFAULT_BAKED_FORMAT)) { throw new IllegalArgumentException( "can't bake vanilla models to the format that doesn't fit into the default one: " + format); } ModelBlock model = this.model; if (model == null) return getMissingModel() .bake(getMissingModel().getDefaultState(), format, bakedTextureGetter); List<TRSRTransformation> newTransforms = Lists.newArrayList(); for (int i = 0; i < model.getElements().size(); i++) { newTransforms.add(null); } ItemCameraTransforms transforms = model.func_181682_g(); boolean uvlock = false; if (state instanceof UVLock) { uvlock = true; state = ((UVLock) state).getParent(); } Map<TransformType, TRSRTransformation> tMap = Maps.newHashMap(); tMap.putAll(IPerspectiveAwareModel.MapWrapper.getTransforms(transforms)); tMap.putAll(IPerspectiveAwareModel.MapWrapper.getTransforms(state)); IModelState perState = new SimpleModelState(ImmutableMap.copyOf(tMap)); if (hasItemModel(model)) { return new ItemLayerModel(model).bake(perState, format, bakedTextureGetter); } if (isCustomRenderer(model)) return new IFlexibleBakedModel.Wrapper(new BuiltInModel(transforms), format); return bakeNormal( model, perState, state.apply(Optional.<IModelPart>absent()).or(TRSRTransformation.identity()), newTransforms, format, bakedTextureGetter, uvlock); }
public static BakedQuad transform( TRSRTransformation transform, BakedQuad quad, VertexFormat format) { for (VertexFormatElement e : (List<VertexFormatElement>) format.getElements()) { if (e.getUsage() == VertexFormatElement.EnumUsage.POSITION) { if (e.getType() != VertexFormatElement.EnumType.FLOAT) { throw new IllegalArgumentException("can only transform float position"); } int[] data = Arrays.copyOf(quad.getVertexData(), quad.getVertexData().length); float[] pos = new float[] {0f, 0f, 0f, 1f}; for (int i = 0; i < Math.min(4, e.getElementCount()); i++) { pos[i] = Float.intBitsToFloat(data[e.getOffset() / 4 + i]); } Vector4f vec = new Vector4f(pos); transform.getMatrix().transform(vec); vec.get(pos); for (int i = 0; i < Math.min(4, e.getElementCount()); i++) { data[e.getOffset() / 4 + i] = Float.floatToRawIntBits(pos[i]); } return new BakedQuad(data, quad.getTintIndex(), quad.getFace()); } } return quad; }