1.0.0-RC3

Make version semvar compliant
Removes warning log from startup

Init emptiness map lazily if needed
Fixes #56

Fix large fill commands breaking light (Vanilla)
Vanilla didn't tell the client to recalculate the edges of the
light it checked, and nor did it even tell the client
to perform the light updates. So of course it broke on chunk edges.

Fix is to simply send the neighbouring light data as well.

Fixes #71

Relocate save/load hooks into their own class
This will make compatibility with starlight better in the future for
mods that mess around with chunk NBT.

There is no forge version for 1.17 yet, so there is no RC3 for forge. No, I will not backport RC3 to 1.16.

1.0.0-RC2

Technical details document
Can be read here: https://github.com/Spottedleaf/Starlight/blob/fabric/TECHNICAL_DETAILS.md
Please note that document is intended for programmers.

Correctly decrease light when block data section is de-initialised
Fixes broken lighting on empty chunk edges when a neighbouring section becomes empty
by removing a source block. It was a rare issue, so it was never reported to me - I found it by
accident.

Handle concurrent chunk generation and lighting better
Thanks to the top tier chunk system, chunk generation
and lighting can occur at the same time. To fix this,
I've adjusted the code to handle concurrent updates
after the chunk is lit, similar to how Vanilla would have handled
it.

Update README to include new benchmarks and other revisions
Please note that these new benchmarks are taken on a newer CPU than
the one I used for the old benchmarks. So do not compare the new ones
and the old ones, you cannot compare benchmarks running entirely different hardware.

1.0.0-RC1

The attached assests have the builds. Fabric is labeled fabric, forge is labeled forge, and the jar for 1.17 snapshots is labeled according to the version the jar was built against (i.e 21w11a). Snapshot builds are only available for fabric, since forge does not do snapshots.

Completely rewrite how lighting is loaded in for clients
Attempts to fix #25 and #40
The old hook was vulnerable to mods doing unexpected things, especially
serverside. The old method also relied on unreliable ordering of events
inside packet handling. New method just hooks directly into the
packet handling methods to avoid conflicting behavior with mods and
to create more reliable hooks.

Completely rewrites internal scheduling of light tasks
This is the fix for chunk loading breaking while under
high block update stress. I know there was an earlier commit,
but hindsight is telling me that commit really didn't do anything.
However the complete rewrite of the internal scheduling will
fix the problem.
Old scheduling was very vulnerable to block updates completely
overloading everything. The old scheduling was also incapable of
indicating to the chunk system whether block updates or other
light modifying tasks were pending for a chunk. The new
scheduling now groups tasks by chunk (light update, needs lighting,
edge checks) and simply drains tasks by chunks. In the event
that there are a lot of block updates, they no longer pile up
in a queue since they are just grouped onto their chunk, which
will eliminate duplicate updates. And since it's a FIFO by chunk,
the maximum latency for a light update to happen is simply the
number of chunks queued. The new queue also tells the chunk
system to not unload chunks until any lighting task is fully complete
for that chunk and its 1 radius neighbours. This will eliminate
problems where the light engine was never able to complete tasks
before server shutdown. This also officially kills light suppression.
Before you ask, no I'm not going to re-add lighting bugs to my light
engine. I want lighting to work, which means I need to fix it when
it clearly doesn't work.

Mark the vanilla light engine fields in LevelLightEngine as null
This will break any mod expecting them to be non-null. But since
we replace the light engine, it's better this way since it forces
an explicit break rather than a silent break.

Initialise block nibbles in 1 radius of non-empty chunks
While vanilla is perfectly capable of handling null nibbles
in these cases, some protocol hacks might not expect this behavior.

I've taken an approach to mod conflicts that there's really nothing
I can do about it since I rewrite the light engine. Reporting them is still
useful for other people to track what is and isn't working however. Sometimes
I can do things about them, but I wont lose sleep if I can't.

Most of the remaining problems I see are with mod conflicts. Can't really do anything about them,
so they're not going to block full release.
There do appear to be some problems with how the client is receiving light data, and hopefully
the fixes in 1.0.0-RC1 fix those issues.

0.0.3

Move to edge checks for loading and generating light

While it might appear at first glance that the vanilla
chunk system makes a guarantee that 1 radius chunks are
loaded for lighting, this isn't actually the case. In fact,
no chunks could be loaded! And yet, the light function is
actually required to be completed still! The only way
we can do this is with edge checks.

In the 1.17 snapshots, it looks like chunk loading doesn't
load 1 radius chunks - which means our logic to require 1 radius
just has to go. In order to ensure that this new behavior
doesn't cause lighting problems on chunk edges, chunk loading
now does edge checks.

This fixes some rare light engine crashes.

1.17 snapshot version
1.17 should work just fine, the amount of changes required to update were basically minimal.

Please note when testing 1.17 that the maximum world difference from top to bottom is 512 blocks - there are technical problems in the vanilla snapshots preventing a larger difference from being used, and attempting to do so will result in totally broken clientside chunk loading.
No longer relevant for latest snapshots!

0.0.2

• Significantly reduce memory overhead

• Rewrite nibble initit
  This fixes all of the known issues around nibble init

• Fix save hook not firing
  Now we will no longer be relighting all of the chunks that we saved

0.0.2-rc3

1. Fix chunk relighting
   In order to make relighting more reliable, move the
   emptiness map lookups to their own cache. This allows us
   to not clobber/use emptiness map values for chunks that were
   not relight during the call.
   More importantly, fix a typo where we supplied the wrong chunk
   argument to the emptiness change function for chunk neighbours -
   this caused the nibbles for the target chunk to be clobbered.

2. Fix broken edge checks
   While edge checks are not currently used, it doesn't mean
   they should be broken. Edge checks should be able to happen
   on null nibbles for block lighting (sky lighting will not have
   nibbles marked null during edge checks).

3. Make handleEmptySectionChanges non-relaxed serverside
   For the server, it should be that the chunks in 1 radius are
   loaded during this call.

4. Fix incorrect neighbour nibble init logic
   We need to be copying the whole array, not just
   the first 9 values.

5. Fix potential missed updateVisible calls
   rewriteNibbleCacheForSkylight could set a value
   in the cache to null and not update the nibble.
   Now the call will call updateVisible when
   removing nibbles from the cache.

6. Fix skylight propagation on the -1 chunk section
   Allow sources to be set up on y=-16, and fix light
   retrieval for y < -16

0.0.2-rc2

1. Finish mixin cleanup
   No longer screw around with serverside scheduling, should
   improve compatibility with mods that like to do that.

Add at-reason to at-Overwrites

Move client mixins to own package

2. Re-schedule block changes to the main thread
   Fixes #6

3. Fix typo for serialized data (versiom -> version)

4. Clean up skylight propagation code
   Delaying the block sets is now a parameter in the general
   propagate method, and move the delay logic to no longer use a flag
   but to rather call a method later.

So far 0.0.2 looks good, will probably go on CF in the coming
weeks (provided there are no severe issues).

0.0.2-rc1

Full text: 02e6333
Optimise chunk sky generation
TLDR optimised a bit.

New system for managing skylight
TLDR skylight system more similar to vanilla, so we now scale a lot better with respect to world height (and are ready for 1.17 levels of worldheight!). Format is incompatible with vanilla, so we force vanilla to relight starlight's chunks.

Cleanup some of the mixins
TLDR just general code cleanup.

Fix propagation & render issues
Skylight generation was broken when blocks were on the
y-border for the highest non-empty chunk section. This
has since been fixed.
Not queueing neighbour chunksections to be re-rendered
in some edge cases has since been fixed.

Fix some mod compatibility issues
Apparently some mods create instances of the lighting
provider with a null world. Allow null worlds.
Some problems still exist, as I think some mods are being
naughty and calling setBlockState off of the main thread.
Tuinity's changes will need to be ported to fix this.

If 0.0.2 proves to be without issue, it can go on curseforge.

0.0.1

First beta release of the engine. Please note that since this is a beta, there could be some severe light corrupting issues.

Known issues:

• The Starlight fabric mod, unlike the Tuinity implementation does not have general improvements around the chunk system and shape math that Tuinity/Paper has, which need to be ported. This means the fabric mod might not live up to the performance of the generation results, as those were obtained on the Tuinity Starlight implementation. Notably, lighting snowy areas is notably worse on the fabric mod compared to the Tuinity implementation.

• There are lighting issues on the client that have yet to be resolved