World marker rendering

JelloUI exposes reusable Jello world-space drawing styles (Sims plumbbob, box outline, skeleton, vanilla glowing outline) as stateless renderers that take caller-supplied data. The calling addon decides what to mark; JelloUI decides how to draw it.

The facade

io.github.sst.remake.api.render.world.JelloWorldMarkers is the stable entry point. It is static and requires no registration:

import io.github.sst.remake.api.render.world.JelloWorldMarkers;

JelloWorldMarkers.sims();
JelloWorldMarkers.boxOutline();
JelloWorldMarkers.skeleton();
JelloWorldMarkers.vanillaOutline();

The Sims, box and skeleton renderers draw immediately and restore the GL state they change when the call ends, including exceptional exits. VanillaOutlineRequest does not draw or manage GL state: it changes entity glowingTag flags and returns the affected entities so the caller can clear them later.

When you may draw

Invoke immediate-mode world markers from a public render listener registered for RenderPhase.WORLD_3D. Callers feed world-space coordinates or entities; the renderers translate into camera space themselves using the WorldRenderContext snapshot you supply.

Build a context from the live client on the render thread:

WorldRenderContext ctx = WorldRenderContext.current();
double camX = ctx.cameraPosition().x();
float tick = ctx.partialTick();

WorldRenderContext.current() validates that a level, a local player and an initialised camera state exist, and throws an IllegalStateException otherwise - catch it when you cannot guarantee an active world view.

Calling the markers

Sims (plumbbob diamond)

JelloWorldMarkers.sims().render(entity, ctx, alpha);              // from an Entity
JelloWorldMarkers.sims().render(x, y, z, tickCount, alpha, cam);  // explicit position

Alpha is in [0,1]. The marker bobs and rotates from the entity’s tick count, mirroring SimsESP.

Box outline

WorldMarkerColor color = WorldMarkerColor.of(0xFF3D7AFF);

JelloWorldMarkers.boxOutline().render(entity, ctx, color, alpha);
JelloWorldMarkers.boxOutline().renderWorldSpace(worldBox, cam, color, alpha);

The box renderer draws a translucent fill in the Jello accent plus a wire outline in the supplied color, through walls.

Skeleton

JelloWorldMarkers.skeleton().render((LivingEntity) entity, ctx, color, alpha,
        true /* csgoStyle articulation */);

Accepts any LivingEntity. Dead or sleeping entities are skipped silently.

Vanilla glowing outline

Vanilla’s glowing outline is rendered by the vanilla entity outline pass based on the glowingTag entity flag. JelloUI cannot draw it directly, so the API is a request:

VanillaOutlineRequest req = JelloWorldMarkers.vanillaOutline().requestBuilder()
        .add(entityA)
        .addAll(nearby)
        .build();
Set<Entity> tagged = req.apply();
// Before replacing this set on a later frame, or when disabling:
VanillaOutlineRequest.clear(tagged);   // null-safe, idempotent

You are responsible for clearing the glowing tag when you stop wanting the outline (typically each frame, or on disable). Failing to clear leaves stray glow on entities. Keep the applied set, clear it before applying the next frame’s set, and always clear it when the feature is disabled or the world changes.

The caller-owns-targets rule

The marker API never enumerates entities, never decides whether a target is a player, bot, friend, hostile or team, and never depends on a module being enabled. All of that is the calling addon’s job. A reusable marker renderer draws for any caller without knowing why it is drawn.

If you are porting ESP-style modules, your addon keeps the target filter and range logic; JelloUI only provides the drawing primitives. World-space markers are a JelloUI core feature and third-party addons reach them through JelloWorldMarkers.