KubeJS GT Dynamic Render

GTRenderJSEvents.registerModelsForRender(event => {
    event.register("kubejs:obj/space");
    event.register("kubejs:obj/star");
    event.register("kubejs:obj/foo");
    event.register("kubejs:obj/bar");
    event.register("kubejs:obj/baz");
});

in startup_scripts (gregtech multiblockmachine registry)

// before
.workableCasingModel(
            "gtceu:block/casings/solid/machine_casing_stable_titanium",
            "gtceu:block/multiblock/implosion_compressor"
        );
// You will use this instead of that.
// after
.model(
            GTMachineModels.createWorkableCasingMachineModel(
                "gtceu:block/casings/solid/machine_casing_stable_titanium",
                 "gtceu:block/multiblock/implosion_compressor"
            )["andThen(java.util.function.Consumer)"](b =>
                b.addDynamicRenderer(() => KubeJSDynamicRender.of("kubejs:example"))
            )
        );

in client_scripts

const OverlayTexture = Java.loadClass("net.minecraft.client.renderer.texture.OverlayTexture");
const RenderType = Java.loadClass("net.minecraft.client.renderer.RenderType");
const LightTexture = Java.loadClass("net.minecraft.client.renderer.LightTexture");

GTRenderJSEvents.registerDynamicRender(event => {
    event.create(
        "kubejs:example",
        /**
         *@param {Internal.RenderBuilder<Internal.WorkableElectricMultiblockMachine,{ someValue:string }>} builder
         */
        builder => {
            // default: raw => raw
            // By using this API, you can utilize arguments with type safety and default values.
            // The result of this function is cached.
            builder.prepareBindings(raw => {
                return {
                    someValue: raw.someValue || "default value",
                };
            });

            builder.render(ctx => {
                // you can use bindings here
                console.log(ctx.binding.someValue);
                // const light = ctx.packedLight;
                // const overlay = ctx.packedOverlay;
                const machine = ctx.machine;
                const poseStack = ctx.poseStack;
                const buffer = ctx.buffer;
                var tick = machine.getOffsetTimer() + ctx.partialTick;
                // offsets
                var x = 0.5,
                    y = 0.5,
                    z = 0.5;
                switch (machine.getFrontFacing()) {
                    case Direction.NORTH:
                        z = 16.5;
                        break;
                    case Direction.SOUTH:
                        z = -15.5;
                        break;
                    case Direction.WEST:
                        x = 16.5;
                        break;
                    case Direction.EAST:
                        x = -15.5;
                        break;
                }
                poseStack.pushPose();
                poseStack.translate(x, y, z);
                renderOuterSpaceShell(poseStack, buffer.getBuffer(RenderType.solid()));
                poseStack.popPose();
            });
            const shouldRender = machine => machine.isFormed();

            builder
                .viewDistance(256)
                .shouldRender(shouldRender)
                .shouldRenderOffScreen(shouldRender)
                .renderBoundingBox(() => {
                    // todo ちゃんとやる
                    const rad = 32;
                    return AABB.of(-rad, -rad, -rad, rad, rad, rad);
                });
        }
    );
});
/**
 * @param {Internal.PoseStack} poseStack
 * @param {Internal.MultiBufferSource} buffer
 * @param {number} scale
 */
function renderOuterSpaceShell(poseStack, buffer) {
    const scale = 0.01 * 17.5;
    poseStack.pushPose();
    poseStack.scale(scale, scale, scale);
    const rt = RenderType.solid();
    BakedModelRenderer.renderModel(poseStack.last(), buffer.getBuffer(rt), getBakedModel("kubejs:obj/space"), rt);
    poseStack.popPose();
}

/**
 * @param {ResourceLocation_} id
 */
function getBakedModel(id) {
    // In the context of KubeJS, Client = Minecraft.getInstance()
    return Client.getModelManager().getModel(id);
}