mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-21 21:02:15 +00:00
Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7e4292bdba | ||
|
|
f79e112700 | ||
|
|
ba46feb20b | ||
|
|
33804c67da | ||
|
|
3c9353e143 | ||
|
|
77eb3ad46a | ||
|
|
8a56ab8ca1 | ||
|
|
fe065803aa | ||
|
|
f94268c384 | ||
|
|
f7a8b0f3bf | ||
|
|
8893cf2291 |
No files matched your search
@@ -0,0 +1,33 @@
|
||||
name: Feature Request
|
||||
description: "Request a feature."
|
||||
labels: ["enhancement"]
|
||||
body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: "Please use this form to request features. We ask you check if it was already requested though"
|
||||
- type: input
|
||||
id: discord
|
||||
attributes:
|
||||
label: Your GTNH Discord Username
|
||||
description: Leave empty if you don't have one, but this will make it harder to contact you if we need additional info.
|
||||
placeholder: "Example: Wumpus#1234"
|
||||
- type: textarea
|
||||
id: request
|
||||
attributes:
|
||||
label: Feature Request
|
||||
description: "Relevant information, as well as relevant images"
|
||||
placeholder: "Example: https://mclo.gs/ OR submit the file to github by dragging it to this textbox."
|
||||
validations:
|
||||
required: true
|
||||
- type: checkboxes
|
||||
id: final
|
||||
attributes:
|
||||
label: Final Checklist
|
||||
description: Certify that you read things
|
||||
options:
|
||||
- label: "I have searched the issues and haven't found a similar issue."
|
||||
required: true
|
||||
- label: "I have read the known incompatibilities and this is not related to one of those."
|
||||
required: true
|
||||
- label: "This issue is not related to a feature that is disabed by default - Shaders, MCPF, etc. [They'll be enabled when they're ready for testing]"
|
||||
required: true
|
||||
@@ -1,6 +1,7 @@
|
||||
.gradle
|
||||
.settings
|
||||
/.idea/
|
||||
/.vs/
|
||||
/.vscode/
|
||||
/run/
|
||||
/build/
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
|
||||
# Required Dependencies
|
||||
* [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.14
|
||||
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.2.9
|
||||
* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.3.2
|
||||
* NOTE: Some mods are not required, but a specific version is required if present - see: `Permanent Incompatibilities` below.
|
||||
|
||||
# Known (temporary) Incompatibilities
|
||||
|
||||
+8
-3
@@ -58,7 +58,7 @@ dependencies {
|
||||
|
||||
// Iris Shaders
|
||||
compileOnly('org.jetbrains:annotations:24.0.1')
|
||||
api("com.github.GTNewHorizons:GTNHLib:0.2.9:dev")
|
||||
api("com.github.GTNewHorizons:GTNHLib:0.3.2:dev")
|
||||
shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
|
||||
implementation("io.github.douira:glsl-transformer:1.0.0")
|
||||
shadowImplementation("io.github.douira:glsl-transformer:1.0.0") { // glsl-transformer Noncommercial License 1.0.0
|
||||
@@ -78,12 +78,17 @@ dependencies {
|
||||
compileOnly("com.github.GTNewHorizons:TinkersConstruct:1.12.0-GTNH:dev")
|
||||
compileOnly("com.github.GTNewHorizons:Natura:2.6.1:dev")
|
||||
|
||||
compileOnly("com.falsepattern:chunkapi-mc1.7.10:0.5.0:api") { transitive = false }
|
||||
compileOnly("com.falsepattern:endlessids-mc1.7.10:1.5-beta0002:dev") { transitive = false }
|
||||
compileOnly("com.github.GTNewHorizons:Battlegear2:1.4.0:dev") { transitive = false }
|
||||
compileOnly(rfg.deobf('maven.modrinth:backhand:1.4.1')) { transitive = false }
|
||||
|
||||
compileOnly("com.falsepattern:chunkapi-mc1.7.10:0.5.1:api") { transitive = false }
|
||||
compileOnly("com.falsepattern:endlessids-mc1.7.10:1.5-beta0003:dev") { transitive = false }
|
||||
|
||||
compileOnly(rfg.deobf("curse.maven:extrautils-225561:2264383"))
|
||||
compileOnly(rfg.deobf("curse.maven:dynamiclights-227874:2337326"))
|
||||
|
||||
compileOnly("curse.maven:minefactory-reloaded-66672:2277486")
|
||||
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds:2.0.3:dev") // Mixin Version
|
||||
compileOnly("com.github.GTNewHorizons:NotEnoughIds-Legacy:1.4.7:dev") // ASM Version
|
||||
|
||||
|
||||
+1
-1
@@ -16,5 +16,5 @@ pluginManagement {
|
||||
}
|
||||
|
||||
plugins {
|
||||
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.21'
|
||||
id 'com.gtnewhorizons.gtnhsettingsconvention' version '1.0.23'
|
||||
}
|
||||
@@ -15,7 +15,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
|
||||
name = "Angelica",
|
||||
version = Tags.VERSION,
|
||||
dependencies = " before:lwjgl3ify@[1.5.3,);" + " after:hodgepodge@[2.4.4,);" + " after:CodeChickenCore@[1.2.0,);"
|
||||
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.2.9,);",
|
||||
+ " after:archaicfix@[0.7.0,);" + " required-after:gtnhlib@[0.3.2,);",
|
||||
acceptedMinecraftVersions = "[1.7.10]",
|
||||
acceptableRemoteVersions = "*",
|
||||
guiFactory = "com.gtnewhorizons.angelica.config.AngelicaGuiConfigFactory")
|
||||
|
||||
@@ -1,24 +1,10 @@
|
||||
package com.gtnewhorizons.angelica.api;
|
||||
|
||||
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
|
||||
import java.math.RoundingMode;
|
||||
|
||||
import static com.google.common.math.IntMath.log2;
|
||||
|
||||
public interface BlockPos {
|
||||
|
||||
int SIZE_BITS_X = 1 + log2(MathHelper.roundUpToPowerOfTwo(30000000), RoundingMode.UNNECESSARY);
|
||||
int SIZE_BITS_Z = SIZE_BITS_X;
|
||||
int SIZE_BITS_Y = 64 - SIZE_BITS_X - SIZE_BITS_Z;
|
||||
long BITS_X = (1L << SIZE_BITS_X) - 1L;
|
||||
long BITS_Y = (1L << SIZE_BITS_Y) - 1L;
|
||||
long BITS_Z = (1L << SIZE_BITS_Z) - 1L;
|
||||
int BIT_SHIFT_Z = SIZE_BITS_Y;
|
||||
int BIT_SHIFT_X = SIZE_BITS_Y + SIZE_BITS_Z;
|
||||
|
||||
int getX();
|
||||
int getY();
|
||||
int getZ();
|
||||
@@ -28,22 +14,6 @@ public interface BlockPos {
|
||||
long asLong();
|
||||
|
||||
static long asLong(int x, int y, int z) {
|
||||
long l = 0L;
|
||||
l |= ((long) x & BITS_X) << BIT_SHIFT_X;
|
||||
l |= ((long) y & BITS_Y) << 0;
|
||||
l |= ((long) z & BITS_Z) << BIT_SHIFT_Z;
|
||||
return l;
|
||||
}
|
||||
|
||||
public static int unpackLongX(long packedPos) {
|
||||
return (int)(packedPos << 64 - BIT_SHIFT_X - SIZE_BITS_X >> 64 - SIZE_BITS_X);
|
||||
}
|
||||
|
||||
public static int unpackLongY(long packedPos) {
|
||||
return (int)(packedPos << 64 - SIZE_BITS_Y >> 64 - SIZE_BITS_Y);
|
||||
}
|
||||
|
||||
public static int unpackLongZ(long packedPos) {
|
||||
return (int)(packedPos << 64 - BIT_SHIFT_Z - SIZE_BITS_Z >> 64 - SIZE_BITS_Z);
|
||||
return CoordinatePacker.pack(x, y, z);
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import cpw.mods.fml.common.Loader;
|
||||
import cpw.mods.fml.common.versioning.ArtifactVersion;
|
||||
import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
|
||||
import net.dries007.holoInventory.HoloInventory;
|
||||
import xonin.backhand.Backhand;
|
||||
|
||||
public class ModStatus {
|
||||
/**
|
||||
@@ -23,6 +24,8 @@ public class ModStatus {
|
||||
public static boolean isEIDBiomeLoaded;
|
||||
public static boolean isXaerosMinimapLoaded;
|
||||
public static boolean isHoloInventoryLoaded;
|
||||
public static boolean isBattlegearLoaded;
|
||||
public static boolean isBackhandLoaded;
|
||||
|
||||
public static void preInit(){
|
||||
isBetterCrashesLoaded = Loader.isModLoaded("bettercrashes");
|
||||
@@ -33,6 +36,8 @@ public class ModStatus {
|
||||
isEIDBiomeLoaded = Loader.isModLoaded("endlessids_biome");
|
||||
isXaerosMinimapLoaded = Loader.isModLoaded("XaeroMinimap");
|
||||
isHoloInventoryLoaded = Loader.isModLoaded("holoinventory");
|
||||
isBattlegearLoaded = Loader.isModLoaded("battlegear2");
|
||||
isBackhandLoaded = Loader.isModLoaded("backhand");
|
||||
|
||||
if (isHoloInventoryLoaded){
|
||||
isHoloInventoryLoaded = new DefaultArtifactVersion("2.4.4-GTNH")
|
||||
@@ -41,6 +46,13 @@ public class ModStatus {
|
||||
) <= 0;
|
||||
}
|
||||
|
||||
if (isBackhandLoaded){
|
||||
isBackhandLoaded = new DefaultArtifactVersion("1.4.1")
|
||||
.compareTo(
|
||||
LoadControllerHelper.getOwningMod(Backhand.class).getProcessedVersion()
|
||||
) <= 0;
|
||||
}
|
||||
|
||||
|
||||
isNEIDMetadataExtended = false;
|
||||
if (isNEIDLoaded) {
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
package com.gtnewhorizons.angelica.compat.endlessids;
|
||||
|
||||
import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook;
|
||||
import lombok.val;
|
||||
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
|
||||
import static com.falsepattern.endlessids.constants.ExtendedConstants.biomeIDMask;
|
||||
import static com.falsepattern.endlessids.constants.ExtendedConstants.biomeIDNull;
|
||||
|
||||
public class EndlessIDsCompat {
|
||||
public static void sodium$populateBiomes(Chunk chunk) {
|
||||
if (!(chunk instanceof ChunkBiomeHook hook))
|
||||
return;
|
||||
|
||||
val biomes = hook.getBiomeShortArray();
|
||||
if (biomes == null)
|
||||
return;
|
||||
|
||||
val cX = chunk.xPosition << 4;
|
||||
val cZ = chunk.zPosition << 4;
|
||||
|
||||
val manager = chunk.worldObj.getWorldChunkManager();
|
||||
for(var z = 0; z < 16; z++) {
|
||||
for(var x = 0; x < 16; x++) {
|
||||
val idx = (z << 4) + x;
|
||||
val biome = biomes[idx] & biomeIDMask;
|
||||
if(biome == biomeIDNull) {
|
||||
val generated = manager.getBiomeGenAt(cX + x, cZ + z);
|
||||
if (generated == null)
|
||||
continue;
|
||||
biomes[idx] = (short)(generated.biomeID & biomeIDMask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,14 +1,11 @@
|
||||
package com.gtnewhorizons.angelica.compat.mojang;
|
||||
|
||||
import com.gtnewhorizons.angelica.api.BlockPos;
|
||||
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
|
||||
import com.gtnewhorizons.angelica.api.MutableBlockPos;
|
||||
import net.minecraft.world.ChunkPosition;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import org.joml.Vector3i;
|
||||
|
||||
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongX;
|
||||
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongY;
|
||||
import static com.gtnewhorizons.angelica.api.BlockPos.unpackLongZ;
|
||||
|
||||
// Should we keep this?
|
||||
public class BlockPosImpl extends Vector3i implements MutableBlockPos {
|
||||
@@ -54,7 +51,7 @@ public class BlockPosImpl extends Vector3i implements MutableBlockPos {
|
||||
|
||||
@Override
|
||||
public long asLong() {
|
||||
return BlockPos.asLong(this.x, this.y, this.z);
|
||||
return CoordinatePacker.pack(this.x, this.y, this.z);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -65,6 +62,7 @@ public class BlockPosImpl extends Vector3i implements MutableBlockPos {
|
||||
|
||||
@Override
|
||||
public BlockPosImpl set(long packedPos) {
|
||||
return set(unpackLongX(packedPos), unpackLongY(packedPos), unpackLongZ(packedPos));
|
||||
CoordinatePacker.unpack(packedPos, this);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
@@ -70,11 +70,16 @@ public class AngelicaConfig {
|
||||
@Config.DefaultBoolean(true)
|
||||
public static boolean showSplashMemoryBar;
|
||||
|
||||
@Config.Comment("Renders the HUD elements once per tick and reuses the pixels to improve performance. [Experimental]")
|
||||
@Config.Comment("Renders the HUD elements once per 20 frames (by default) and reuses the pixels to improve performance. [Experimental]")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean enableHudCaching;
|
||||
|
||||
@Config.Comment("The amount of frames to wait before updating the HUD elements. [Experimental]")
|
||||
@Config.DefaultInt(20)
|
||||
@Config.RangeInt(min = 1, max = 60)
|
||||
public static int hudCachingFPS = 20;
|
||||
|
||||
@Config.Comment("Batch drawScreen fonts [Experimental]")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
@@ -110,6 +115,11 @@ public class AngelicaConfig {
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean fixExtraUtilsSodiumCompat;
|
||||
|
||||
@Config.Comment("Fix thread-safety issues in MineFactory Reloaded")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
public static boolean fixMineFactoryReloadedSodiumCompat;
|
||||
|
||||
@Config.Comment("Fix RenderBlockFluid reading the block type from the world access multiple times")
|
||||
@Config.DefaultBoolean(true)
|
||||
@Config.RequiresMcRestart
|
||||
|
||||
@@ -1,15 +1,21 @@
|
||||
package com.gtnewhorizons.angelica.dynamiclights;
|
||||
|
||||
import com.gtnewhorizons.angelica.api.BlockPos;
|
||||
import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.mojang.BlockPosImpl;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
|
||||
import me.jellysquid.mods.sodium.client.render.SodiumWorldRenderer;
|
||||
import mods.battlegear2.api.core.IBattlePlayer;
|
||||
import mods.battlegear2.api.core.IInventoryPlayerBattle;
|
||||
import net.irisshaders.iris.api.v0.IrisApi;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityLivingBase;
|
||||
import net.minecraft.entity.item.EntityItem;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.init.Items;
|
||||
import net.minecraft.item.Item;
|
||||
@@ -18,8 +24,9 @@ import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.util.MathHelper;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
import xonin.backhand.api.core.BackhandUtils;
|
||||
import xonin.backhand.api.core.IBackhandPlayer;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.locks.ReentrantReadWriteLock;
|
||||
import java.util.function.Predicate;
|
||||
@@ -271,7 +278,7 @@ public class DynamicLights {
|
||||
* @param chunkPos the packed chunk position
|
||||
*/
|
||||
public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, long chunkPos) {
|
||||
scheduleChunkRebuild(renderer, BlockPos.unpackLongX(chunkPos), BlockPos.unpackLongY(chunkPos), BlockPos.unpackLongZ(chunkPos));
|
||||
scheduleChunkRebuild(renderer, CoordinatePacker.unpackX(chunkPos), CoordinatePacker.unpackY(chunkPos), CoordinatePacker.unpackZ(chunkPos));
|
||||
}
|
||||
|
||||
public static void scheduleChunkRebuild(@NotNull SodiumWorldRenderer renderer, int x, int y, int z) {
|
||||
@@ -287,7 +294,7 @@ public class DynamicLights {
|
||||
*/
|
||||
public static void updateTrackedChunks(@NotNull BlockPosImpl chunkPos, @Nullable LongOpenHashSet old, @Nullable LongOpenHashSet newPos) {
|
||||
if (old != null || newPos != null) {
|
||||
long pos = chunkPos.asLong();
|
||||
final long pos = chunkPos.asLong();
|
||||
if (old != null)
|
||||
old.remove(pos);
|
||||
if (newPos != null)
|
||||
@@ -319,6 +326,9 @@ public class DynamicLights {
|
||||
* @return the luminance of the item
|
||||
*/
|
||||
public static int getLuminanceFromItemStack(@NotNull ItemStack stack, boolean submergedInWater) {
|
||||
// TODO only have certain items not glow in water?
|
||||
if (submergedInWater) return 0;
|
||||
|
||||
Item item = stack.getItem();
|
||||
if (item instanceof ItemBlock itemBlock) {
|
||||
Block block = itemBlock.field_150939_a;
|
||||
@@ -337,15 +347,15 @@ public class DynamicLights {
|
||||
if (entity.fire > 0) return 15;
|
||||
|
||||
if (entity instanceof EntityItem item) {
|
||||
return getLuminanceFromItemStack(item.getEntityItem(), item.isInWater());
|
||||
return getLuminanceFromItemStack(item.getEntityItem(), item.isInsideOfMaterial(Material.water));
|
||||
}
|
||||
|
||||
if (entity instanceof EntityLivingBase living) {
|
||||
int luminance = 0;
|
||||
|
||||
boolean inWater = living.isInWater();
|
||||
boolean inWater = living.isInsideOfMaterial(Material.water);
|
||||
|
||||
// check equipment + hand for light
|
||||
// check equipment + hand for light (should work for all entities)
|
||||
ItemStack itemStack;
|
||||
for (int i = 0; i < 5; i++) {
|
||||
if ((itemStack = living.getEquipmentInSlot(i)) != null) {
|
||||
@@ -353,6 +363,23 @@ public class DynamicLights {
|
||||
}
|
||||
}
|
||||
|
||||
if (ModStatus.isBattlegearLoaded &&
|
||||
living instanceof EntityPlayer player &&
|
||||
player instanceof IBattlePlayer battlePlayer &&
|
||||
battlePlayer.battlegear2$isBattlemode()
|
||||
) {
|
||||
ItemStack offhand = ((IInventoryPlayerBattle) player.inventory).battlegear2$getCurrentOffhandWeapon();
|
||||
if (offhand != null) {
|
||||
luminance = Math.max(luminance, getLuminanceFromItemStack(offhand, inWater));
|
||||
}
|
||||
}
|
||||
else if (ModStatus.isBackhandLoaded && living instanceof EntityPlayer player){
|
||||
ItemStack offhand = BackhandUtils.getOffhandItem(player);
|
||||
if (offhand != null) {
|
||||
luminance = Math.max(luminance, getLuminanceFromItemStack(offhand, inWater));
|
||||
}
|
||||
}
|
||||
|
||||
return luminance;
|
||||
}
|
||||
|
||||
|
||||
@@ -82,7 +82,14 @@ public class Feature {
|
||||
, GLStateManager.depthTest // GL_DEPTH_TEST flag
|
||||
// GL_DITHER flag
|
||||
, GLStateManager.fogMode // GL_FOG flag
|
||||
// GL_LIGHTi where 0 <= i < GL_MAX_LIGHTS
|
||||
, GLStateManager.lightStates[0] // GL_LIGHT0
|
||||
, GLStateManager.lightStates[1] // GL_LIGHT1
|
||||
, GLStateManager.lightStates[2] // GL_LIGHT2
|
||||
, GLStateManager.lightStates[3] // GL_LIGHT3
|
||||
, GLStateManager.lightStates[4] // GL_LIGHT4
|
||||
, GLStateManager.lightStates[5] // GL_LIGHT5
|
||||
, GLStateManager.lightStates[6] // GL_LIGHT6
|
||||
, GLStateManager.lightStates[7] // GL_LIGHT7
|
||||
, GLStateManager.lightingState // GL_LIGHTING flag
|
||||
// GL_LINE_SMOOTH flag
|
||||
// GL_LINE_STIPPLE flag
|
||||
@@ -149,9 +156,25 @@ public class Feature {
|
||||
// GL_LIGHT_MODEL_TWO_SIDE setting
|
||||
GLStateManager.lightingState // GL_LIGHTING enable bit
|
||||
// Enable bit for each light
|
||||
, GLStateManager.lightStates[0] // GL_LIGHT0
|
||||
, GLStateManager.lightStates[1] // GL_LIGHT1
|
||||
, GLStateManager.lightStates[2] // GL_LIGHT2
|
||||
, GLStateManager.lightStates[3] // GL_LIGHT3
|
||||
, GLStateManager.lightStates[4] // GL_LIGHT4
|
||||
, GLStateManager.lightStates[5] // GL_LIGHT5
|
||||
, GLStateManager.lightStates[6] // GL_LIGHT6
|
||||
, GLStateManager.lightStates[7] // GL_LIGHT7
|
||||
// Ambient, diffuse, and specular intensity for each light
|
||||
// Direction, position, exponent, and cutoff angle for each light
|
||||
// Constant, linear, and quadratic attenuation factors for each light
|
||||
, GLStateManager.lightDataStates[0]
|
||||
, GLStateManager.lightDataStates[1]
|
||||
, GLStateManager.lightDataStates[2]
|
||||
, GLStateManager.lightDataStates[3]
|
||||
, GLStateManager.lightDataStates[4]
|
||||
, GLStateManager.lightDataStates[5]
|
||||
, GLStateManager.lightDataStates[6]
|
||||
, GLStateManager.lightDataStates[7]
|
||||
// Ambient, diffuse, specular, and emissive color for each material
|
||||
// Ambient, diffuse, and specular color indices for each material
|
||||
// Specular exponent for each material
|
||||
|
||||
@@ -11,6 +11,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.DepthStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.FogStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.IStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.IntegerStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.LightStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
|
||||
import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
|
||||
import com.gtnewhorizons.angelica.glsm.states.Color4;
|
||||
@@ -59,6 +60,7 @@ import org.lwjgl.opengl.GL14;
|
||||
import org.lwjgl.opengl.GL20;
|
||||
import org.lwjgl.opengl.GLContext;
|
||||
|
||||
import java.lang.Math;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.DoubleBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
@@ -121,6 +123,14 @@ public class GLStateManager {
|
||||
@Getter protected static final Matrix4fStack modelViewMatrix = new Matrix4fStack(MAX_MODELVIEW_STACK_DEPTH);
|
||||
@Getter protected static final Matrix4fStack projectionMatrix = new Matrix4fStack(MAX_PROJECTION_STACK_DEPTH);
|
||||
|
||||
@Getter protected static final BooleanStateStack[] lightStates = new BooleanStateStack[8];
|
||||
@Getter protected static final LightStateStack[] lightDataStates = new LightStateStack[8];
|
||||
static {
|
||||
for (int i = 0; i < lightStates.length; i ++) {
|
||||
lightStates[i] = new BooleanStateStack(GL11.GL_LIGHT0 + i);
|
||||
lightDataStates[i] = new LightStateStack(GL11.GL_LIGHT0 + i);
|
||||
}
|
||||
}
|
||||
|
||||
@Getter protected static final ViewPortStateStack viewportState = new ViewPortStateStack();
|
||||
|
||||
@@ -259,6 +269,14 @@ public class GLStateManager {
|
||||
case GL11.GL_DEPTH_TEST -> enableDepthTest();
|
||||
case GL11.GL_FOG -> enableFog();
|
||||
case GL11.GL_LIGHTING -> enableLighting();
|
||||
case GL11.GL_LIGHT0 -> enableLight(0);
|
||||
case GL11.GL_LIGHT1 -> enableLight(1);
|
||||
case GL11.GL_LIGHT2 -> enableLight(2);
|
||||
case GL11.GL_LIGHT3 -> enableLight(3);
|
||||
case GL11.GL_LIGHT4 -> enableLight(4);
|
||||
case GL11.GL_LIGHT5 -> enableLight(5);
|
||||
case GL11.GL_LIGHT6 -> enableLight(6);
|
||||
case GL11.GL_LIGHT7 -> enableLight(7);
|
||||
case GL11.GL_SCISSOR_TEST -> enableScissorTest();
|
||||
case GL11.GL_TEXTURE_2D -> enableTexture();
|
||||
case GL12.GL_RESCALE_NORMAL -> enableRescaleNormal();
|
||||
@@ -274,6 +292,14 @@ public class GLStateManager {
|
||||
case GL11.GL_DEPTH_TEST -> disableDepthTest();
|
||||
case GL11.GL_FOG -> disableFog();
|
||||
case GL11.GL_LIGHTING -> disableLighting();
|
||||
case GL11.GL_LIGHT0 -> disableLight(0);
|
||||
case GL11.GL_LIGHT1 -> disableLight(1);
|
||||
case GL11.GL_LIGHT2 -> disableLight(2);
|
||||
case GL11.GL_LIGHT3 -> disableLight(3);
|
||||
case GL11.GL_LIGHT4 -> disableLight(4);
|
||||
case GL11.GL_LIGHT5 -> disableLight(5);
|
||||
case GL11.GL_LIGHT6 -> disableLight(6);
|
||||
case GL11.GL_LIGHT7 -> disableLight(7);
|
||||
case GL11.GL_SCISSOR_TEST -> disableScissorTest();
|
||||
case GL11.GL_TEXTURE_2D -> disableTexture();
|
||||
case GL12.GL_RESCALE_NORMAL -> disableRescaleNormal();
|
||||
@@ -292,6 +318,14 @@ public class GLStateManager {
|
||||
case GL11.GL_DEPTH_TEST -> depthTest.isEnabled();
|
||||
case GL11.GL_FOG -> fogMode.isEnabled();
|
||||
case GL11.GL_LIGHTING -> lightingState.isEnabled();
|
||||
case GL11.GL_LIGHT0 -> lightStates[0].isEnabled();
|
||||
case GL11.GL_LIGHT1 -> lightStates[1].isEnabled();
|
||||
case GL11.GL_LIGHT2 -> lightStates[2].isEnabled();
|
||||
case GL11.GL_LIGHT3 -> lightStates[3].isEnabled();
|
||||
case GL11.GL_LIGHT4 -> lightStates[4].isEnabled();
|
||||
case GL11.GL_LIGHT5 -> lightStates[5].isEnabled();
|
||||
case GL11.GL_LIGHT6 -> lightStates[6].isEnabled();
|
||||
case GL11.GL_LIGHT7 -> lightStates[7].isEnabled();
|
||||
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
|
||||
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.getValue()).isEnabled();
|
||||
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
|
||||
@@ -311,6 +345,14 @@ public class GLStateManager {
|
||||
case GL11.GL_DEPTH_WRITEMASK -> depthState.isEnabled();
|
||||
case GL11.GL_FOG -> fogMode.isEnabled();
|
||||
case GL11.GL_LIGHTING -> lightingState.isEnabled();
|
||||
case GL11.GL_LIGHT0 -> lightStates[0].isEnabled();
|
||||
case GL11.GL_LIGHT1 -> lightStates[1].isEnabled();
|
||||
case GL11.GL_LIGHT2 -> lightStates[2].isEnabled();
|
||||
case GL11.GL_LIGHT3 -> lightStates[3].isEnabled();
|
||||
case GL11.GL_LIGHT4 -> lightStates[4].isEnabled();
|
||||
case GL11.GL_LIGHT5 -> lightStates[5].isEnabled();
|
||||
case GL11.GL_LIGHT6 -> lightStates[6].isEnabled();
|
||||
case GL11.GL_LIGHT7 -> lightStates[7].isEnabled();
|
||||
case GL11.GL_SCISSOR_TEST -> scissorTest.isEnabled();
|
||||
case GL11.GL_TEXTURE_2D -> textures.getTextureUnitStates(activeTextureUnit.getValue()).isEnabled();
|
||||
case GL12.GL_RESCALE_NORMAL -> rescaleNormalState.isEnabled();
|
||||
@@ -381,6 +423,24 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glGetLight(int light, int pname, FloatBuffer params) {
|
||||
if (shouldBypassCache()) {
|
||||
GL11.glGetLight(light, pname, params);
|
||||
return;
|
||||
}
|
||||
|
||||
LightStateStack state = lightDataStates[light - GL11.GL_LIGHT0];
|
||||
switch (pname) {
|
||||
case GL11.GL_AMBIENT -> state.ambient.get(0, params);
|
||||
case GL11.GL_DIFFUSE -> state.diffuse.get(0, params);
|
||||
case GL11.GL_SPECULAR -> state.specular.get(0, params);
|
||||
case GL11.GL_POSITION -> state.position.get(0, params);
|
||||
case GL11.GL_SPOT_DIRECTION -> state.spotDirection.get(0, params);
|
||||
case GL11.GL_SPOT_EXPONENT -> params.put(state.spotExponent);
|
||||
case GL11.GL_SPOT_CUTOFF -> params.put(state.spotCutoff);
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> params.put(state.constantAttenuation);
|
||||
case GL11.GL_LINEAR_ATTENUATION -> params.put(state.linearAttenuation);
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> params.put(state.quadraticAttenuation);
|
||||
}
|
||||
GL11.glGetLight(light, pname, params);
|
||||
}
|
||||
|
||||
@@ -595,6 +655,8 @@ public class GLStateManager {
|
||||
return ((b - Byte.MIN_VALUE) & 0xFF) / 255.0F;
|
||||
}
|
||||
|
||||
public static float i2f(int i) { return ((i - Integer.MIN_VALUE) & 0xFFFFFF) / 4294967295.0F; }
|
||||
|
||||
private static boolean changeColor(float red, float green, float blue, float alpha) {
|
||||
// Helper function for glColor*
|
||||
if (shouldBypassCache() || red != color.getRed() || green != color.getGreen() || blue != color.getBlue() || alpha != color.getAlpha()) {
|
||||
@@ -900,10 +962,18 @@ public class GLStateManager {
|
||||
lightingState.enable();
|
||||
}
|
||||
|
||||
public static void enableLight(int light) {
|
||||
lightStates[light].enable();
|
||||
}
|
||||
|
||||
public static void disableLighting() {
|
||||
lightingState.disable();
|
||||
}
|
||||
|
||||
public static void disableLight(int light) {
|
||||
lightStates[light].disable();
|
||||
}
|
||||
|
||||
public static void enableRescaleNormal() {
|
||||
rescaleNormalState.enable();
|
||||
}
|
||||
@@ -1147,6 +1217,10 @@ public class GLStateManager {
|
||||
}
|
||||
}
|
||||
|
||||
public static Matrix4f getModelviewMatrix() {
|
||||
return modelViewMatrix;
|
||||
}
|
||||
|
||||
public static void glLoadIdentity() {
|
||||
GL11.glLoadIdentity();
|
||||
getMatrixStack().identity();
|
||||
@@ -1418,10 +1492,61 @@ public class GLStateManager {
|
||||
}
|
||||
|
||||
public static void glLight(int light, int pname, FloatBuffer params) {
|
||||
GL11.glLight(light, pname, params);
|
||||
LightStateStack lightState = lightDataStates[light - GL11.GL_LIGHT0];
|
||||
switch (pname) {
|
||||
case GL11.GL_AMBIENT -> lightState.setAmbient(params);
|
||||
case GL11.GL_DIFFUSE -> lightState.setDiffuse(params);
|
||||
case GL11.GL_SPECULAR -> lightState.setSpecular(params);
|
||||
case GL11.GL_POSITION -> lightState.setPosition(params);
|
||||
case GL11.GL_SPOT_DIRECTION -> lightState.setSpotDirection(params);
|
||||
case GL11.GL_SPOT_EXPONENT -> lightState.setSpotExponent(params);
|
||||
case GL11.GL_SPOT_CUTOFF -> lightState.setSpotCutoff(params);
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> lightState.setConstantAttenuation(params);
|
||||
case GL11.GL_LINEAR_ATTENUATION -> lightState.setLinearAttenuation(params);
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> lightState.setQuadraticAttenuation(params);
|
||||
default -> GL11.glLight(light, pname, params);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glLight(int light, int pname, IntBuffer params) {
|
||||
GL11.glLight(light, pname, params);
|
||||
LightStateStack lightState = lightDataStates[light - GL11.GL_LIGHT0];
|
||||
switch (pname) {
|
||||
case GL11.GL_AMBIENT -> lightState.setAmbient(params);
|
||||
case GL11.GL_DIFFUSE -> lightState.setDiffuse(params);
|
||||
case GL11.GL_SPECULAR -> lightState.setSpecular(params);
|
||||
case GL11.GL_POSITION -> lightState.setPosition(params);
|
||||
case GL11.GL_SPOT_DIRECTION -> lightState.setSpotDirection(params);
|
||||
case GL11.GL_SPOT_EXPONENT -> lightState.setSpotExponent(params);
|
||||
case GL11.GL_SPOT_CUTOFF -> lightState.setSpotCutoff(params);
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> lightState.setConstantAttenuation(params);
|
||||
case GL11.GL_LINEAR_ATTENUATION -> lightState.setLinearAttenuation(params);
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> lightState.setQuadraticAttenuation(params);
|
||||
default -> GL11.glLight(light, pname, params);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glLightf(int light, int pname, float param) {
|
||||
LightStateStack lightState = lightDataStates[light - GL11.GL_LIGHT0];
|
||||
switch (pname) {
|
||||
case GL11.GL_SPOT_EXPONENT -> lightState.setSpotExponent(param);
|
||||
case GL11.GL_SPOT_CUTOFF -> lightState.setSpotCutoff(param);
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> lightState.setConstantAttenuation(param);
|
||||
case GL11.GL_LINEAR_ATTENUATION -> lightState.setLinearAttenuation(param);
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> lightState.setQuadraticAttenuation(param);
|
||||
default -> GL11.glLightf(light, pname, param);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glLighti(int light, int pname, int param) {
|
||||
LightStateStack lightState = lightDataStates[light - GL11.GL_LIGHT0];
|
||||
switch (pname) {
|
||||
case GL11.GL_SPOT_EXPONENT -> lightState.setSpotExponent(param);
|
||||
case GL11.GL_SPOT_CUTOFF -> lightState.setSpotCutoff(param);
|
||||
case GL11.GL_CONSTANT_ATTENUATION -> lightState.setConstantAttenuation(param);
|
||||
case GL11.GL_LINEAR_ATTENUATION -> lightState.setLinearAttenuation(param);
|
||||
case GL11.GL_QUADRATIC_ATTENUATION -> lightState.setQuadraticAttenuation(param);
|
||||
default -> GL11.glLighti(light, pname, param);
|
||||
}
|
||||
}
|
||||
|
||||
public static void glLightModel(int pname, FloatBuffer params) {
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package com.gtnewhorizons.angelica.glsm.stacks;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.glsm.states.LightState;
|
||||
|
||||
public class LightStateStack extends LightState implements IStateStack<LightStateStack> {
|
||||
|
||||
protected final LightState[] stack;
|
||||
|
||||
protected int pointer;
|
||||
|
||||
public LightStateStack(int light) {
|
||||
super(light);
|
||||
stack = new LightState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
|
||||
for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
|
||||
stack[i] = new LightState(light);
|
||||
}
|
||||
}
|
||||
|
||||
public LightStateStack push() {
|
||||
if (pointer == stack.length) {
|
||||
throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
|
||||
}
|
||||
|
||||
stack[pointer++].set(this);
|
||||
return this;
|
||||
}
|
||||
|
||||
public LightStateStack pop() {
|
||||
if (pointer == 0) {
|
||||
throw new IllegalStateException("Stack underflow");
|
||||
}
|
||||
|
||||
set(stack[--pointer]);
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isEmpty() { return pointer == 0; }
|
||||
}
|
||||
@@ -0,0 +1,291 @@
|
||||
package com.gtnewhorizons.angelica.glsm.states;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import org.joml.Matrix3f;
|
||||
import org.joml.Vector3f;
|
||||
import org.joml.Vector3i;
|
||||
import org.joml.Vector4f;
|
||||
import org.joml.Vector4i;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.FloatBuffer;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
import static com.gtnewhorizons.angelica.glsm.GLStateManager.i2f;
|
||||
|
||||
public class LightState implements ISettableState<LightState> {
|
||||
|
||||
private static final Vector4i vector4i = new Vector4i();
|
||||
private static final Vector4f vector4f = new Vector4f();
|
||||
private static final Vector3i vector3i = new Vector3i();
|
||||
private static final Vector3f vector3f = new Vector3f();
|
||||
private static final Matrix3f matrix3f = new Matrix3f();
|
||||
|
||||
public int light;
|
||||
|
||||
public final Vector4f ambient;
|
||||
public final Vector4f diffuse;
|
||||
public final Vector4f specular;
|
||||
public final Vector4f position;
|
||||
public final Vector3f spotDirection;
|
||||
public float spotExponent;
|
||||
public float spotCutoff;
|
||||
public float constantAttenuation;
|
||||
public float linearAttenuation;
|
||||
public float quadraticAttenuation;
|
||||
|
||||
public LightState(int light) {
|
||||
this(
|
||||
light,
|
||||
new Vector4f(0F, 0F, 0F, 1F),
|
||||
new Vector4f(0F, 0F, 0F, 1F),
|
||||
new Vector4f(0F, 0F, 0F, 1F),
|
||||
new Vector4f(0F, 0F, 1F, 0F),
|
||||
new Vector3f(0F, 0F, -1F),
|
||||
0F,
|
||||
180F,
|
||||
1.0F,
|
||||
0.0F,
|
||||
0.0F
|
||||
);
|
||||
if (light == GL11.GL_LIGHT0) {
|
||||
this.diffuse.set(1F, 1F, 1F, 1F);
|
||||
this.specular.set(1F, 1F, 1F, 1F);
|
||||
}
|
||||
}
|
||||
|
||||
public LightState(int light, Vector4f ambient, Vector4f diffuse, Vector4f specular, Vector4f position, Vector3f spotDirection, float spotExponent, float spotCutoff, float constantAttenuation, float linearAttenuation, float quadraticAttenuation) {
|
||||
this.light = light;
|
||||
this.ambient = ambient;
|
||||
this.diffuse = diffuse;
|
||||
this.specular = specular;
|
||||
this.spotExponent = spotExponent;
|
||||
this.spotCutoff = spotCutoff;
|
||||
this.constantAttenuation = constantAttenuation;
|
||||
this.linearAttenuation = linearAttenuation;
|
||||
this.quadraticAttenuation = quadraticAttenuation;
|
||||
|
||||
this.position = position;
|
||||
this.position.mul(GLStateManager.getModelviewMatrix());
|
||||
|
||||
this.spotDirection = spotDirection;
|
||||
GLStateManager.getModelviewMatrix().get3x3(matrix3f);
|
||||
this.spotDirection.mul(matrix3f);
|
||||
}
|
||||
|
||||
public void setAmbient(FloatBuffer newBuffer) {
|
||||
vector4f.set(newBuffer);
|
||||
if (GLStateManager.shouldBypassCache() || !this.ambient.equals(vector4f)) {
|
||||
this.ambient.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_AMBIENT, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setAmbient(IntBuffer newBuffer) {
|
||||
vector4i.set(newBuffer);
|
||||
vector4f.set(i2f(vector4i.x), i2f(vector4i.y), i2f(vector4i.z), i2f(vector4i.w));
|
||||
if (GLStateManager.shouldBypassCache() || !this.ambient.equals(vector4f)) {
|
||||
this.ambient.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_AMBIENT, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setDiffuse(FloatBuffer newBuffer) {
|
||||
vector4f.set(newBuffer);
|
||||
if (GLStateManager.shouldBypassCache() || !this.diffuse.equals(vector4f)) {
|
||||
this.diffuse.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_DIFFUSE, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setDiffuse(IntBuffer newBuffer) {
|
||||
vector4i.set(newBuffer);
|
||||
vector4f.set(i2f(vector4i.x), i2f(vector4i.y), i2f(vector4i.z), i2f(vector4i.w));
|
||||
if (GLStateManager.shouldBypassCache() || !this.diffuse.equals(vector4f)) {
|
||||
this.diffuse.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_DIFFUSE, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setSpecular(FloatBuffer newBuffer) {
|
||||
vector4f.set(newBuffer);
|
||||
if (GLStateManager.shouldBypassCache() || !this.specular.equals(vector4f)) {
|
||||
this.specular.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_SPECULAR, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setSpecular(IntBuffer newBuffer) {
|
||||
vector4i.set(newBuffer);
|
||||
vector4f.set(i2f(vector4i.x), i2f(vector4i.y), i2f(vector4i.z), i2f(vector4i.w));
|
||||
if (GLStateManager.shouldBypassCache() || !this.specular.equals(vector4f)) {
|
||||
this.specular.set(vector4f);
|
||||
GL11.glLight(this.light, GL11.GL_SPECULAR, newBuffer);
|
||||
}
|
||||
}
|
||||
|
||||
public void setPosition(FloatBuffer newBuffer) {
|
||||
// We are bypassing cache everytime for position, because the necessary components to enable tracking the cache
|
||||
// are big and probably more than just bypassing. We would need to track the modelview matrix it was transformed
|
||||
// with and the untransformed coordinates in addition to the final transformation.
|
||||
this.position.set(newBuffer);
|
||||
this.position.mul(GLStateManager.getModelviewMatrix());
|
||||
GL11.glLight(this.light, GL11.GL_POSITION, newBuffer);
|
||||
}
|
||||
|
||||
public void setPosition(IntBuffer newBuffer) {
|
||||
vector4i.set(newBuffer);
|
||||
this.position.set((float) vector4i.x, (float) vector4i.y, (float) vector4i.z, (float) vector4i.w);
|
||||
this.position.mul(GLStateManager.getModelviewMatrix());
|
||||
GL11.glLight(this.light, GL11.GL_POSITION, newBuffer);
|
||||
}
|
||||
|
||||
public void setSpotDirection(FloatBuffer newBuffer) {
|
||||
// We are bypassing cache everytime for spot direction, because the necessary components to enable tracking the cache
|
||||
// are big and probably more than just bypassing. We would need to track the modelview matrix it was transformed
|
||||
// with and the untransformed coordinates in addition to the final transformation.
|
||||
GLStateManager.getModelviewMatrix().get3x3(matrix3f);
|
||||
this.spotDirection.set(newBuffer);
|
||||
this.spotDirection.mul(matrix3f);
|
||||
GL11.glLight(this.light, GL11.GL_SPOT_DIRECTION, newBuffer);
|
||||
}
|
||||
|
||||
public void setSpotDirection(IntBuffer newBuffer) {
|
||||
vector3i.set(newBuffer);
|
||||
GLStateManager.getModelviewMatrix().get3x3(matrix3f);
|
||||
this.spotDirection.set((float) vector3i.x, (float) vector3i.y, (float) vector3i.z);
|
||||
this.spotDirection.mul(matrix3f);
|
||||
GL11.glLight(this.light, GL11.GL_SPOT_DIRECTION, newBuffer);
|
||||
}
|
||||
|
||||
public void setSpotExponent(FloatBuffer newBuffer) {
|
||||
setSpotExponent(newBuffer.get());
|
||||
}
|
||||
|
||||
public void setSpotExponent(IntBuffer newBuffer) {
|
||||
setSpotExponent((float) newBuffer.get());
|
||||
}
|
||||
|
||||
public void setSpotExponent(int i) {
|
||||
setSpotExponent((float) i);
|
||||
}
|
||||
|
||||
public void setSpotExponent(float f) {
|
||||
if (GLStateManager.shouldBypassCache() || Float.compare(f, this.spotExponent) != 0) {
|
||||
this.spotExponent = f;
|
||||
GL11.glLightf(this.light, GL11.GL_SPOT_EXPONENT, f);
|
||||
}
|
||||
}
|
||||
|
||||
public void setSpotCutoff(FloatBuffer newBuffer) {
|
||||
setSpotCutoff(newBuffer.get());
|
||||
}
|
||||
|
||||
public void setSpotCutoff(IntBuffer newBuffer) {
|
||||
setSpotCutoff((float) newBuffer.get());
|
||||
}
|
||||
|
||||
public void setSpotCutoff(int i) {
|
||||
setSpotCutoff((float) i);
|
||||
}
|
||||
|
||||
public void setSpotCutoff(float f) {
|
||||
if (GLStateManager.shouldBypassCache() || Float.compare(f, this.spotCutoff) != 0) {
|
||||
this.spotCutoff = f;
|
||||
GL11.glLightf(this.light, GL11.GL_SPOT_CUTOFF, f);
|
||||
}
|
||||
}
|
||||
|
||||
public void setConstantAttenuation(FloatBuffer newBuffer) {
|
||||
setConstantAttenuation(newBuffer.get());
|
||||
}
|
||||
|
||||
public void setConstantAttenuation(IntBuffer newBuffer) {
|
||||
setConstantAttenuation((float) newBuffer.get());
|
||||
}
|
||||
|
||||
public void setConstantAttenuation(int i) {
|
||||
setConstantAttenuation((float) i);
|
||||
}
|
||||
|
||||
public void setConstantAttenuation(float f) {
|
||||
if (GLStateManager.shouldBypassCache() || Float.compare(f, this.constantAttenuation) != 0) {
|
||||
this.constantAttenuation = f;
|
||||
GL11.glLightf(this.light, GL11.GL_CONSTANT_ATTENUATION, f);
|
||||
}
|
||||
}
|
||||
|
||||
public void setLinearAttenuation(FloatBuffer newBuffer) {
|
||||
setLinearAttenuation(newBuffer.get());
|
||||
}
|
||||
|
||||
public void setLinearAttenuation(IntBuffer newBuffer) {
|
||||
setLinearAttenuation((float) newBuffer.get());
|
||||
}
|
||||
|
||||
public void setLinearAttenuation(int i) {
|
||||
setLinearAttenuation((float) i);
|
||||
}
|
||||
|
||||
public void setLinearAttenuation(float f) {
|
||||
if (GLStateManager.shouldBypassCache() || Float.compare(f, this.linearAttenuation) != 0) {
|
||||
this.linearAttenuation = f;
|
||||
GL11.glLightf(this.light, GL11.GL_LINEAR_ATTENUATION, f);
|
||||
}
|
||||
}
|
||||
|
||||
public void setQuadraticAttenuation(FloatBuffer newBuffer) {
|
||||
setQuadraticAttenuation(newBuffer.get());
|
||||
}
|
||||
|
||||
public void setQuadraticAttenuation(IntBuffer newBuffer) {
|
||||
setQuadraticAttenuation((float) newBuffer.get());
|
||||
}
|
||||
|
||||
public void setQuadraticAttenuation(int i) {
|
||||
setQuadraticAttenuation((float) i);
|
||||
}
|
||||
|
||||
public void setQuadraticAttenuation(float f) {
|
||||
if (GLStateManager.shouldBypassCache() || Float.compare(f, this.quadraticAttenuation) != 0) {
|
||||
this.quadraticAttenuation = f;
|
||||
GL11.glLightf(this.light, GL11.GL_QUADRATIC_ATTENUATION, f);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public LightState set(LightState state) {
|
||||
this.ambient.set(state.ambient);
|
||||
this.diffuse.set(state.diffuse);
|
||||
this.specular.set(state.specular);
|
||||
this.position.set(state.position);
|
||||
this.spotDirection.set(state.spotDirection);
|
||||
this.spotExponent = state.spotExponent;
|
||||
this.spotCutoff = state.spotCutoff;
|
||||
this.constantAttenuation = state.constantAttenuation;
|
||||
this.linearAttenuation = state.linearAttenuation;
|
||||
this.quadraticAttenuation = state.quadraticAttenuation;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameAs(Object state) {
|
||||
if (this == state) return true;
|
||||
if (!(state instanceof LightState lightState)) return false;
|
||||
return this.ambient.equals(lightState.ambient)
|
||||
&& this.diffuse.equals(lightState.diffuse)
|
||||
&& this.specular.equals(lightState.specular)
|
||||
&& this.position.equals(lightState.position)
|
||||
&& this.spotDirection.equals(lightState.spotDirection)
|
||||
&& Float.compare(this.spotCutoff, lightState.spotCutoff) == 0
|
||||
&& Float.compare(this.spotExponent, lightState.spotExponent) == 0
|
||||
&& Float.compare(this.linearAttenuation, lightState.linearAttenuation) == 0
|
||||
&& Float.compare(this.constantAttenuation, lightState.constantAttenuation) == 0
|
||||
&& Float.compare(this.quadraticAttenuation, lightState.quadraticAttenuation) == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public LightState copy() { return new LightState(this.light).set(this); }
|
||||
|
||||
}
|
||||
@@ -4,6 +4,7 @@ import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.mixins.early.angelica.hudcaching.RenderGameOverlayEventAccessor;
|
||||
import cpw.mods.fml.common.eventhandler.EventPriority;
|
||||
import net.dries007.holoInventory.client.Renderer;
|
||||
@@ -43,6 +44,7 @@ public class HUDCaching {
|
||||
private static final Minecraft mc = Minecraft.getMinecraft();
|
||||
public static Framebuffer framebuffer;
|
||||
private static boolean dirty = true;
|
||||
private static long nextHudRefresh;
|
||||
|
||||
public static boolean renderingCacheOverride;
|
||||
|
||||
@@ -106,13 +108,6 @@ public class HUDCaching {
|
||||
|
||||
/* TODO END REMOVE DEBUG STUFF */
|
||||
|
||||
@SubscribeEvent
|
||||
public void onTick(TickEvent.ClientTickEvent event) {
|
||||
if (event.phase == TickEvent.Phase.END) {
|
||||
dirty = true;
|
||||
}
|
||||
}
|
||||
|
||||
// highest so it runs before the GLSM load event
|
||||
@SubscribeEvent(priority = EventPriority.HIGH)
|
||||
public void onJoinWorld(WorldEvent.Load event) {
|
||||
@@ -136,8 +131,13 @@ public class HUDCaching {
|
||||
return;
|
||||
}
|
||||
|
||||
if (System.currentTimeMillis() > nextHudRefresh) {
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
if (dirty) {
|
||||
dirty = false;
|
||||
nextHudRefresh = System.currentTimeMillis() + (1000 / AngelicaConfig.hudCachingFPS);
|
||||
resetFramebuffer(mc.displayWidth, mc.displayHeight);
|
||||
framebuffer.bindFramebuffer(false);
|
||||
renderingCacheOverride = true;
|
||||
|
||||
@@ -207,6 +207,11 @@ public enum Mixins {
|
||||
"client.extrautils.MixinRenderBlockConnectedTexturesEthereal",
|
||||
"client.extrautils.MixinIconConnectedTexture")),
|
||||
|
||||
MFR_THREAD_SAFETY(new Builder("Enable thread safety fixes for MineFactory Reloaded").setPhase(Phase.LATE)
|
||||
.addTargetedMod(TargetedMod.MINEFACTORY_RELOADED).setSide(Side.CLIENT)
|
||||
.setApplyIf(() -> AngelicaConfig.fixMineFactoryReloadedSodiumCompat)
|
||||
.addMixinClasses("client.minefactoryreloaded.MixinRedNetCableRenderer")),
|
||||
|
||||
SPEEDUP_CAMPFIRE_BACKPORT_ANIMATIONS(new Builder("Add animation speedup support to Campfire Backport").setPhase(Phase.LATE)
|
||||
.addTargetedMod(TargetedMod.CAMPFIRE_BACKPORT).setSide(Side.CLIENT)
|
||||
.setApplyIf(() -> AngelicaConfig.speedupAnimations)
|
||||
|
||||
@@ -15,6 +15,7 @@ public enum TargetedMod {
|
||||
, DYNAMIC_SURROUNDINGS_MIST("Dynamic Surroundings", "org.blockartistry.mod.DynSurround.mixinplugin.DynamicSurroundingsEarlyMixins", "dsurround")
|
||||
, DYNAMIC_SURROUNDINGS_ORIGINAL("Dynamic Surroundings", "org.blockartistry.mod.DynSurround.asm.TransformLoader", "dsurround")
|
||||
, EXTRAUTILS("ExtraUtilities", null, "ExtraUtilities")
|
||||
, MINEFACTORY_RELOADED("MineFactory Reloaded", null, "MineFactoryReloaded")
|
||||
, GTNHLIB("GTNHLib", "com.gtnewhorizon.gtnhlib.core.GTNHLibCore", "gtnhlib")
|
||||
, IC2("IC2", "ic2.core.coremod.IC2core", "IC2")
|
||||
, JABBA("JABBA", null, "JABBA")
|
||||
|
||||
+6
@@ -7,6 +7,7 @@ import net.minecraft.entity.EntityLivingBase;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.ModifyArg;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
|
||||
|
||||
@Mixin(EntityRenderer.class)
|
||||
@@ -23,4 +24,9 @@ public abstract class MixinEntityRenderer {
|
||||
);
|
||||
}
|
||||
|
||||
@ModifyArg(method = "setupCameraTransform", at = @At(value = "INVOKE", target = "Lorg/lwjgl/util/glu/Project;gluPerspective(FFFF)V", ordinal = 0), index = 0)
|
||||
private float captureFov(float fov) {
|
||||
RenderingState.INSTANCE.setFov(fov);
|
||||
return fov;
|
||||
}
|
||||
}
|
||||
@@ -5,6 +5,9 @@ import net.minecraft.world.World;
|
||||
import net.minecraft.world.biome.BiomeGenBase;
|
||||
import net.minecraft.world.biome.WorldChunkManager;
|
||||
import net.minecraft.world.chunk.Chunk;
|
||||
|
||||
import com.gtnewhorizons.angelica.compat.ModStatus;
|
||||
import com.gtnewhorizons.angelica.compat.endlessids.EndlessIDsCompat;
|
||||
import org.spongepowered.asm.mixin.Final;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.Shadow;
|
||||
@@ -29,14 +32,18 @@ public abstract class MixinChunk {
|
||||
if(this.worldObj.isRemote && !Minecraft.getMinecraft().isSingleplayer()) {
|
||||
// We are in multiplayer, the server might not have sent all biomes to the client.
|
||||
// Populate them now while we're on the main thread.
|
||||
WorldChunkManager manager = this.worldObj.getWorldChunkManager();
|
||||
for(int z = 0; z < 16; z++) {
|
||||
for(int x = 0; x < 16; x++) {
|
||||
int idx = (z << 4) + x;
|
||||
int biome = this.blockBiomeArray[idx] & 255;
|
||||
if(biome == 255) {
|
||||
BiomeGenBase generated = manager.getBiomeGenAt((this.xPosition << 4) + x, (this.zPosition << 4) + z);
|
||||
this.blockBiomeArray[idx] = (byte)(generated.biomeID & 255);
|
||||
if (ModStatus.isEIDBiomeLoaded) {
|
||||
EndlessIDsCompat.sodium$populateBiomes((Chunk) (Object) this);
|
||||
} else {
|
||||
WorldChunkManager manager = this.worldObj.getWorldChunkManager();
|
||||
for (int z = 0; z < 16; z++) {
|
||||
for (int x = 0; x < 16; x++) {
|
||||
int idx = (z << 4) + x;
|
||||
int biome = this.blockBiomeArray[idx] & 255;
|
||||
if (biome == 255) {
|
||||
BiomeGenBase generated = manager.getBiomeGenAt((this.xPosition << 4) + x, (this.zPosition << 4) + z);
|
||||
this.blockBiomeArray[idx] = (byte) (generated.biomeID & 255);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
package com.gtnewhorizons.angelica.mixins.late.client.minefactoryreloaded;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.client.renderer.RenderBlocks;
|
||||
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
|
||||
import net.minecraft.world.IBlockAccess;
|
||||
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
|
||||
import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
|
||||
|
||||
import powercrystals.minefactoryreloaded.render.block.RedNetCableRenderer;
|
||||
import powercrystals.minefactoryreloaded.tile.rednet.TileEntityRedNetCable;
|
||||
|
||||
@Mixin(value = RedNetCableRenderer.class)
|
||||
public abstract class MixinRedNetCableRenderer extends TileEntitySpecialRenderer {
|
||||
|
||||
/**
|
||||
* @author JL2210
|
||||
* @reason Thread safety compat (check result of getTileEntity for null)
|
||||
*/
|
||||
@Inject(method = "renderWorldBlock", at = @At(value = "FIELD", target = "Lpowercrystals/minefactoryreloaded/setup/MFRConfig;TESRCables*:Z"), locals = LocalCapture.CAPTURE_FAILHARD, cancellable = true, remap = false)
|
||||
public void angelica$checkNullBeforeAccess(IBlockAccess world, int x, int y, int z, Block block, int modelId,
|
||||
RenderBlocks renderer, CallbackInfoReturnable<Boolean> cir, TileEntityRedNetCable _cable) {
|
||||
if (_cable == null) {
|
||||
cir.setReturnValue(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,6 +64,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
private VertexBuffer vbo;
|
||||
private int cloudMode = -1;
|
||||
private int renderDistance = -1;
|
||||
private int cloudElevation = -1;
|
||||
private int scaleMult = -1;
|
||||
|
||||
private DynamicTexture COLOR_TEX = null;
|
||||
|
||||
@@ -82,9 +84,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
return instance;
|
||||
}
|
||||
|
||||
|
||||
private int getScale() {
|
||||
return cloudMode == 2 ? 12 : 8;
|
||||
return (cloudMode == 2 ? 12 : 8) * scaleMult;
|
||||
}
|
||||
|
||||
private float ceilToScale(float value) {
|
||||
@@ -139,11 +140,12 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
tessellator.pos(sectX0, 0, sectZ1).tex(u0, v1).color(bCol, bCol, bCol, ALPHA).endVertex();
|
||||
|
||||
if (fancy) {
|
||||
final int height = HEIGHT * scaleMult;
|
||||
// Top
|
||||
tessellator.pos(sectX0, HEIGHT, sectZ0).tex(u0, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, HEIGHT, sectZ1).tex(u0, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, HEIGHT, sectZ1).tex(u1, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, HEIGHT, sectZ0).tex(u1, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, sectZ0).tex(u0, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, sectZ1).tex(u0, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, sectZ1).tex(u1, v1).color(1, 1, 1, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, sectZ0).tex(u1, v0).color(1, 1, 1, ALPHA).endVertex();
|
||||
|
||||
float slice;
|
||||
float sliceCoord0;
|
||||
@@ -157,8 +159,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
if (slice > -CULL_DIST) {
|
||||
slice += INSET;
|
||||
tessellator.pos(slice, 0, sectZ1).tex(sliceCoord0, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, HEIGHT, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, HEIGHT, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, 0, sectZ0).tex(sliceCoord0, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
slice -= INSET;
|
||||
}
|
||||
@@ -168,8 +170,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
if (slice <= CULL_DIST) {
|
||||
slice -= INSET;
|
||||
tessellator.pos(slice, 0, sectZ0).tex(sliceCoord0, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, HEIGHT, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, HEIGHT, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ0).tex(sliceCoord1, v0).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, height, sectZ1).tex(sliceCoord1, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
tessellator.pos(slice, 0, sectZ1).tex(sliceCoord0, v1).color(0.9F, 0.9F, 0.9F, ALPHA).endVertex();
|
||||
slice += INSET;
|
||||
}
|
||||
@@ -183,8 +185,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
if (slice > -CULL_DIST) {
|
||||
slice += INSET;
|
||||
tessellator.pos(sectX0, 0, slice).tex(u0, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, HEIGHT, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, HEIGHT, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, 0, slice).tex(u1, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
slice -= INSET;
|
||||
}
|
||||
@@ -194,8 +196,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
if (slice <= CULL_DIST) {
|
||||
slice -= INSET;
|
||||
tessellator.pos(sectX1, 0, slice).tex(u1, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, HEIGHT, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, HEIGHT, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX1, height, slice).tex(u1, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, height, slice).tex(u0, sliceCoord1).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
tessellator.pos(sectX0, 0, slice).tex(u0, sliceCoord0).color(0.8F, 0.8F, 0.8F, ALPHA).endVertex();
|
||||
slice += INSET;
|
||||
}
|
||||
@@ -238,21 +240,32 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
|
||||
public void checkSettings() {
|
||||
GraphicsQualityOff cloudGraphicsQuality = (GraphicsQualityOff)Settings.MODE_CLOUDS.option.getStore();
|
||||
final int cloudQualitySetting = cloudGraphicsQuality == GraphicsQualityOff.FANCY
|
||||
final int cloudQualitySetting = cloudGraphicsQuality == GraphicsQualityOff.FANCY
|
||||
|| cloudGraphicsQuality == GraphicsQualityOff.DEFAULT && mc.gameSettings.fancyGraphics ? 2 : 1;
|
||||
boolean newEnabled = mc.gameSettings.shouldRenderClouds()
|
||||
final boolean newEnabled = mc.gameSettings.shouldRenderClouds()
|
||||
&& mc.theWorld != null
|
||||
&& mc.theWorld.provider.isSurfaceWorld();
|
||||
final int targetDistance = Math.max(mc.gameSettings.renderDistanceChunks, (int)Settings.RENDER_DISTANCE_CLOUDS.option.getStore());
|
||||
final int cloudScaleMult = (int)Settings.CLOUD_SCALE.option.getStore();
|
||||
|
||||
if (isBuilt()
|
||||
&& (!newEnabled
|
||||
|| cloudQualitySetting != cloudMode
|
||||
|| mc.gameSettings.renderDistanceChunks != renderDistance)) {
|
||||
|| targetDistance != renderDistance
|
||||
|| cloudScaleMult != scaleMult)) {
|
||||
dispose();
|
||||
}
|
||||
|
||||
cloudMode = cloudQualitySetting;
|
||||
renderDistance = mc.gameSettings.renderDistanceChunks;
|
||||
renderDistance = targetDistance;
|
||||
scaleMult = cloudScaleMult;
|
||||
|
||||
cloudElevation = mc.theWorld == null ? 128 : (int)mc.theWorld.provider.getCloudHeight();
|
||||
//Allows the setting to work with RFG and similar without hardcoding.
|
||||
//The minimum height check is so stuff like Aether cloud height doesn't get messed up.
|
||||
if(cloudElevation >= 96) {
|
||||
cloudElevation = (int)Settings.CLOUD_HEIGHT.option.getStore();
|
||||
}
|
||||
|
||||
if (newEnabled && !isBuilt()) {
|
||||
build();
|
||||
@@ -268,7 +281,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
|
||||
double totalOffset = cloudTicks + partialTicks;
|
||||
|
||||
double x = entity.prevPosX + (entity.posX - entity.prevPosX) * partialTicks + totalOffset * 0.03;
|
||||
double y = mc.theWorld.provider.getCloudHeight() - (entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks) + 0.33;
|
||||
double y = cloudElevation - (entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks) + 0.33;
|
||||
double z = entity.prevPosZ + (entity.posZ - entity.prevPosZ) * partialTicks;
|
||||
|
||||
int scale = getScale();
|
||||
|
||||
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.rendering;
|
||||
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.joml.Matrix4f;
|
||||
import org.joml.Vector3d;
|
||||
import org.lwjgl.BufferUtils;
|
||||
@@ -21,6 +22,9 @@ public class RenderingState {
|
||||
private final Matrix4f projectionMatrix = new Matrix4f().identity();
|
||||
@Getter
|
||||
private final Matrix4f modelViewMatrix = new Matrix4f().identity();
|
||||
@Getter
|
||||
@Setter
|
||||
private float fov;
|
||||
|
||||
|
||||
public void setCameraPosition(double x, double y, double z) {
|
||||
|
||||
@@ -145,6 +145,8 @@ public class RedirectorTransformer implements IClassTransformer {
|
||||
.add("glGetTexParameteri")
|
||||
.add("glIsEnabled")
|
||||
.add("glLight")
|
||||
.add("glLightf")
|
||||
.add("glLighti")
|
||||
.add("glLightModel")
|
||||
.add("glLightModelf")
|
||||
.add("glLightModeli")
|
||||
|
||||
@@ -40,7 +40,7 @@ public enum Settings {
|
||||
SettingsManager.cloudsUpdated();
|
||||
}
|
||||
},
|
||||
CLOUD_SCALE(new NotFineOptionSlider(4, 2, 20, 1, null)),
|
||||
CLOUD_SCALE(new NotFineOptionSlider(1, 1, 3, 1, null)),
|
||||
DOWNFALL_DISTANCE(new NotFineOptionCycling<>(DownfallQuality.DEFAULT, OptionImpact.MEDIUM)) {
|
||||
@Override
|
||||
public void applyChanges() {
|
||||
@@ -112,7 +112,7 @@ public enum Settings {
|
||||
},
|
||||
PARTICLES_ENC_TABLE(new NotFineOptionSlider(1, 0, 16, 1, OptionImpact.LOW)),
|
||||
PARTICLES_VOID(new NotFineOptionTickBox(true, OptionImpact.LOW)),
|
||||
RENDER_DISTANCE_CLOUDS(new NotFineOptionSlider(4, 4, 64, 2, OptionImpact.VARIES)) {
|
||||
RENDER_DISTANCE_CLOUDS(new NotFineOptionSlider(4, 4, 64, 1, OptionImpact.VARIES)) {
|
||||
@Override
|
||||
public void applyChanges() {
|
||||
SettingsManager.cloudsUpdated();
|
||||
@@ -172,8 +172,7 @@ public enum Settings {
|
||||
|
||||
@Override
|
||||
public Control<Integer> getControl() {
|
||||
//TODO: Don't hardcode CLOUD_SCALE check.
|
||||
return new SliderControl(this, min, max, step, setting != Settings.CLOUD_SCALE ? ControlValueFormatter.number() : NotFineControlValueFormatter.multiplied(0.25f));
|
||||
return new SliderControl(this, min, max, step, ControlValueFormatter.number());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -57,8 +57,8 @@ public class SettingsManager {
|
||||
|
||||
public static void cloudsUpdated() {
|
||||
if(Settings.MODE_CLOUDS.option.getStore() != GraphicsQualityOff.OFF) {
|
||||
minimumFarPlaneDistance = 32 * (int)Settings.RENDER_DISTANCE_CLOUDS.option.getStore();
|
||||
minimumFarPlaneDistance += Math.abs((int)Settings.CLOUD_HEIGHT.option.getStore());
|
||||
minimumFarPlaneDistance = 32 * ((int)Settings.RENDER_DISTANCE_CLOUDS.option.getStore());
|
||||
minimumFarPlaneDistance += (int)Settings.CLOUD_HEIGHT.option.getStore();
|
||||
mc.gameSettings.clouds = true;
|
||||
} else {
|
||||
minimumFarPlaneDistance = 128;
|
||||
|
||||
@@ -206,9 +206,9 @@ public class NotFineGameOptionPages {
|
||||
.add(Settings.MODE_SKY.option)
|
||||
.add(Settings.MODE_SUN_MOON.option)
|
||||
.add(Settings.MODE_CLOUDS.option)
|
||||
//.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.CLOUD_HEIGHT.option)
|
||||
//.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.MODE_CLOUD_TRANSLUCENCY.option)
|
||||
.add(Settings.MODE_STARS.option)
|
||||
.add(Settings.TOTAL_STARS.option)
|
||||
|
||||
@@ -81,9 +81,9 @@ public class SodiumGameOptionPages {
|
||||
firstGroupBuilder.add(Settings.MODE_LIGHT_FLICKER.option)
|
||||
.add(Settings.MODE_SKY.option)
|
||||
.add(Settings.MODE_SUN_MOON.option)
|
||||
//.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.RENDER_DISTANCE_CLOUDS.option)
|
||||
.add(Settings.CLOUD_HEIGHT.option)
|
||||
//.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.CLOUD_SCALE.option)
|
||||
.add(Settings.MODE_CLOUD_TRANSLUCENCY.option)
|
||||
.add(Settings.MODE_STARS.option)
|
||||
.add(Settings.TOTAL_STARS.option)
|
||||
|
||||
@@ -7,6 +7,7 @@ import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
|
||||
import com.gtnewhorizons.angelica.config.AngelicaConfig;
|
||||
import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
|
||||
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
||||
import com.gtnewhorizons.angelica.rendering.RenderingState;
|
||||
import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
|
||||
import it.unimi.dsi.fastutil.longs.LongSet;
|
||||
import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
|
||||
@@ -64,6 +65,7 @@ public class SodiumWorldRenderer implements ChunkStatusListener {
|
||||
private int renderDistance;
|
||||
|
||||
private double lastCameraX, lastCameraY, lastCameraZ;
|
||||
private float lastFov;
|
||||
private double lastCameraPitch, lastCameraYaw;
|
||||
private float lastFogDistance;
|
||||
|
||||
@@ -213,8 +215,10 @@ public class SodiumWorldRenderer implements ChunkStatusListener {
|
||||
|
||||
float fogDistance = FogHelper.getFogCutoff();
|
||||
|
||||
float fov = RenderingState.INSTANCE.getFov();
|
||||
|
||||
boolean dirty = pos.x != this.lastCameraX || pos.y != this.lastCameraY || pos.z != this.lastCameraZ ||
|
||||
pitch != this.lastCameraPitch || yaw != this.lastCameraYaw || fogDistance != this.lastFogDistance;
|
||||
pitch != this.lastCameraPitch || yaw != this.lastCameraYaw || fogDistance != this.lastFogDistance || fov != this.lastFov;
|
||||
|
||||
if(AngelicaConfig.enableIris) {
|
||||
iris$ensureStateSwapped();
|
||||
@@ -232,6 +236,7 @@ public class SodiumWorldRenderer implements ChunkStatusListener {
|
||||
this.lastCameraPitch = pitch;
|
||||
this.lastCameraYaw = yaw;
|
||||
this.lastFogDistance = fogDistance;
|
||||
this.lastFov = fov;
|
||||
|
||||
profiler.endStartSection("chunk_update");
|
||||
|
||||
|
||||
@@ -45,6 +45,7 @@ public class FluidRenderer {
|
||||
private final QuadLightData quadLightData = new QuadLightData();
|
||||
private boolean useSeparateAo;
|
||||
private final int[] quadColors = new int[4];
|
||||
private final TextureAtlasSprite missingTex = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite("minecraft:missing");
|
||||
|
||||
public FluidRenderer(LightPipelineProvider lpp) {
|
||||
int normal = Norm3b.pack(0.0f, 1.0f, 0.0f);
|
||||
@@ -95,7 +96,7 @@ public class FluidRenderer {
|
||||
int posZ = pos.z;
|
||||
|
||||
Fluid fluid = ((IFluidBlock) block).getFluid();
|
||||
if(fluid == null) return false;
|
||||
if (fluid == null) return false;
|
||||
|
||||
// Check for occluded sides; if everything is occluded, don't render
|
||||
boolean sfUp = this.isFluidOccluded(world, posX, posY, posZ, ForgeDirection.UP, fluid);
|
||||
@@ -117,6 +118,11 @@ public class FluidRenderer {
|
||||
(TextureAtlasSprite) fluid.getFlowingIcon(),
|
||||
null
|
||||
};
|
||||
|
||||
// Because some mods are wack and return null textures here
|
||||
sprites[0] = sprites[0] == null ? missingTex : sprites[0];
|
||||
sprites[1] = sprites[1] == null ? missingTex : sprites[1];
|
||||
|
||||
boolean hc = fluid.getColor() != 0xffffffff;
|
||||
|
||||
boolean rendered = false;
|
||||
|
||||
@@ -126,6 +126,8 @@ options.iris.shadowDistance.enabled=Allows you to change the maximum distance fo
|
||||
options.iris.shadowDistance.disabled=Your current shader pack has already set a render distance for shadows; you cannot change it.
|
||||
options.iris.gui.hide=Hide GUI
|
||||
options.iris.gui.show=Show GUI
|
||||
options.dynamic_lights=Dynamic Lights
|
||||
options.dynamic_lights.tooltip=Enables dynamic lights. Modes: OFF - off, FASTEST - 500ms delay, FAST - 250ms delay, FANCY - no delay
|
||||
pack.iris.select.title=Select
|
||||
pack.iris.configure.title=Configure
|
||||
label.iris.true=On
|
||||
|
||||
@@ -10,7 +10,7 @@ options.graphics.smart=Smart
|
||||
options.graphics.ultra=Ultra
|
||||
options.off=Off
|
||||
options.on=On
|
||||
options.cloud_height=Cloud Height
|
||||
options.cloud_height=Cloud Elevation
|
||||
options.cloud_scale=Cloud Scale
|
||||
options.gui_background=Background
|
||||
options.downfall_distance=Weather Effects
|
||||
@@ -33,7 +33,7 @@ options.mode_water=Water
|
||||
options.mode_vignette=Vignette
|
||||
options.particles_enc_table=Enchantment Particles
|
||||
options.particles_void=Void Particles
|
||||
options.render_distance_clouds=Cloud Render Distance
|
||||
options.render_distance_clouds=Minimum Cloud Distance
|
||||
options.title.detail=Detail Settings
|
||||
options.title.other=Other Settings
|
||||
options.title.particle=Particle Settings
|
||||
|
||||
@@ -0,0 +1,167 @@
|
||||
package com.gtnewhorizons.angelica.glsm;
|
||||
|
||||
import com.gtnewhorizons.angelica.AngelicaExtension;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyLightState;
|
||||
import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
|
||||
|
||||
@ExtendWith(AngelicaExtension.class)
|
||||
public class GLSM_Lighting_UnitTest {
|
||||
|
||||
static final FloatBuffer f4b = ByteBuffer.allocateDirect(4 << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
static final FloatBuffer f3b = ByteBuffer.allocateDirect(3 << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
|
||||
@Test
|
||||
void testLightEnablement() {
|
||||
verifyState(GL11.GL_LIGHT0, false, "GL_LIGHT0 Initial State");
|
||||
GLStateManager.glEnable(GL11.GL_LIGHT0);
|
||||
verifyState(GL11.GL_LIGHT0, true, "GL_LIGHT0 Enabled");
|
||||
|
||||
verifyState(GL11.GL_LIGHT1, false, "GL_LIGHT1 Initial State");
|
||||
GLStateManager.glEnable(GL11.GL_LIGHT1);
|
||||
verifyState(GL11.GL_LIGHT1, true, "GL_LIGHT1 Enabled State");
|
||||
|
||||
GLStateManager.glDisable(GL11.GL_LIGHT0);
|
||||
GLStateManager.glDisable(GL11.GL_LIGHT1);
|
||||
}
|
||||
|
||||
@Test
|
||||
void testLightValues() {
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, new float[]{0F, 0F, 0F, 1F}, "GL_LIGHT0 Initial Ambient");
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, new float[]{1F, 1F, 1F, 1F}, "GL_LIGHT0 Initial Diffuse");
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, new float[]{1F, 1F, 1F, 1F}, "GL_LIGHT0 Initial Specular");
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, new float[]{0F, 0F, 1F, 0F}, "GL_LIGHT0 Initial Position");
|
||||
|
||||
verifyLightState(GL11.GL_LIGHT1, GL11.GL_AMBIENT, new float[]{0F, 0F, 0F, 1F}, "GL_LIGHT1 Initial Ambient");
|
||||
verifyLightState(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, new float[]{0F, 0F, 0F, 1F}, "GL_LIGHT1 Initial Diffuse");
|
||||
verifyLightState(GL11.GL_LIGHT1, GL11.GL_SPECULAR, new float[]{0F, 0F, 0F, 1F}, "GL_LIGHT1 Initial Specular");
|
||||
verifyLightState(GL11.GL_LIGHT1, GL11.GL_POSITION, new float[]{0F, 0F, 1F, 0F}, "GL_LIGHT1 Initial Position");
|
||||
|
||||
newf4b(0.25F, 0.5F, 0.25F, 0.5F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_AMBIENT, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 Ambient Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
newf4b(0.3F, 0.4F, 0.5F, 0.6F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_AMBIENT, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, new float[]{0.3F, 0.4F, 0.5F, 0.6F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_AMBIENT, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
// The position is stored in eye coordinates, so we're moving around the modelview matrix before changing them
|
||||
// That way we can test that the client side transformation of them via GLSM is working and matches the OpenGL
|
||||
// transformation. This doesn't seem like float precision should break this test, but it may be possible for it
|
||||
// to need tweaked a bit more.
|
||||
GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
GLStateManager.glPushMatrix();
|
||||
GLStateManager.glTranslatef(25.0F, 25.0F, 25.0F);
|
||||
GLStateManager.glRotatef(35.0F, 10.0F, 15.0F, 20.0F);
|
||||
newf4b(0.25F, 0.5F, 0.25F, 0.0F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_POSITION, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, new float[]{0.1090F, 0.5189F, 0.3062F, 0.0F}, "GL_LIGHT0 Position Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
newf4b(0.3F, 0.4F, 0.5F, 0.0F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_POSITION, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, new float[]{0.2824F, 0.4200F, 0.4937F, 0.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_POSITION, new float[]{0.1090F, 0.5189F, 0.3062F, 0.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
GLStateManager.glPopMatrix();
|
||||
|
||||
newf4b(0.25F, 0.5F, 0.25F, 0.5F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 Diffuse Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
newf4b(0.3F, 0.4F, 0.5F, 0.6F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, new float[]{0.3F, 0.4F, 0.5F, 0.6F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_DIFFUSE, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
newf4b(0.25F, 0.5F, 0.25F, 0.5F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPECULAR, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 Specular Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
newf4b(0.3F, 0.4F, 0.5F, 0.6F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPECULAR, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, new float[]{0.3F, 0.4F, 0.5F, 0.6F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPECULAR, new float[]{0.25F, 0.5F, 0.25F, 0.5F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
|
||||
GLStateManager.glPushMatrix();
|
||||
GLStateManager.glTranslatef(25.0F, 25.0F, 25.0F);
|
||||
GLStateManager.glRotatef(35.0F, 10.0F, 15.0F, 20.0F);
|
||||
newf4b(0.25F, 0.5F, 0.25F, 0.0F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, new float[]{0.1090F, 0.5189F, 0.3062F}, "GL_LIGHT0 Spot Direction Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
newf4b(0.3F, 0.4F, 0.5F, 0.0F);
|
||||
GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, f4b);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, new float[]{0.2824F, 0.4200F, 0.4937F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_DIRECTION, new float[]{0.1090F, 0.5189F, 0.3062F}, "GL_LIGHT0 attrib pop state check");
|
||||
GLStateManager.glPopMatrix();
|
||||
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_SPOT_EXPONENT, 1.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_EXPONENT, new float[]{1.0F}, "GL_LIGHT0 Spot Exponent Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_SPOT_EXPONENT, 2.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_EXPONENT, new float[]{2.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_EXPONENT, new float[]{1.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_SPOT_CUTOFF, 20.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_CUTOFF, new float[]{20.0F}, "GL_LIGHT0 Spot Cutoff Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_SPOT_CUTOFF, 40.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_CUTOFF, new float[]{40.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_SPOT_CUTOFF, new float[]{20.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_CONSTANT_ATTENUATION, 10.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_CONSTANT_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 Constant Attenuation Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_CONSTANT_ATTENUATION, 20.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_CONSTANT_ATTENUATION, new float[]{20.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_CONSTANT_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_LINEAR_ATTENUATION, 10.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_LINEAR_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 Linear Attenuation Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_LINEAR_ATTENUATION, 20.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_LINEAR_ATTENUATION, new float[]{20.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_LINEAR_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_QUADRATIC_ATTENUATION, 10.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_QUADRATIC_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 Quadratic Attenuation Changed State");
|
||||
GLStateManager.glPushAttrib(GL11.GL_LIGHTING_BIT);
|
||||
GLStateManager.glLightf(GL11.GL_LIGHT0, GL11.GL_QUADRATIC_ATTENUATION, 20.0F);
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_QUADRATIC_ATTENUATION, new float[]{20.0F}, "GL_LIGHT0 attrib push state changed check");
|
||||
GLStateManager.glPopAttrib();
|
||||
verifyLightState(GL11.GL_LIGHT0, GL11.GL_QUADRATIC_ATTENUATION, new float[]{10.0F}, "GL_LIGHT0 attrib pop state check");
|
||||
|
||||
GLStateManager.glPopAttrib();
|
||||
}
|
||||
|
||||
static void newf4b(float x, float y, float z, float w) {
|
||||
f4b.clear();
|
||||
f4b.put(x).put(y).put(z).put(w);
|
||||
f4b.flip();
|
||||
}
|
||||
|
||||
static void newf3b(float x, float y, float z) {
|
||||
f3b.clear();
|
||||
f3b.put(x).put(y).put(z);
|
||||
f3b.flip();
|
||||
}
|
||||
}
|
||||
@@ -133,10 +133,10 @@ class GLSM_PushPop_UnitTest {
|
||||
GLStateManager.glNormal3f(0.5f, 0.5f, 0.5f);
|
||||
GLStateManager.glTexCoord4f(0.5f, 0.5f, 0.5f, 0.5f); // Current texture coordinates
|
||||
GLStateManager.glRasterPos4f(0.5f, 0.5f, 0.5f, 0.5f); // Current raster position
|
||||
// GL_CURRENT_RASTER_POSITION_VALID flag
|
||||
// RGBA color associated with current raster position
|
||||
// Color index associated with current raster position
|
||||
// Texture coordinates associated with current raster position
|
||||
// GL_CURRENT_RASTER_POSITION_VALID flag
|
||||
// RGBA color associated with current raster position
|
||||
// Color index associated with current raster position
|
||||
// Texture coordinates associated with current raster position
|
||||
GLStateManager.glEdgeFlag(false); // GL_EDGE_FLAG flag
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user