Question Minecraft — OpenGL Chams and Entity Texture Swapping via GlHook

[byte_corvus]

Dealing with the Minecraft render pipeline without touching the JVM is a classic challenge for anyone trying to stay engine-independent. The goal here is simple: implement chams or texture swaps for players and entities strictly through OpenGL hooks. If you're trying to avoid JNI hooks to stay under the radar or just prefer working at the driver level, you've likely hit the same wall many of us have.

The Graphics Hook Analysis
The original intent was to monitor the standard suspects: glBegin, glTexImage2D, glBindTexture, glArrayElement, glDrawArrays, and glDrawElements. While these are the bread and butter of GL rendering, they are extremely noisy in a game like Minecraft where every block, item, and particle is fighting for draw calls.

Spoiler: Technical Breakdown of the Function Calls

1. glTexImage2D — This is generally for texture allocation/loading. You won't find the active entity frames here; it's too early in the pipe.
2. glBindTexture — This is where the magic happens, but you'll see thousands of calls. Filtering for player skins requires identifying the specific texture ID or the dimensions (players usually have unique texture ratios).
3. glDrawElements / glDrawArrays — This is the actual draw strike. For chams, you need to disable the depth test right before the entity call and re-enable it immediately after.

Why You Can't Find Entity Textures
Minecraft's rendering logic depends heavily on the version. In older versions (Legacy/1.8.9), it's easier to find the fixed-function pipeline calls. In modern versions (1.17+), the game moves to Core Profile and utilizes shaders. If you aren't hooking glUseProgram or monitoring the vertex buffer objects (VBOs), you're looking at a black box.

Implementation Strategy
To effectively swap textures or inject chams colors:

1. Identify the entity draw call signature. Entities usually have a specific number of indices in glDrawElements that distinguish them from world terrain blocks.
2. Hook glBindTexture and log the IDs. You'll notice certain IDs are only bound when players are in the FOV.
3. For the actual "chams" effect, use a simple depth buffer manipulation:

// Simple Logic for Wallhack/Chams
void hooked_glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) {
    if (is_entity(count)) {
        glDepthFunc(GL_ALWAYS);
        // Optional: Change color or bind a flat texture here
        original_glDrawElements(mode, count, type, indices);
        glDepthFunc(GL_LEQUAL);
    } else {
        original_glDrawElements(mode, count, type, indices);
    }
}

Preventive Troubleshooting
If you're getting no hits on entity textures, it's likely because the game is batching them or using atlas textures. For modern MC, look into glUniform calls—this is where color/lighting data for entities often sits before the draw call is executed. Also, remember to disable Secure Boot and check your hook's impact on FPS, as high-frequency GL hooking can tank performance if your filtering logic isn't optimized.

Anyone here managed to isolate player skins in 1.20+ using strictly external GL hooks without a shader-based approach?