KubeJS GT Dynamic Render

Wouldn't you like to add cool rendering to GregTech CEu Modern? But that requires Java? Don't worry! This mod solves that.

We only support 1.20.1 Forge because that's where GTCEu is.

Example:

in startup_scripts:

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");
});

These obj files should be placed in /assets/kubejs/models.

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);
}