I am currently creating dozens (potentially 100+) different animations for the player's hand in first person view, and to make it easier on myself I have a system that lets me parse .json files for expressions, in a form like this:

 

{
	"transform":[
		{"translation":["__i * 0.56 - __swing_ratio * 1.75 + 0.9","-0.38", "-0.52"]},
		{"rotation":["0.0","90.0","0.0"]},
		{"rotation":["0.0","0.0","-90.0"]},
		{"rotation":["-25.0 + 25.0 * Math.cos(__swing_ratio * __swing_ratio * Math.PI)","0.0","0.0"]}
	]
}

 

these get read into a list of an HandTransformation class where type is the type of transformation.

 

public class HandTransformation
{
    public String type;
    public String[] transformation = new String[3];
}

 

At runtime, this method is called which evaluates the expression in the .json via a JS ScriptEngine, and does the appropriate transformations to the MatrixStacks object from the RenderHand event:

	matrixStack.clear();
        matrixStack.push();
        for (ItemTransformation itemTransformation:action.getTransformations())
        {
            String type = itemTransformation.type;
            Vector3f transform = getVector(itemTransformation, side, swingRatio, equippedRatio);

            if (type.equals("translation"))
            {
                matrixStack.translate(transform.getX(), transform.getY(), transform.getZ());
            }
            else if (type.equals("rotation"))
            {
                matrixStack.rotate(Vector3f.XP.rotationDegrees(transform.getX()));
                matrixStack.rotate(Vector3f.YP.rotationDegrees(transform.getY()));
                matrixStack.rotate(Vector3f.ZP.rotationDegrees(transform.getZ()));
            }
        }
        Minecraft.getInstance().getFirstPersonRenderer().renderItemSide(Minecraft.getInstance().player, itemStack, rightHanded ? ItemCameraTransforms.TransformType.FIRST_PERSON_RIGHT_HAND : ItemCameraTransforms.TransformType.FIRST_PERSON_LEFT_HAND, !rightHanded, matrixStack, buffer,light);
        matrixStack.pop();

    private Vector3f getVector(ItemTransformation itemTransformation, float side, float swingRatio, float equippedRatio)
    {
        String[] transformation = itemTransformation.transformation;
        String sideString = Float.toString(side);
        String swingRatioString = Float.toString(swingRatio);
        String equppedRatioString = Float.toString(equippedRatio);

        Vector3f transforms = new Vector3f();
        for (int i = 0; i < 3; i++)
        {
            String expression = transformation[i];
            expression.replaceAll("__i", sideString);
            expression.replaceAll("__swing_ratio", swingRatioString);
            expression.replaceAll("__equip_ratio", equppedRatioString);

            float result = evaluateScript(expression);

            switch(i)
            {
                case 0:
                    transforms.setX(result);
                    break;
                case 1:
                    transforms.setY(result);
                    break;
                default:
                    transforms.setZ(result);
            }
        }
        return transforms;
    }
    public float evaluateScript(String expression)
    {
        float result = 0.0f;
        ScriptEngineManager factory = new ScriptEngineManager();
        ScriptEngine engine = factory.getEngineByName("JavaScript");
        try
        {
            Object obj = engine.eval(expression);
            result = Float.parseFloat(obj.toString());
        }
        catch(ScriptException e)
        {
            e.printStackTrace();
        }
        return result;
    }

This all works, but as expected it cripples the framerate whenever it runs due to ScriptEngine. So, the next best thing is to apply the transformations to my own MatrixStacks object at initialization, for when I need them during gameplay.

 

Can I simply create my own MatrixStacks object at initialization (outside of the render event call) and not use the one provided by the event call? Or does it work more like the old GLStateManager and just wouldn't work?

 

Or better yet, is there an equally robust alternative to the JS script engine for evaluating mathematical expressions at runtime?

Edited November 29, 20204 yr by Turtledove

Solved my own problem, I ended up using a parser rather than the ScriptEngine, which I should've done from the beginning.