Minecraft Forums

Quote from TheMasterCaver»

The reason is because every part of an entity requires a separate draw call and these are expensive; a chest requires that the game tell the GPU to render three separate pieces; a chicken has 8 separate pieces, and so on. Worse, the game needs to switch between textures, which is also expensive, when rendering an entity and its shadow, as well as any equipment it has (the game stitches all block textures into a single texture atlas precisely because each draw call can only reference one texture at a time).

To illustrate just how different block and entity rendering is, all blocks can be rendered in as little as 3 draw calls (at least in 1.6.4, when Fancy graphics, or translucent blocks/water are enabled; Fast graphics only requires 2 draw calls, plus a handful of OpenGL state changes):

This code mostly decides if a chunk section is to be rendered and adds it to a list, when is then sent to the GPU to be render everything on screen - using just one draw call (glCallLists) and three OpenGL calls in total (glTranslatef, all at the end of the method). Translucent blocks are similar except they have an additional draw call to render a "mask" which is used to eliminate graphical artifacts like those described by MC-38022 on Fancy graphics (the only issue is that you can't see translucent blocks behind other translucent blocks but that doesn't bother me anywhere near as much as the very obvious artifacts as described in the link, which are also less severe in 1.6.4):

private int renderSortedRenderers(int par1, int par2, double playerX, double playerY, double playerZ)
{
    if (!this.fastRender) return renderSortedRenderers_old(par1, par2, playerX, playerY, playerZ);
    this.glListBuffer.clear();
    int var6 = 0;
    boolean var7 = this.mc.gameSettings.showDebugInfo;
    int x = MathHelper.floor_double(playerX) - 8;
    int z = MathHelper.floor_double(playerZ) - 8;

    for (int var8 = par1; var8 < par2; ++var8)
    {
        ChunkRenderer var9 = this.sortedChunkRenderers[var8];

        if (var7)
        {
            if (var9.skipRenderPass0 && var9.skipRenderPass1)
            {
                ++this.renderersSkippingRenderPass;
            }
            else if (!var9.isInFrustum)
            {
                ++this.renderersBeingClipped;
            }
            else if (this.advancedOpengl && !var9.isVisible)
            {
                ++this.renderersBeingOccluded;
            }
            else
            {
                ++this.renderersBeingRendered;
            }
        }

        if (var9.isInFrustum && !var9.skipRenderPass0 && (!this.advancedOpengl || var9.isVisible))
        {
            if (var9.shouldRender(x, this.playerHeight, z, this.renderRadius1, this.renderRadius2))
            {
                int var10 = var9.getGLCallListForPass0();

                if (var10 >= 0)
                {
                    this.glListBuffer.put(var10);
                    ++var6;
                    if (var6 >= MAX_GL_LISTS) break;
                }
            }
            else if (var7)
            {
                ++this.renderersBeingOccluded;
                --this.renderersBeingRendered;
            }
        }
    }

    if (var6 > 0)
    {
        this.glListBuffer.flip();
        GL11.glTranslatef((float)(-playerX), (float)(-playerY), (float)(-playerZ));
        GL11.glCallLists(this.glListBuffer);
        GL11.glTranslatef((float)playerX, (float)playerY, (float)playerZ);
    }

    return var6;
}

By contrast, this is what the game calls to render every single piece of an entity - in the extreme case, horses have 39 pieces (and were likely simplified in part because of how demanding such a complex model is - one of the only times I experience a lag spike while playing is when a horse renders for the first time, due to the cost of constructing its model (it doesn't help that it combines multiple layers of textures), which isn't compiled until an entity is rendered for the first time):

public void render(float par1)
{
 if (!this.isHidden)
 {
 if (this.showModel)
 {
 if (!this.compiled)
 {
 this.compileDisplayList(par1);
 }

 GL11.glTranslatef(this.offsetX, this.offsetY, this.offsetZ);
 int var2;

 if (this.rotateAngleX == 0.0F && this.rotateAngleY == 0.0F && this.rotateAngleZ == 0.0F)
 {
 if (this.rotationPointX == 0.0F && this.rotationPointY == 0.0F && this.rotationPointZ == 0.0F)
 {
 GL11.glCallList(this.displayList);

 if (this.childModels != null)
 {
 for (var2 = 0; var2 < this.childModels.size(); ++var2)
 {
 ((ModelRenderer)this.childModels.get(var2)).render(par1);
 }
 }
 }
 else
 {
 GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1);
 GL11.glCallList(this.displayList);

 if (this.childModels != null)
 {
 for (var2 = 0; var2 < this.childModels.size(); ++var2)
 {
 ((ModelRenderer)this.childModels.get(var2)).render(par1);
 }
 }

 GL11.glTranslatef(-this.rotationPointX * par1, -this.rotationPointY * par1, -this.rotationPointZ * par1);
 }
 }
 else
 {
 GL11.glPushMatrix();
 GL11.glTranslatef(this.rotationPointX * par1, this.rotationPointY * par1, this.rotationPointZ * par1);

 if (this.rotateAngleZ != 0.0F)
 {
 GL11.glRotatef(this.rotateAngleZ * (180F / (float)Math.PI), 0.0F, 0.0F, 1.0F);
 }

 if (this.rotateAngleY != 0.0F)
 {
 GL11.glRotatef(this.rotateAngleY * (180F / (float)Math.PI), 0.0F, 1.0F, 0.0F);
 }

 if (this.rotateAngleX != 0.0F)
 {
 GL11.glRotatef(this.rotateAngleX * (180F / (float)Math.PI), 1.0F, 0.0F, 0.0F);
 }

 GL11.glCallList(this.displayList);

 if (this.childModels != null)
 {
 for (var2 = 0; var2 < this.childModels.size(); ++var2)
 {
 ((ModelRenderer)this.childModels.get(var2)).render(par1);
 }
 }

 GL11.glPopMatrix();
 }

 GL11.glTranslatef(-this.offsetX, -this.offsetY, -this.offsetZ);
 }
 }
}

As an illustration of just how costly entity rendering is, 100 chickens has a bigger impact on FPS than going from a default Superflat world, with only a few chunks in view, to a normal world at maximum (16 chunks) render distance, or even in a "mega forest" biome:

This is also why the game is fairly aggressive on entity culling; chickens only render up to 28 blocks away (the distance is based on their size) and the server doesn't send most entities to the client unless they are within 80 blocks (does the "entity distance" slider affect either of these?); in the last two examples above the client isn't rendering any entities despite there being around 400 loaded server-side and around 100 client-side (the "mob counts" is server-side while "E:" is client-side).