everyone gets stars!

common/src/main/java/net/lerariemann/infinity/access/WorldRendererAccess.java

···
 package net.lerariemann.infinity.access;
 
 public interface WorldRendererAccess {
-    void projectInfinity$setNeedsStars(boolean b);
+    void infinity$setNeedsStars(boolean b);
 }

common/src/main/java/net/lerariemann/infinity/mixin/options/WorldRendererMixin.java

···
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Constant;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyConstant;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Environment(EnvType.CLIENT)
···
 
     @Shadow protected abstract boolean hasBlindnessOrDarkness(Camera camera);
 
-    @Shadow protected abstract void renderStars();
-
     @Shadow public abstract void render(RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightmapTextureManager lightmapTextureManager, Matrix4f matrix4f, Matrix4f matrix4f2);
 
     @Unique
     public boolean infinity$needsStars;
-
-    @Unique
-    public void infinity$testRerenderStars() {
-        if (infinity$needsStars) {
-            renderStars();
-            infinity$needsStars = false;
-        }
-    }
     @Override
-    public void projectInfinity$setNeedsStars(boolean b) {
+    public void infinity$setNeedsStars(boolean b) {
         infinity$needsStars = b;
     }
 
···
             ci.cancel();
         }
     }
-    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(intValue = 1500))
-    private int injected(int constant) {
-        return infinity$options().getNumStars();
-    }
-    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(floatValue = 0.15f))
-    private float injected2(float constant) {
-        return infinity$options().getStarSizeBase();
-    }
-    @ModifyConstant(method = "buildStarsBuffer(Lnet/minecraft/client/render/Tessellator;)Lnet/minecraft/client/render/BuiltBuffer;", constant = @Constant(floatValue = 0.1f))
-    private float injected3(float constant) {
-        return infinity$options().getStarSizeModifier();
-    }
 
     @Unique
     private void infinity$renderEntireSky(Matrix4f matrix4f, Matrix4f projectionMatrix, float tickDelta, Camera camera, boolean thickFog, Runnable fogCallback) {
···
                 matrices, tickDelta, projectionMatrix,
                 lightSkyBuffer, starsBuffer);
         if (renderer.testAndRenderNonOverworldySkies()) return;
-        infinity$testRerenderStars();
+        infinity$createStarsIfNeeded();
         renderer.setupOverworldySky();
         renderer.renderAllCelestialBodies(fogCallback);
         renderer.finish();
+    }
+
+    @Unique
+    public void infinity$createStarsIfNeeded() {
+        if (infinity$needsStars) {
+            if (this.starsBuffer != null) {
+                this.starsBuffer.close();
+            }
+            this.starsBuffer = new VertexBuffer(VertexBuffer.Usage.STATIC);
+            this.starsBuffer.bind();
+            this.starsBuffer.upload(SkyRenderer.buildStarsBuffer(Tessellator.getInstance(), infinity$options()));
+            VertexBuffer.unbind();
+            infinity$needsStars = false;
+        }
     }
 
     @Unique

common/src/main/java/net/lerariemann/infinity/options/InfinityOptions.java

···
     public static double test(NbtCompound data, String key, double def) {
         return data.contains(key, NbtElement.DOUBLE_TYPE) ? data.getDouble(key) : def;
     }
+    public static boolean test(NbtCompound data, String key, boolean def) {
+        return data.contains(key) ? data.getBoolean(key) : def;
+    }
 
     public boolean isEmpty() {
         return data.isEmpty();
···
     }
     public float getHorizonShadingRatio() {
         return test(data, "horizon_shading_ratio", 1.0f);
+    }
+    public boolean endSkyLike() {
+        return test(data, "end_sky_like", false);
+    }
+    public boolean hasDawn() {
+        return test(data, "dawn", !getSkyType().equals("rainbow"));
     }
 
     //sun
···
     public float getStellarVelocity() {
         return test(data, "stellar_velocity", 1.0f);
     }
+    public float getDayStarBrightness() {
+        return test(data, "star_brightness_day", 0.0f);
+    }
+    public float getNightStarBrightness() {
+        return test(data, "star_brightness_night", 0.5f);
+    }
     public Vector3f getStellarColor() {
         int color = test(data, "stellar_color",16777215);
         return new Vector3f((float)(color >> 16 & 0xFF) / 255.0f, (float)(color >> 8 & 0xFF) / 255.0f, (float)(color & 0xFF) / 255.0f);
···
     }
     public float getLunarOffset(int i) {
         return fullLunarTest("lunar_offset", i, 0.0f);
-    }
-
-    //skybox
-    public boolean endSkyLike() {
-        return data.contains("end_sky_like") && data.getBoolean("end_sky_like");
     }
 }

common/src/main/java/net/lerariemann/infinity/options/RandomInfinityOptions.java

···
         data.putFloat("stellar_velocity", (float)(r.nextDouble() * 4 - 2));
         data.putFloat("stellar_tilt_y", (float)(r.nextDouble() * 180 - 90));
         data.putFloat("stellar_tilt_z", (float)(r.nextDouble() * 180 - 90));
+        float a = r.nextFloat();
+        float b = r.nextFloat();
+        data.putFloat("star_brightness_day", Math.min(a, b));
+        data.putFloat("star_brightness_night", Math.max(a, b));
         //other stuff
         data.putDouble("time_scale", timeScale(r));
         data.putDouble("mavity", prov.roll(r, "use_mavity") ? mavity(r) : 1.0);

common/src/main/java/net/lerariemann/infinity/options/SkyRenderer.java

···
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.RotationAxis;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.random.Random;
 import org.joml.Matrix4f;
+import org.joml.Quaternionf;
 import org.joml.Vector3f;
 
 import java.awt.*;
···
     public void renderRainbowBackground() {
         float main = world.getSkyAngle(tickDelta) * 2;
         int color = Color.getHSBColor(main - (int)main, 1.0f, 1.0f).getRGB();
-        float f = MathHelper.clamp(MathHelper.cos(world.getSkyAngle(tickDelta) * ((float)Math.PI * 2)) * 2.0f + 0.5f, 0.2f, 1.0f);
+        float f = MathHelper.clamp(MathHelper.cos(world.getSkyAngle(tickDelta) * ((float)Math.PI * 2)) * 2.0f + 0.5f, 0.0f, 1.0f);
         renderSingleColorBackground(f * (float)(color >> 16 & 0xFF) / 255.0f, f * (float)(color >> 8 & 0xFF) / 255.0f, f * (float)(color & 0xFF) / 255.0f, 1.0f);
     }
     public void renderSingleColorBackground(float f, float g, float h, float a) {
···
     public void handleFog() {
         RenderSystem.enableBlend();
         float[] fs = this.world.getDimensionEffects().getFogColorOverride(this.world.getSkyAngle(tickDelta), tickDelta);
-        if (fs != null && !options().getSkyType().equals("rainbow")) handleSunriseFog(fs);
+        if (fs != null && options().hasDawn()) handleSunriseFog(fs);
         RenderSystem.blendFuncSeparate(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE, GlStateManager.SrcFactor.ONE, GlStateManager.DstFactor.ZERO);
     }
     public void handleSunriseFog(float[] fs) {
···
         matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(-tilt_y));
     }
     public void renderStars(Matrix4f matrix4f2, Matrix4f projectionMatrix, Runnable fogCallback, float rain_alpha) {
-        float u = world.getStarBrightness(tickDelta) * rain_alpha;
+        float u = getStarBrightness(tickDelta) * rain_alpha;
         Vector3f color = options.getStellarColor();
         if (u > 0.0f) {
             RenderSystem.setShaderColor(u*color.x, u*color.y, u*color.z, u);
···
             VertexBuffer.unbind();
             fogCallback.run();
         }
+    }
+    public float getStarBrightness(float tickDelta) {
+        float f = world.getSkyAngle(tickDelta);
+        float g = 1.0F - (MathHelper.cos(f * (float) (Math.PI * 2)) * 2.0F + 0.25F);
+        g = MathHelper.clamp(g, 0.0f, 1.0f);
+        float day = options.getDayStarBrightness();
+        float night = options.getNightStarBrightness();
+        return day + g*g*(night-day);
+    }
+
+    public static BuiltBuffer buildStarsBuffer(Tessellator tessellator, InfinityOptions options) {
+        Random random = Random.create(10842L);
+        int num_stars = options.getNumStars();
+        float distance_to_stars = 100.0F;
+        BufferBuilder bufferBuilder = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION);
+        for (int star = 0; star < num_stars; star++) {
+            float star_x = random.nextFloat() * 2.0F - 1.0F;
+            float star_y = random.nextFloat() * 2.0F - 1.0F;
+            float star_z = random.nextFloat() * 2.0F - 1.0F;
+            float star_size = options.getStarSizeBase() + random.nextFloat() * options.getStarSizeModifier();
+            float m = MathHelper.magnitude(star_x, star_y, star_z);
+            if (!(m <= 0.010000001F) && !(m >= 1.0F)) {
+                Vector3f star_coords = new Vector3f(star_x, star_y, star_z).normalize(distance_to_stars);
+                float rotation_angle = (float)(random.nextDouble() * (float) Math.PI * 2.0);
+                Quaternionf quaternionf = new Quaternionf().rotateTo(new Vector3f(0.0F, 0.0F, -1.0F), star_coords).rotateZ(rotation_angle);
+                bufferBuilder.vertex(star_coords.add(new Vector3f(star_size, -star_size, 0.0F).rotate(quaternionf)));
+                bufferBuilder.vertex(star_coords.add(new Vector3f(star_size, star_size, 0.0F).rotate(quaternionf)));
+                bufferBuilder.vertex(star_coords.add(new Vector3f(-star_size, star_size, 0.0F).rotate(quaternionf)));
+                bufferBuilder.vertex(star_coords.add(new Vector3f(-star_size, -star_size, 0.0F).rotate(quaternionf)));
+            }
+        }
+        return bufferBuilder.end();
     }
     
     public void renderSkybox(Identifier texture, float copies, int brightness, int alpha) {

common/src/main/java/net/lerariemann/infinity/var/ModPayloads.java

···
         }
     }
     public static void receiveStars(StarsRePayLoad payload, Object context) {
-        ((WorldRendererAccess)(client(context).worldRenderer)).projectInfinity$setNeedsStars(true);
+        ((WorldRendererAccess)(client(context).worldRenderer)).infinity$setNeedsStars(true);
     }
 
     public static ShaderRePayload setShaderFromWorld(ServerWorld destination) {

common/src/main/resources/config/easter/blue.json

···
 {
-  "infinity_version": 2000003,
+  "infinity_version": 2001005,
   "easter-options": {
     "portal_color": 255,
     "shader": {
···
           "uniforms": [
             {
               "name": "RedMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.7, 0.0, 0.0 ]
             },
             {
               "name": "GreenMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.0, 0.7, 0.0 ]
             },
             {
               "name": "BlueMatrix",
-              "values": [ 1.0, 1.0, 1.0 ]
+              "values": [ 0.7, 0.7, 1.0 ]
             }
           ]
         },

common/src/main/resources/config/easter/chaos.json

···
       "type": "random_hue"
     },
     "time_scale": 50.0,
-    "sky_type": "rainbow"
+    "sky_type": "rainbow",
+    "star_brightness_day": 0.5,
+    "star_brightness_night": 1.0
   },
   "easter-type": "chaos",
   "type": "minecraft:noise",

common/src/main/resources/config/easter/chess.json

···
 {
-  "infinity_version": 2000005,
+  "infinity_version": 2001005,
   "easter-type": "chess",
   "easter-options": {
     "portal_color": {
···
         0,
         16777215
       ]
-    }
+    },
+    "dawn": false,
+    "star_brightness_night": 0.0
   },
   "type": "minecraft:noise",
   "settings": {

common/src/main/resources/config/easter/classic.json

···
 {
-  "infinity_version": 2000003,
+  "infinity_version": 2001005,
   "easter-options": {
-    "portal_color": 65535
+    "portal_color": 65535,
+    "star_size_base": 0.25,
+    "star_size_modifier": 0.25,
+    "star_brightness_night": 0.75
   },
   "type": "minecraft:noise",
   "settings": {

common/src/main/resources/config/easter/green.json

···
 {
-  "infinity_version": 2000003,
+  "infinity_version": 2001005,
   "easter-options": {
     "portal_color": 65280,
     "shader": {
···
           "uniforms": [
             {
               "name": "RedMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.7, 0.0, 0.0 ]
             },
             {
               "name": "GreenMatrix",
-              "values": [ 1.0, 1.0, 1.0 ]
+              "values": [ 0.7, 1.0, 0.7 ]
             },
             {
               "name": "BlueMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.0, 0.0, 0.7 ]
             }
           ]
         },

common/src/main/resources/config/easter/pride.json

···
 {
-  "infinity_version": 2000005,
+  "infinity_version": 2001005,
   "easter-options": {
     "portal_color": {
       "type": "checker",
···
         7848414,
         14331317,
         16777215
-      ]
+      ],
+      "star_brightness_night": 1.0,
+      "num_stars": 3000
     }
   },
   "type": "minecraft:noise",

common/src/main/resources/config/easter/red.json

···
 {
-  "infinity_version": 2000003,
+  "infinity_version": 2001005,
   "easter-options": {
     "portal_color": 16711680,
     "shader": {
···
           "uniforms": [
             {
               "name": "RedMatrix",
-              "values": [ 1.0, 1.0, 1.0 ]
+              "values": [ 1.0, 0.7, 0.7 ]
             },
             {
               "name": "GreenMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.0, 0.7, 0.0 ]
             },
             {
               "name": "BlueMatrix",
-              "values": [ 0.0, 0.0, 0.0 ]
+              "values": [ 0.0, 0.0, 0.7 ]
             }
           ]
         },

docs/dimension-options.mdx

···
 for the sky to stop being darkened by void fog. With 0 it's always darkened, and with 1 - never (which is the case for all
 of the mod's dimensions). The overworld uses 0.03125.
 - `end_sky_like`: setting this to true disables the rendering of stellar bodies completely even in a world with overworld dimension effects.
+- `dawn`: a boolean dictating if skies get shading on sunrise and sunset. They do by default except when they're rainbow.
 - `time_scale`: how fast does the Sun move across the sky! affects most things the day length in minecraft should logically affect,
 including undead mobs burning. 0.0 is fixed time, 1.0 is normal time, negatives make the sun rise in the west.
 - `solar_size`: the size of the Sun :D the Overworld uses 30.0
···
     rotates the orbit in a perpendicular direction, lowering its highest point from the zenith.
     - `lunar_velocity`, multiplicative with `time_scale`, defines how fast each moon moves.
     - `lunar_offset` defines the starting position the moon has on its orbit (observed when you execute `/time set 0`).
-- `num_stars`: the amount of stars in the night sky. 1500 is the vanilla value.
+- `num_stars`: the amount of stars in the night sky. 1500 is the vanilla value. Needs to be above 0 (to disable the stars, set their
+brightness to 0 instead).
 - `star_size_base` and `star_size_modifier` are the minimum and width of the star size distribution. Actual star sizes are distributed
 uniformly between base and base+modifier. 0.15 and 0.1 are corresponding vanilla options.
 - `stellar_color`: the tint for stars.
 - `stellar_tilt_y`, `stellar_tilt_z`, `stellar_velocity` mirror the lunar options for the movement of the entire star-filled sphere.
+- `star_brightness_day`, `star_brightness_night`: self-explanatory. Need to be between 0 and 1. Vanilla uses 0.0 and 0.5 respectfully,
+and that's a pity, cause stars are very beautiful when `star_brightness_night` is raised to 1.0 :D
 
 Here's an example of an options file from the wild, edited a bit for your readability: