public Optional<TRSRTransformation> apply(Optional<? extends IModelPart> part) { // TODO make more use of Optional if(!part.isPresent()) { if(parent != null) { return parent.apply(part); } return Optional.absent(); } if(!(part.get() instanceof NodeJoint)) { return Optional.absent(); } Node<?> node = ((NodeJoint)part.get()).getNode(); TRSRTransformation nodeTransform; if(progress < 1e-5 || frame == nextFrame) { nodeTransform = getNodeMatrix(node, frame); } else if(progress > 1 - 1e-5) { nodeTransform = getNodeMatrix(node, nextFrame); } else { nodeTransform = getNodeMatrix(node, frame); nodeTransform = nodeTransform.slerp(getNodeMatrix(node, nextFrame), progress); } if(parent != null && node.getParent() == null) { return Optional.of(parent.apply(part).or(TRSRTransformation.identity()).compose(nodeTransform)); } return Optional.of(nodeTransform); }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableMap<TransformType, TRSRTransformation> transformMap = PerspectiveMapWrapper.getTransforms(state); TRSRTransformation transform = state.apply(Optional.empty()).orElse(TRSRTransformation.identity()); TextureAtlasSprite widgetSprite = bakedTextureGetter.apply(getWidgetTexture(widget)); ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); int width = widget.getWidth() + (widget.getParameters() != null && widget.getParameters().length > 0 ? 10 : 0); int height = widget.getHeight() + (widget.hasStepOutput() ? 5 : 0); Pair<Double, Double> maxUV = widget.getMaxUV(); int textureSize = widget.getTextureSize(); float scale = 1F / (float) Math.max(maxUV.getLeft(), maxUV.getRight()); float transX = 0;//maxUV.getLeft().floatValue(); float transY = -1 + maxUV.getRight().floatValue(); transform = transform.compose(new TRSRTransformation(new Vector3f(0, 0, 0), null, new Vector3f(scale, scale, 1), null)); transform = transform.compose(new TRSRTransformation(new Vector3f(transX, transY, 0), null, new Vector3f(1, 1, 1), null)); builder.add(ItemTextureQuadConverter.genQuad(format, transform, 0, 0, 16 * maxUV.getLeft().floatValue(), 16 * maxUV.getRight().floatValue(), NORTH_Z_BASE, widgetSprite, EnumFacing.NORTH, 0xffffffff)); builder.add(ItemTextureQuadConverter.genQuad(format, transform, 0, 0, 16 * maxUV.getLeft().floatValue(), 16 * maxUV.getRight().floatValue(), SOUTH_Z_BASE, widgetSprite, EnumFacing.SOUTH, 0xffffffff)); return new BakedProgrammingPuzzle(this, builder.build(), widgetSprite, format, Maps.immutableEnumMap(transformMap), Maps.newHashMap()); }
@Override public Pair<? extends IBakedModel, Matrix4f> handlePerspective(TransformType cameraTransformType) { if (baseKnowledgeBookModel instanceof IPerspectiveAwareModel) { Matrix4f matrix4f = ((IPerspectiveAwareModel) baseKnowledgeBookModel).handlePerspective(cameraTransformType) .getRight(); return Pair.of(this, matrix4f); } ItemCameraTransforms itemCameraTransforms = baseKnowledgeBookModel.getItemCameraTransforms(); ItemTransformVec3f itemTransformVec3f = itemCameraTransforms.getTransform(cameraTransformType); TRSRTransformation tr = new TRSRTransformation(itemTransformVec3f); Matrix4f mat = null; if (tr != null) { mat = tr.getMatrix(); } return Pair.of(this, mat); }
@Override public Pair<? extends IBakedModel, Matrix4f> handlePerspective(TransformType cameraTransformType) { if (parentModel instanceof IPerspectiveAwareModel) { Matrix4f matrix4f = ((IPerspectiveAwareModel) parentModel).handlePerspective(cameraTransformType) .getRight(); return Pair.of(this, matrix4f); } ItemCameraTransforms itemCameraTransforms = parentModel.getItemCameraTransforms(); ItemTransformVec3f itemTransformVec3f = itemCameraTransforms.getTransform(cameraTransformType); TRSRTransformation tr = new TRSRTransformation(itemTransformVec3f); Matrix4f mat = null; if (tr != null) { mat = tr.getMatrix(); } return Pair.of(this, mat); }
public MultiLayerBakedModel(ImmutableMap<Optional<BlockRenderLayer>, IBakedModel> models, IBakedModel missing, ImmutableMap<TransformType, TRSRTransformation> cameraTransforms) { this.models = models; this.cameraTransforms = cameraTransforms; this.missing = missing; if(models.containsKey(Optional.absent())) { base = models.get(Optional.absent()); } else { base = missing; } ImmutableMap.Builder<Optional<EnumFacing>, ImmutableList<BakedQuad>> quadBuilder = ImmutableMap.builder(); quadBuilder.put(Optional.<EnumFacing>absent(), buildQuads(models, Optional.<EnumFacing>absent())); for(EnumFacing side: EnumFacing.values()) { quadBuilder.put(Optional.of(side), buildQuads(models, Optional.of(side))); } quads = quadBuilder.build(); }
private static final BakedQuad buildQuad( VertexFormat format, Optional<TRSRTransformation> transform, EnumFacing side, TextureAtlasSprite sprite, int tint, float x0, float y0, float z0, float u0, float v0, float x1, float y1, float z1, float u1, float v1, float x2, float y2, float z2, float u2, float v2, float x3, float y3, float z3, float u3, float v3) { UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format); builder.setQuadTint(tint); builder.setQuadOrientation(side); builder.setTexture(sprite); putVertex(builder, format, transform, side, x0, y0, z0, u0, v0); putVertex(builder, format, transform, side, x1, y1, z1, u1, v1); putVertex(builder, format, transform, side, x2, y2, z2, u2, v2); putVertex(builder, format, transform, side, x3, y3, z3, u3, v3); return builder.build(); }
@SuppressWarnings("deprecation") public static Matrix4f getMatrix(net.minecraft.client.renderer.block.model.ItemTransformVec3f transform) { javax.vecmath.Matrix4f m = new javax.vecmath.Matrix4f(), t = new javax.vecmath.Matrix4f(); m.setIdentity(); m.setTranslation(TRSRTransformation.toVecmath(transform.translation)); t.setIdentity(); t.rotY(transform.rotation.y); m.mul(t); t.setIdentity(); t.rotX(transform.rotation.x); m.mul(t); t.setIdentity(); t.rotZ(transform.rotation.z); m.mul(t); t.setIdentity(); t.m00 = transform.scale.x; t.m11 = transform.scale.y; t.m22 = transform.scale.z; m.mul(t); return m; }
/** * IModelState wrapper for a Clip, sampled at specified time. */ public static Pair<IModelState, Iterable<Event>> apply(final IClip clip, final float lastPollTime, final float time) { return Pair.<IModelState, Iterable<Event>>of(new IModelState() { public Optional<TRSRTransformation> apply(Optional<? extends IModelPart> part) { if(!part.isPresent() || !(part.get() instanceof IJoint)) { return Optional.absent(); } IJoint joint = (IJoint)part.get(); // TODO: Cache clip application? TRSRTransformation jointTransform = clip.apply(joint).apply(time).compose(joint.getInvBindPose()); Optional<? extends IJoint> parent = joint.getParent(); while(parent.isPresent()) { TRSRTransformation parentTransform = clip.apply(parent.get()).apply(time); jointTransform = parentTransform.compose(jointTransform); parent = parent.get().getParent(); } return Optional.of(jointTransform); } }, clip.pastEvents(lastPollTime, time)); }
public BakedItemModel(ImmutableList<BakedQuad> quads, TextureAtlasSprite particle, ImmutableMap<TransformType, TRSRTransformation> transforms, ItemOverrideList overrides, IBakedModel otherModel) { this.quads = quads; this.particle = particle; this.transforms = transforms; this.overrides = overrides; if(otherModel != null) { this.otherModel = otherModel; this.isCulled = true; } else { ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); for(BakedQuad quad : quads) { if(quad.getFace() == EnumFacing.SOUTH) { builder.add(quad); } } this.otherModel = new BakedItemModel(builder.build(), particle, transforms, overrides, this); isCulled = false; } }
private static UnpackedBakedQuad putQuad(VertexFormat format, TRSRTransformation transform, EnumFacing side, TextureAtlasSprite sprite, int color, float x1, float y1, float x2, float y2, float z, float u1, float v1, float u2, float v2) { side = side.getOpposite(); UnpackedBakedQuad.Builder builder = new UnpackedBakedQuad.Builder(format); builder.setQuadTint(-1); builder.setQuadOrientation(side); builder.setTexture(sprite); if (side == EnumFacing.NORTH) { putVertex(builder, format, transform, side, x1, y1, z, u1, v2, color); putVertex(builder, format, transform, side, x2, y1, z, u2, v2, color); putVertex(builder, format, transform, side, x2, y2, z, u2, v1, color); putVertex(builder, format, transform, side, x1, y2, z, u1, v1, color); } else { putVertex(builder, format, transform, side, x1, y1, z, u1, v2, color); putVertex(builder, format, transform, side, x1, y2, z, u1, v1, color); putVertex(builder, format, transform, side, x2, y2, z, u2, v1, color); putVertex(builder, format, transform, side, x2, y1, z, u2, v2, color); } return builder.build(); }
public LinkedHashSet<Face> applyTransform(Optional<TRSRTransformation> transform) { LinkedHashSet<Face> faceSet = new LinkedHashSet<Face>(); for (Face f : this.faces) { f.setTintIndex(getTintIndex()); // if (minUVBounds != null && maxUVBounds != null) f.normalizeUVs(minUVBounds, maxUVBounds); faceSet.add(f.bake(transform.orElse(TRSRTransformation.identity()))); } return faceSet; }
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 IBakedModel getModel(ResourceLocation resourceLocation) { IBakedModel bakedModel; IModel model; try { model = ModelLoaderRegistry.getModel(resourceLocation); } catch (Exception e) { throw new RuntimeException(e); } bakedModel = model.bake(TRSRTransformation.identity(), DefaultVertexFormats.BLOCK, location -> Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(location.toString())); return bakedModel; }
public static IBakedModel getBakedModel(String modelLocation){ IModel model; try { model = ModelLoaderRegistry.getModel(new ResourceLocation(RunicArcana.MOD_ID, modelLocation)); } catch (Exception e) { throw new RuntimeException(e); } IBakedModel bakedModel = model.bake(TRSRTransformation.identity(), DefaultVertexFormats.BLOCK, DustModelHandler::textureGetter); return bakedModel; }
@Override public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { IBakedModel[] connections = new IBakedModel[6]; IBakedModel[] endings = new IBakedModel[6]; IBakedModel[] nodeSides = new IBakedModel[6]; //IBakedModel node = null; // d u n s w e ModelRotation[] rotations = new ModelRotation[] { ModelRotation.X90_Y0, ModelRotation.X270_Y0, ModelRotation.X0_Y0, ModelRotation.X0_Y180, ModelRotation.X0_Y270, ModelRotation.X0_Y90 }; try { IModel nodeSideModel = ModelLoaderRegistry.getModel(new ResourceLocation(Etheric.MODID, "block/pipe_node_side")); IModel connectionModel = ModelLoaderRegistry .getModel(new ResourceLocation(Etheric.MODID, "block/pipe_connection")); IModel endingModel = ModelLoaderRegistry.getModel(new ResourceLocation(Etheric.MODID, "block/pipe_end")); //node = nodeModel.bake(new TRSRTransformation(ModelRotation.X0_Y0), DefaultVertexFormats.BLOCK, // ModelLoader.defaultTextureGetter()); for (int i = 0; i < connections.length; i++) { connections[i] = connectionModel.bake(new TRSRTransformation(rotations[i]), DefaultVertexFormats.BLOCK, ModelLoader.defaultTextureGetter()); endings[i] = endingModel.bake(new TRSRTransformation(rotations[i]), DefaultVertexFormats.BLOCK, ModelLoader.defaultTextureGetter()); nodeSides[i] = nodeSideModel.bake(new TRSRTransformation(rotations[i]), DefaultVertexFormats.BLOCK, ModelLoader.defaultTextureGetter()); } } catch (Exception e) { Etheric.logger.warn(e.getMessage()); } if (connections[0] == null) { return ModelLoaderRegistry.getMissingModel().bake(state, format, bakedTextureGetter); } return new BakedPipeModel(nodeSides, connections, endings); }
@SubscribeEvent public static void setupModels(ModelBakeEvent event) { try { lodestone_sliver = ModelLoaderRegistry.getModel(new ResourceLocation(Etheric.MODID, "item/lodestone_sliver")).bake(TRSRTransformation.identity(), DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter()); } catch (Exception e) { Etheric.logger.error("Error loading seeing stone submodel", e); lodestone_sliver = ModelLoaderRegistry.getMissingModel().bake(TRSRTransformation.identity(), DefaultVertexFormats.ITEM, ModelLoader.defaultTextureGetter()); } }
public Optional<TRSRTransformation> apply(Optional<? extends IModelPart> part) { if(!part.isPresent()) { return def; } if(!map.containsKey(part.get())) { return Optional.absent(); } return Optional.fromNullable(map.get(part.get())); }
private static void addSideQuad(ImmutableList.Builder<BakedQuad> builder, BitSet faces, VertexFormat format, Optional<TRSRTransformation> transform, EnumFacing side, int tint, TextureAtlasSprite sprite, int uMax, int vMax, int u, int v) { int si = side.ordinal(); if(si > 4) si -= 2; int index = (vMax + 1) * ((uMax + 1) * si + u) + v; if(!faces.get(index)) { faces.set(index); builder.add(buildSideQuad(format, transform, side, tint, sprite, u, v)); } }
public BakedToolModel(IModel 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; }
protected ImmutableMap<TransformType, TRSRTransformation> itemTransforms() { ImmutableMap.Builder<TransformType, TRSRTransformation> builder = ImmutableMap.builder(); builder.put(TransformType.GROUND, get(0 , 2, 0, 0, 0, 0, 0.5f)); builder.put(TransformType.HEAD, get(0, 13, 7, 0, 180, 0, 1)); builder.put(TransformType.FIXED, get(0, 0, 0, 0, 180, 0, 1)); builder.put(TransformType.THIRD_PERSON_RIGHT_HAND, get(0, 4, 0.5f, 0, -90, 55, 0.85f)); builder.put(TransformType.THIRD_PERSON_LEFT_HAND, get(0, 4, 0.5f, 0, 90, -55, 0.85f)); builder.put(TransformType.FIRST_PERSON_RIGHT_HAND, get(1.13f, 3.2f, 1.13f, 0, -90, 25, 0.68f)); builder.put(TransformType.FIRST_PERSON_LEFT_HAND, get(1.13f, 3.2f, 1.13f, 0, 90, -25, 0.68f)); return (ImmutableMap) builder.build(); }
@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 BakedMaceModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap), Maps.<String, IBakedModel>newHashMap()); }
@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 BakedHoeModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap), Maps.<String, IBakedModel>newHashMap()); }
public IBakedModel bake(IModelState state, final 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++) { BlockPart part = model.getElements().get(i); newTransforms.add(animation.getPartTransform(state, part, i)); } ItemCameraTransforms transforms = model.getAllTransforms(); 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 BuiltInModel(transforms, model.createOverrides()); return bakeNormal(model, perState, state, newTransforms, format, bakedTextureGetter, uvlock); }
@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 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 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 static ImmutableMap<TransformType, TRSRTransformation> itemTransforms() { ImmutableMap.Builder<TransformType, TRSRTransformation> builder = ImmutableMap.builder(); builder.put(TransformType.GROUND, get(0 , 2, 0, 0, 0, 0, 0.5f)); builder.put(TransformType.HEAD, get(0, 13, 7, 0, 180, 0, 1)); builder.put(TransformType.FIXED, get(0, 0, 0, 0, 180, 0, 1)); builder.put(TransformType.THIRD_PERSON_RIGHT_HAND, get(0, 4, 0.5f, 0, -90, 55, 0.85f)); builder.put(TransformType.THIRD_PERSON_LEFT_HAND, get(0, 4, 0.5f, 0, 90, -55, 0.85f)); builder.put(TransformType.FIRST_PERSON_RIGHT_HAND, get(1.13f, 3.2f, 1.13f, 0, -90, 25, 0.68f)); builder.put(TransformType.FIRST_PERSON_LEFT_HAND, get(1.13f, 3.2f, 1.13f, 0, 90, -25, 0.68f)); return (ImmutableMap) builder.build(); }
@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 BakedShovelModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap), Maps.<String, IBakedModel>newHashMap()); }
@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(); ImmutableList<ResourceLocation> textures = ImmutableList.<ResourceLocation>of(new ResourceLocation(modid, "items/" + toolName + "/" + partName + "_" + matName)); builder.addAll(new ItemLayerModel(textures).bake(state, format, bakedTextureGetter).getQuads(null, null, 0)); return new BakedToolHeadModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap), Maps.<String, IBakedModel>newHashMap()); }
private static ImmutableMap<TransformType, TRSRTransformation> itemTransforms() { ImmutableMap.Builder<TransformType, TRSRTransformation> builder = ImmutableMap.builder(); builder.put(TransformType.GROUND, get(0 , 2, 0, 0, 0, 0, 0.5f)); builder.put(TransformType.HEAD, get(0, 13, 7, 0, 180, 0, 1)); builder.put(TransformType.FIXED, get(0, 0, 0, 0, 180, 0, 1)); builder.put(TransformType.THIRD_PERSON_RIGHT_HAND, get(0, 3, 1, 0, 0, 0, 0.55f)); builder.put(TransformType.THIRD_PERSON_LEFT_HAND, leftify(get(0, 3, 1, 0, 0, 0, 0.55f))); builder.put(TransformType.FIRST_PERSON_RIGHT_HAND, get(1.13f, 3.2f, 1.13f, 0, -90, 25, 0.68f)); builder.put(TransformType.FIRST_PERSON_LEFT_HAND, leftify(get(1.13f, 3.2f, 1.13f, 0, -90, 25, 0.68f))); return (ImmutableMap) builder.build(); }
@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 (bladeTexture != null && crossguardTexture != null && handleTexture != null) { ImmutableList.Builder<ResourceLocation> texBuilder = ImmutableList.builder(); if (bladeTexture != null) { texBuilder.add(bladeTexture); } if (handleTexture != null) { texBuilder.add(handleTexture); } if (crossguardTexture != null) { texBuilder.add(crossguardTexture); } 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 BakedSwordModel(this, builder.build(), format, Maps.immutableEnumMap(transformMap), Maps.<String, IBakedModel>newHashMap()); }
public IBakedModel bake(IModelState state, final VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) { ImmutableList.Builder<BakedQuad> builder = ImmutableList.builder(); Optional<TRSRTransformation> transform = state.apply(Optional.<IModelPart>absent()); for(int i = 0; i < textures.size(); i++) { TextureAtlasSprite sprite = bakedTextureGetter.apply(textures.get(i)); builder.addAll(getQuadsForSprite(i, sprite, format, transform)); } TextureAtlasSprite particle = bakedTextureGetter.apply(textures.isEmpty() ? new ResourceLocation("missingno") : textures.get(0)); ImmutableMap<TransformType, TRSRTransformation> map = IPerspectiveAwareModel.MapWrapper.getTransforms(state); return new BakedItemModel(builder.build(), particle, map, overrides, null); }
public BakedModelInstrument(ImmutableList<BakedQuad> quads, TextureAtlasSprite particle, ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transforms, Instrument instrument, ResourceLocation instTx) { this.quads = quads; this.particle = particle; this.transforms = transforms; this.instrument = instrument; this.instTx = instTx; }
@Override public Pair<? extends IBakedModel, Matrix4f> handlePerspective(ItemCameraTransforms.TransformType type) { if(instrument != null) { HashMap<ItemCameraTransforms.TransformType, TRSRTransformation> map = new HashMap<>(); map.put(ItemCameraTransforms.TransformType.FIRST_PERSON_LEFT_HAND, new TRSRTransformation(new Vector3f(1F, 0F, 1F), TRSRTransformation.quatFromXYZDegrees(new Vector3f(0F, 180F, 0F)), new Vector3f(1F, 1F, 1F), new Quat4f())); map.put(ItemCameraTransforms.TransformType.THIRD_PERSON_LEFT_HAND, new TRSRTransformation(new Vector3f(0.1F, 0F + (instrument.handImg.getHeight() <= 16F ? 0F : MathHelper.clamp((float)instrument.info.activeHandPosition[1], -0.3F, 0.3F)), 0.025F - (instrument.handImg.getWidth() <= 16F ? 0F : MathHelper.clamp((float)instrument.info.activeHandPosition[0], -0.5F, 0.5F))), TRSRTransformation.quatFromXYZDegrees(new Vector3f(0F, 80F, 0F)), new Vector3f(-1F, 1F, 1F), TRSRTransformation.quatFromXYZDegrees(new Vector3f(0F, 0F, 0F)))); map.put(ItemCameraTransforms.TransformType.THIRD_PERSON_RIGHT_HAND, new TRSRTransformation(new Vector3f(-0.1F, 0F + (instrument.handImg.getHeight() <= 16F ? 0F : MathHelper.clamp((float)instrument.info.activeHandPosition[1], -0.3F, 0.3F)), 1F - (instrument.handImg.getWidth() <= 16F ? 0F : MathHelper.clamp((float)instrument.info.activeHandPosition[0], -0.5F, 0.5F))), TRSRTransformation.quatFromXYZDegrees(new Vector3f(0F, 80F, 0F)), new Vector3f(1F, 1F, 1F), TRSRTransformation.quatFromXYZDegrees(new Vector3f(0F, 0F, 0F)))); ImmutableMap<ItemCameraTransforms.TransformType, TRSRTransformation> transforms = ImmutableMap.copyOf(map); return PerspectiveMapWrapper.handlePerspective(ModelBaseWrapper.isEntityRender(type) ? instrument.handModel : instrument.iconModel, transforms, type); } return PerspectiveMapWrapper.handlePerspective(this, transforms, type); }
@Override public TRSRTransformation applyTransfomation(TransformType type) { switch (type) { case FIRST_PERSON_LEFT_HAND: ModelTransform transLeftHand = new ModelTransform(); transLeftHand.setPosition(0F, -0.05F, 0F); transLeftHand.setScale(0.6F); return transLeftHand.toGuiTranaformation(); case FIRST_PERSON_RIGHT_HAND: ModelTransform transRightHand = new ModelTransform(); transRightHand.setPosition(0F, -0.05F, 0F); transRightHand.setScale(0.6F); return transRightHand.toGuiTranaformation(); case GROUND: ModelTransform transGround = new ModelTransform(); transGround.setScale(0.45F); return transGround.toGuiTranaformation(); case GUI: ModelTransform transGui = new ModelTransform(); transGui.setRotation(30F, 45F, 0); transGui.setScale(0.75F); return transGui.toGuiTranaformation(); case THIRD_PERSON_LEFT_HAND: ModelTransform transThirdLeftHand = new ModelTransform(); transThirdLeftHand.setPosition(0F, -0.05F, 0F); transThirdLeftHand.setScale(0.45F); return transThirdLeftHand.toGuiTranaformation(); case THIRD_PERSON_RIGHT_HAND: ModelTransform transThirdRightHand = new ModelTransform(); transThirdRightHand.setPosition(0F, -0.05F, 0F); transThirdRightHand.setScale(0.45F); return transThirdRightHand.toGuiTranaformation(); default: return null; } }
public TRSRTransformation apply(float time) { TRSRTransformation ret = TRSRTransformation.identity(); if(node.getAnimation() == null) { return ret.compose(new TRSRTransformation(node.getPos(), node.getRot(), node.getScale(), null)); } int start = Math.max(1, (int)Math.round(Math.floor(time))); int end = Math.min(start + 1, (int)Math.round(Math.ceil(time))); float progress = time - (float)Math.floor(time); Key keyStart = node.getAnimation().getKeys().get(start, node); Key keyEnd = node.getAnimation().getKeys().get(end, node); TRSRTransformation startTr = keyStart == null ? null : new TRSRTransformation(keyStart.getPos(), keyStart.getRot(),keyStart.getScale(), null); TRSRTransformation endTr = keyEnd == null ? null : new TRSRTransformation(keyEnd.getPos(), keyEnd.getRot(),keyEnd.getScale(), null); if(keyStart == null) { if(keyEnd == null) { ret = ret.compose(new TRSRTransformation(node.getPos(), node.getRot(), node.getScale(), null)); } // TODO animated TRSRTransformation for speed? else { ret = ret.compose(endTr); } } else if(progress < 1e-5 || keyEnd == null) { ret = ret.compose(startTr); } else { ret = ret.compose(startTr.slerp(endTr, progress)); } return ret; }
public static Matrix4f getMatrix(ModelRotation modelRotation) { Matrix4f ret = new Matrix4f(TRSRTransformation.toVecmath(modelRotation.getMatrix4d())), tmp = new Matrix4f(); tmp.setIdentity(); tmp.m03 = tmp.m13 = tmp.m23 = .5f; ret.mul(tmp, ret); tmp.invert(); //tmp.m03 = tmp.m13 = tmp.m23 = -.5f; ret.mul(tmp); return ret; }
public Optional<TRSRTransformation> apply(Optional<? extends IModelPart> part) { Optional<TRSRTransformation> normal = state.apply(part); Optional<TRSRTransformation> multi = state.apply(Optional.of(new PartPart(model, index, part))); if(normal.isPresent() && multi.isPresent()) { return Optional.of(normal.get().compose(multi.get())); } return normal.or(multi); }
public MBJoint(String name, BlockPart part) { this.name = name; if(part.partRotation != null) { float x = 0, y = 0, z = 0; switch(part.partRotation.axis) { case X: x = 1; case Y: y = 1; case Z: z = 1; } Quat4f rotation = new Quat4f(); rotation.set(new AxisAngle4f(x, y, z, 0)); Matrix4f m = new TRSRTransformation( TRSRTransformation.toVecmath(part.partRotation.origin), rotation, null, null).getMatrix(); m.invert(); invBindPose = new TRSRTransformation(m); } else { invBindPose = TRSRTransformation.identity(); } }
public TRSRTransformation getPartTransform(IModelState state, BlockPart part, int i) { ImmutableCollection<MBJointWeight> infos = getJoint(i); if(!infos.isEmpty()) { Matrix4f m = new Matrix4f(), tmp; float weight = 0; for(MBJointWeight info : infos) { if(info.getWeights().containsKey(i)) { ModelBlockAnimation.MBJoint joint = new ModelBlockAnimation.MBJoint(info.getName(), part); Optional<TRSRTransformation> trOp = state.apply(Optional.of(joint)); if(trOp.isPresent() && trOp.get() != TRSRTransformation.identity()) { float w = info.getWeights().get(i)[0]; tmp = trOp.get().getMatrix(); tmp.mul(w); m.add(tmp); weight += w; } } } if(weight > 1e-5) { m.mul(1f / weight); return new TRSRTransformation(m); } } return null; }