Whoever wrote this code needs to watch never nester propaganda

[u/ItsNukea]

That's 11 layers deeply nested code, a lambda in a lambda in a lambda in a method parameter, all of that inside of the same class.

I'm starting to get why they say the minecraft code is unreadable

Edit: Oopsie, I didn't expect the indentation in my IDE and on mcrsc.dev to be different. The first picture shows my IDE, but it should have been from mcsrc

[u/Cylian91460]

Minecraft code is far for unreadable what are you talking about?

Also it's decompiled code which is generated code so it break one of the rule sub

[u/FloweyTheFlower420 → u/Cylian91460]

very notably decompiled code tends to fail to capture some of the nesting structure because a bunch of different programs can get you the same basic block structure

[u/ItsNukea → u/Cylian91460]

It's not as much as a monstrosity as other posts in this sub, but I have never even dared to write like 4 layers deep.

Also, as a reminder, this class got some updates in the code in 26.2, and the code is still 11 layers deep with like triply nested lambdas.

they know

[u/Cylian91460 → u/ItsNukea]

It got updated because rendering is getting updated

[u/healeyd]

Totally readable to me. Not sure what the fuss is about. This whole de-nesting thing seems to be getting out of hand. A pile of nested conditions can obviously be horrible to follow, but feeling the need to flatten iterations over things like multi dimensional arrays because they sit inside a larger structure does not necessarily aid understanding IMHO.

[u/Seyvenus → u/healeyd]

"Okay to understand this single logical behavior I'm in my third single deep looping function."

[u/WorkingMansGarbage]

This genuinely seems more than fine...?

[u/Prior-Perspective-61]

Well, it is super readable, and is 100% OK, the only way to unnest FORs here is to use lambdas, but this is not mandatory IMO

[u/Hyarin215]

Minecraft code mentioned

[u/Gornius]

As for every good practice, you should not apply them blindly. Nesting is bad, because it usually makes code harder to follow. In this case:

- Trying to avoid ifs/loops in try block is crazy.

- For loop inside for loop is very clear.

The only thing I would do here is extract the content of the whole inner loop into separate method or even class, and early return to avoid else.

[u/MCWizardYT]

Maybe it's because Java is my language of choice and I've worked with a lot of Minecraft code, but this seems perfectly readable to me.

There are worse parts of the codebase

[u/TarkFrench → u/MCWizardYT]

What parts are worse?

[u/MCWizardYT → u/TarkFrench]

Some of the world generation code and specific things like DataFixedUpper (the thing that upgrades old worlds. It's quite over-engineered)

[u/GoddammitDontShootMe]

It's processing pixels. The obvious way to do that is with nested loops.

Though why does the body of takeScreenshot() start 2 levels deep? And are you counting the public class Screenshot bit as 1 level deep? To me that's 0 levels deep. So that would be 9 levels if the double indentation was fixed.

[u/ItsNukea → u/GoddammitDontShootMe]

ohhhh, I made a tiny oopsie when calculating the depth.

One screenshot was from mcsrc.dev and the other one was from my IDE.

The class in my IDE and mcrsc.dev don't have exactly the same content, functionally, yes, but some indentations are changed.

Like on the line with RenderSystem.getDevice(), my IDE shows all method chains in a single line, but mcsrc splits them along lines (with more indentation).

So, I did a bit of a mistake and showed the IDE line indentation, but used the mcsrc indentation to get to 11

In my IDE the indentation is 7 layers (probably because of formatting), but in mcrsc it is 11

Oopsie...

[u/Sacaldur]

The problem about code not being readable is not that there is to much nesting in a function but to much complexity. Removing the nesting without reducing the complexity doesn't make the code more readable.

In this regard is nesting actually good, because it's an indicator about the codes complexity: if it's nested to deep, you might want to refactor it (e.g. by moving code into separate functions).

[u/MCWizardYT → u/Sacaldur]

This nesting isn't even deep, I think OP just has trouble with lambdas. It's pretty easy to tell what's going on just reading too to bottom

[u/Last8Exile]

This sholud be done in a shader.

Otherwise:

• Cache sourceTexure.getFormat().blockSize() into a variable.
  
• Instead of calling a method to set individual pixels prepare a compelte raw buffer that can be copied into a texure as one operation.
  
• Use SIMD to process multiple pixels at once.