diff --git a/build.gradle b/build.gradle index 37dd56d3a..12c3a85e8 100644 --- a/build.gradle +++ b/build.gradle @@ -29,10 +29,10 @@ subprojects { // parchment mappings as backup parchment("org.parchmentmc.data:parchment-${rootProject.minecraft_version}:${rootProject.parchment_version}@zip") } - implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}") - implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux") - implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos") - implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows") + implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}") { transitive = false } + implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux") { transitive = false } + implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos") { transitive = false } + implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows") { transitive = false } // for OSC tracker support implementation("com.illposed.osc:javaosc-core:0.9") diff --git a/common/src/main/java/org/vivecraft/client/ClientVRPlayers.java b/common/src/main/java/org/vivecraft/client/ClientVRPlayers.java index 1fb6baac8..7843215de 100644 --- a/common/src/main/java/org/vivecraft/client/ClientVRPlayers.java +++ b/common/src/main/java/org/vivecraft/client/ClientVRPlayers.java @@ -24,6 +24,7 @@ import org.vivecraft.client_vr.render.helpers.RenderHelper; import org.vivecraft.client_vr.settings.AutoCalibration; import org.vivecraft.client_vr.settings.VRSettings; +import org.vivecraft.client_xr.render_pass.RenderPassType; import org.vivecraft.common.network.FBTMode; import org.vivecraft.common.network.VrPlayerState; import org.vivecraft.common.utils.MathUtils; @@ -228,7 +229,9 @@ public void tick() { Vector3f look; if (rotInfo != null) { look = MathUtils.FORWARD.rotateY(-rotInfo.getBodyYawRad(), new Vector3f()); - if (player.isVisuallySwimming() && (player.isInWater() || rotInfo.fbtMode == FBTMode.ARMS_ONLY)) { + if (player.isVisuallySwimming() && + (player.isInWater() || rotInfo.fbtMode == FBTMode.ARMS_ONLY)) + { yOffset = 0.3F * rotInfo.heightScale; xzOffset = 14f * rotInfo.heightScale; @@ -249,10 +252,10 @@ public void tick() { if (ClientDataHolderVR.getInstance().vrSettings.playerModelType == VRSettings.PlayerModelType.SPLIT_ARMS_LEGS) { - yOffset = -0.7F * Mth.cos(bend*Mth.HALF_PI) * rotInfo.heightScale; + yOffset = -0.7F * Mth.cos(bend * Mth.HALF_PI) * rotInfo.heightScale; xzOffset = bend * 14f * rotInfo.heightScale; } else { - yOffset = -0.7F * Mth.cos(bend*Mth.PI) * rotInfo.heightScale; + yOffset = -0.7F * Mth.cos(bend * Mth.PI) * rotInfo.heightScale; xzOffset = 14f * rotInfo.heightScale * Mth.sin(bend * Mth.PI); } pos = pos.add(pivot.x, pivot.y, pivot.z); @@ -299,6 +302,7 @@ public int getHMD(UUID uuid) { /** * gets the latest clientside player data, use this when not rendering, i.e. on tick + * * @param uuid uuid of the player to get the data for * @return latest available player data */ @@ -308,6 +312,7 @@ public RotInfo getLatestRotationsForPlayer(UUID uuid) { /** * gets the clientside interpolated player data, this one should only be called during rendering + * * @param uuid uuid of the player to get the data for * @return interpolated data */ @@ -435,7 +440,7 @@ public static RotInfo getMainPlayerRotInfo(LivingEntity player, float partialTic rotInfo.headRot = rotInfo.headQuat.transform(MathUtils.BACK, new Vector3f()); Vec3 pos; - if (player == Minecraft.getInstance().player) { + if (player == Minecraft.getInstance().player && !RenderPassType.isGuiOnly()) { pos = ((GameRendererExtension) Minecraft.getInstance().gameRenderer).vivecraft$getRvePos(partialTick); } else { pos = player.getPosition(partialTick); diff --git a/common/src/main/java/org/vivecraft/client/Xplat.java b/common/src/main/java/org/vivecraft/client/Xplat.java index 0131c3f9c..ef771313d 100644 --- a/common/src/main/java/org/vivecraft/client/Xplat.java +++ b/common/src/main/java/org/vivecraft/client/Xplat.java @@ -8,6 +8,7 @@ import net.minecraft.network.protocol.Packet; import net.minecraft.world.entity.EquipmentSlot; import net.minecraft.world.item.ItemStack; +import net.minecraft.server.level.ServerPlayer; import net.minecraft.world.level.BlockAndTintGetter; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -227,4 +228,15 @@ static int getKeyModifier(KeyMapping keyMapping) { static int getKeyModifierKey(KeyMapping keyMapping) { return -1; } + + /** + * checks if the given player is a fake player, instead of an actual player + * + * @param player player to check + * @return {@code true} when it is a fake player + */ + @ExpectPlatform + static boolean isFakePlayer(ServerPlayer player) { + return false; + } } diff --git a/common/src/main/java/org/vivecraft/client/gui/settings/GuiRoomscaleSettings.java b/common/src/main/java/org/vivecraft/client/gui/settings/GuiRoomscaleSettings.java index 28961c289..12055998b 100644 --- a/common/src/main/java/org/vivecraft/client/gui/settings/GuiRoomscaleSettings.java +++ b/common/src/main/java/org/vivecraft/client/gui/settings/GuiRoomscaleSettings.java @@ -2,25 +2,26 @@ import net.minecraft.client.gui.screens.Screen; import org.vivecraft.client.gui.framework.GuiVROptionsBase; +import org.vivecraft.client.gui.framework.VROptionEntry; import org.vivecraft.client_vr.settings.VRSettings; public class GuiRoomscaleSettings extends GuiVROptionsBase { - private static final VRSettings.VrOptions[] ROOMSCALE_SETTINGS = new VRSettings.VrOptions[]{ - VRSettings.VrOptions.WEAPON_COLLISION, - VRSettings.VrOptions.FEET_COLLISION, - VRSettings.VrOptions.REALISTIC_OPENING, - VRSettings.VrOptions.REALISTIC_JUMP, - VRSettings.VrOptions.REALISTIC_SNEAK, - VRSettings.VrOptions.REALISTIC_CLIMB, - VRSettings.VrOptions.REALISTIC_ROW, - VRSettings.VrOptions.REALISTIC_SWIM, - VRSettings.VrOptions.BOW_MODE, - VRSettings.VrOptions.BACKPACK_SWITCH, - VRSettings.VrOptions.ALLOW_CRAWLING, - VRSettings.VrOptions.REALISTIC_DISMOUNT, - VRSettings.VrOptions.REALISTIC_BLOCK_INTERACT, - VRSettings.VrOptions.REALISTIC_ENTITY_INTERACT, - VRSettings.VrOptions.SWORD_BLOCK_COLLISION + private final VROptionEntry[] roomScaleSettings = new VROptionEntry[]{ + new VROptionEntry("vivecraft.options.screen.weaponcollision.button", (button, mousePos) -> { + this.minecraft.setScreen(new GuiWeaponCollisionSettings(this)); + return true; + }), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_JUMP), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_SNEAK), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_CLIMB), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_ROW), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_SWIM), + new VROptionEntry(VRSettings.VrOptions.BOW_MODE), + new VROptionEntry(VRSettings.VrOptions.BACKPACK_SWITCH), + new VROptionEntry(VRSettings.VrOptions.ALLOW_CRAWLING), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_DISMOUNT), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_BLOCK_INTERACT), + new VROptionEntry(VRSettings.VrOptions.REALISTIC_ENTITY_INTERACT) }; public GuiRoomscaleSettings(Screen lastScreen) { @@ -30,7 +31,7 @@ public GuiRoomscaleSettings(Screen lastScreen) { @Override public void init() { this.vrTitle = "vivecraft.options.screen.roomscale"; - super.init(ROOMSCALE_SETTINGS, true); + super.init(this.roomScaleSettings, true); super.addDefaultButtons(); } } diff --git a/common/src/main/java/org/vivecraft/client/gui/settings/GuiWeaponCollisionSettings.java b/common/src/main/java/org/vivecraft/client/gui/settings/GuiWeaponCollisionSettings.java new file mode 100644 index 000000000..c5c387464 --- /dev/null +++ b/common/src/main/java/org/vivecraft/client/gui/settings/GuiWeaponCollisionSettings.java @@ -0,0 +1,27 @@ +package org.vivecraft.client.gui.settings; + +import net.minecraft.client.gui.screens.Screen; +import org.vivecraft.client.gui.framework.GuiVROptionsBase; +import org.vivecraft.client_vr.settings.VRSettings; + +public class GuiWeaponCollisionSettings extends GuiVROptionsBase { + private static final VRSettings.VrOptions[] WEAPON_COLLISION_SETTINGS = new VRSettings.VrOptions[]{ + VRSettings.VrOptions.WEAPON_COLLISION, + VRSettings.VrOptions.FEET_COLLISION, + VRSettings.VrOptions.REALISTIC_OPENING, + VRSettings.VrOptions.SWORD_BLOCK_COLLISION, + VRSettings.VrOptions.ONLY_SWORD_COLLISION, + VRSettings.VrOptions.REDUCED_PLAYER_REACH + }; + + public GuiWeaponCollisionSettings(Screen lastScreen) { + super(lastScreen); + } + + @Override + public void init() { + this.vrTitle = "vivecraft.options.screen.weaponcollision"; + super.init(WEAPON_COLLISION_SETTINGS, true); + super.addDefaultButtons(); + } +} diff --git a/common/src/main/java/org/vivecraft/client_vr/gameplay/trackers/SwingTracker.java b/common/src/main/java/org/vivecraft/client_vr/gameplay/trackers/SwingTracker.java index 786e00ec7..6fdb213b2 100644 --- a/common/src/main/java/org/vivecraft/client_vr/gameplay/trackers/SwingTracker.java +++ b/common/src/main/java/org/vivecraft/client_vr/gameplay/trackers/SwingTracker.java @@ -136,6 +136,13 @@ public void doProcess(LocalPlayer player) { boolean isTool = false; boolean isSword = false; + if (this.dh.vrSettings.onlySwordCollision && + !(item instanceof SwordItem || itemstack.is(ItemTags.VIVECRAFT_SWORDS))) + { + // only swords can hit + continue; + } + if (!(item instanceof SwordItem || itemstack.is(ItemTags.VIVECRAFT_SWORDS)) && !(item instanceof TridentItem || itemstack.is(ItemTags.VIVECRAFT_SPEARS))) { @@ -216,12 +223,14 @@ public void doProcess(LocalPlayer player) { AABB weaponTipBB = new AABB(handPos, weaponTip); List mobs = this.mc.level.getEntities(this.mc.player, weaponTipBB); - mobs.removeIf((e) -> e instanceof Player); + if (this.dh.vrSettings.reducedPlayerReach) { + // shorter range for players to try to prevent accidental hits + mobs.removeIf((e) -> e instanceof Player); - // shorter range for players to try to prevent accidental hits - List players = this.mc.level.getEntities(this.mc.player, weaponBB); - players.removeIf((e) -> !(e instanceof Player)); - mobs.addAll(players); + List players = this.mc.level.getEntities(this.mc.player, weaponBB); + players.removeIf((e) -> !(e instanceof Player)); + mobs.addAll(players); + } for (Entity entity : mobs) { if (entity.isPickable() && entity != this.mc.getCameraEntity().getVehicle()) { diff --git a/common/src/main/java/org/vivecraft/client_vr/menuworlds/MenuWorldRenderer.java b/common/src/main/java/org/vivecraft/client_vr/menuworlds/MenuWorldRenderer.java index 3fdd8ff34..1b18823df 100644 --- a/common/src/main/java/org/vivecraft/client_vr/menuworlds/MenuWorldRenderer.java +++ b/common/src/main/java/org/vivecraft/client_vr/menuworlds/MenuWorldRenderer.java @@ -33,6 +33,7 @@ import net.minecraft.world.level.block.RenderShape; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.dimension.BuiltinDimensionTypes; +import net.minecraft.world.level.dimension.DimensionType; import net.minecraft.world.level.material.Fluid; import net.minecraft.world.level.material.FluidState; import net.minecraft.world.level.material.Fluids; @@ -1585,9 +1586,8 @@ public void updateLightmap() { Vector3f finalColor = new Vector3f(); for (int i = 0; i < 16; ++i) { for (int j = 0; j < 16; ++j) { - float skyBrightness = - LightTexture.getBrightness(this.blockAccess.dimensionType(), i) * effectiveSkyLight; - float blockBrightnessRed = LightTexture.getBrightness(this.blockAccess.dimensionType(), j) * + float skyBrightness = getBrightness(this.blockAccess.dimensionType(), i) * effectiveSkyLight; + float blockBrightnessRed = getBrightness(this.blockAccess.dimensionType(), j) * (this.blockLightRedFlicker + 1.5f); float blockBrightnessGreen = blockBrightnessRed * ((blockBrightnessRed * 0.6f + 0.4f) * 0.6f + 0.4f); @@ -1653,6 +1653,15 @@ private float notGamma(float f) { return 1.0f - g * g * g * g; } + /** + * copy of {@link LightTexture#getBrightness(DimensionType, int)}, because some mods access the player in that + */ + private float getBrightness(DimensionType dimensionType, int lightLevel) { + float f = (float) lightLevel / 15.0F; + float g = f / (4.0F - 3.0F * f); + return Mth.lerp(dimensionType.ambientLight(), g, 1.0F); + } + public float getWaterVision() { if (!this.areEyesInFluid(FluidTags.WATER)) { return 0.0F; diff --git a/common/src/main/java/org/vivecraft/client_vr/provider/MCVR.java b/common/src/main/java/org/vivecraft/client_vr/provider/MCVR.java index ae02a30c9..3d2734dca 100644 --- a/common/src/main/java/org/vivecraft/client_vr/provider/MCVR.java +++ b/common/src/main/java/org/vivecraft/client_vr/provider/MCVR.java @@ -1267,26 +1267,26 @@ public void calibrateFBT(float headsetYaw) { if (startIndex >= 0) { this.usingUnlabeledTrackers = true; - // unassigned trackers, assign them by distance + // only check non identified trackers + List indices = new ArrayList<>(); for (int t = startIndex + 3; t < endIndex + 3; t++) { + if (this.deviceSource[t].isValid()) { + int finalT = t; + trackers.removeIf((triple -> triple.getLeft().equals(this.deviceSource[finalT]))); + } else { + indices.add(t); + } + } + + // unassigned trackers, assign them by distance + for (int t : indices) { int closestIndex = -1; float closestDistance = Float.MAX_VALUE; // find the closest tracker to the reference point for (int i = 0; i < trackers.size(); i++) { - // int trackerIndex = trackers.get(i); Triple tracker = trackers.get(i); - // if regular fbt is already detected, skip those trackers - if (hasFBT()) { - if (this.deviceSource[WAIST_TRACKER].equals(tracker.getLeft()) || - this.deviceSource[LEFT_FOOT_TRACKER].equals(tracker.getLeft()) || - this.deviceSource[RIGHT_FOOT_TRACKER].equals(tracker.getLeft())) - { - continue; - } - } - tracker.getRight().getTranslation(tempV) .sub(posAvg.x, 0F, posAvg.z) // center around headset .rotateY(headsetYaw) diff --git a/common/src/main/java/org/vivecraft/client_vr/render/helpers/VREffectsHelper.java b/common/src/main/java/org/vivecraft/client_vr/render/helpers/VREffectsHelper.java index d68081b3d..7747da902 100644 --- a/common/src/main/java/org/vivecraft/client_vr/render/helpers/VREffectsHelper.java +++ b/common/src/main/java/org/vivecraft/client_vr/render/helpers/VREffectsHelper.java @@ -819,7 +819,7 @@ public static void renderFireInFirstPerson() { // code adapted from net.minecraft.client.renderer.ScreenEffectRenderer.renderFire - RenderSystem.setShader(GameRenderer::getPositionTexColorShader); + RenderSystem.setShader(GameRenderer::getPositionColorTexShader); RenderSystem.setShaderTexture(0, fireSprite.atlasLocation()); float uMin = fireSprite.getU0(); float uMax = fireSprite.getU1(); @@ -848,15 +848,15 @@ public static void renderFireInFirstPerson() { posestack.translate(0.0D, -headHeight, 0.0D); Matrix4f matrix = posestack.last().pose(); - bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR); + bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR_TEX); bufferbuilder.vertex(matrix, -width, 0.0F, -width) - .uv(u1, v1).color(1.0F, 1.0F, 1.0F, 0.9F).endVertex(); + .color(1.0F, 1.0F, 1.0F, 0.9F).uv(u1, v1).endVertex(); bufferbuilder.vertex(matrix, width, 0.0F, -width) - .uv(u0, v1).color(1.0F, 1.0F, 1.0F, 0.9F).endVertex(); + .color(1.0F, 1.0F, 1.0F, 0.9F).uv(u0, v1).endVertex(); bufferbuilder.vertex(matrix, width, headHeight, -width) - .uv(u0, v0).color(1.0F, 1.0F, 1.0F, 0.9F).endVertex(); + .color(1.0F, 1.0F, 1.0F, 0.9F).uv(u0, v0).endVertex(); bufferbuilder.vertex(matrix, -width, headHeight, -width) - .uv(u1, v0).color(1.0F, 1.0F, 1.0F, 0.9F).endVertex(); + .color(1.0F, 1.0F, 1.0F, 0.9F).uv(u1, v0).endVertex(); BufferUploader.drawWithShader(bufferbuilder.end()); posestack.popPose(); diff --git a/common/src/main/java/org/vivecraft/client_vr/settings/VRSettings.java b/common/src/main/java/org/vivecraft/client_vr/settings/VRSettings.java index 90588785a..f43ee5d82 100644 --- a/common/src/main/java/org/vivecraft/client_vr/settings/VRSettings.java +++ b/common/src/main/java/org/vivecraft/client_vr/settings/VRSettings.java @@ -278,6 +278,10 @@ public enum DataSource implements OptionEnum { public boolean feetCollision = true; // VIVE weapon feet collides with blocks/enemies @SettingField(VrOptions.SWORD_BLOCK_COLLISION) public boolean swordBlockCollision = true; + @SettingField(VrOptions.ONLY_SWORD_COLLISION) + public boolean onlySwordCollision = false; + @SettingField(VrOptions.REDUCED_PLAYER_REACH) + public boolean reducedPlayerReach = true; @SettingField(VrOptions.MOVEMENT_MULTIPLIER) public float movementSpeedMultiplier = 1.0f; // VIVE - use full speed by default @SettingField(VrOptions.FREEMOVE_MODE) @@ -1632,6 +1636,8 @@ Object convertOption(String value) { }, FEET_COLLISION(false, true), SWORD_BLOCK_COLLISION(false, true), // lets swords hit blocks that can be mined or instabroken + ONLY_SWORD_COLLISION(false, true), // only let swords hit stuff + REDUCED_PLAYER_REACH(false, true), // reduces roomscale reach to hit players // VIVE END - new options // JRBUDDA VIVE ALLOW_CRAWLING(false, true), // Roomscale Crawling diff --git a/common/src/main/java/org/vivecraft/common/utils/MathUtils.java b/common/src/main/java/org/vivecraft/common/utils/MathUtils.java index e4f707840..f89102e38 100644 --- a/common/src/main/java/org/vivecraft/common/utils/MathUtils.java +++ b/common/src/main/java/org/vivecraft/common/utils/MathUtils.java @@ -14,6 +14,7 @@ public class MathUtils { public static final Vector3fc RIGHT = new Vector3f(-1.0F, 0.0F, 0.0F); public static final Vector3fc UP = new Vector3f(0.0F, 1.0F, 0.0F); public static final Vector3fc DOWN = new Vector3f(0.0F, -1.0F, 0.0F); + public static final Vector3fc ZERO = new Vector3f(); public static final Vec3 FORWARD_D = new Vec3(0.0, 0.0, 1.0); public static final Vec3 BACK_D = new Vec3(0.0, 0.0, -1.0); @@ -22,6 +23,8 @@ public class MathUtils { public static final Vec3 UP_D = new Vec3(0.0, 1.0, 0.0); public static final Vec3 DOWN_D = new Vec3(0.0, -1.0, 0.0); + public static final Matrix4fc IDENTITY = new Matrix4f(); + /** * subtracts {@code b} from {@code a}, and returns the result as a Vector3f, should only be used to get local position differences * diff --git a/common/src/main/java/org/vivecraft/mixin/client_vr/MinecraftVRMixin.java b/common/src/main/java/org/vivecraft/mixin/client_vr/MinecraftVRMixin.java index 432a43afa..bf5f92a90 100644 --- a/common/src/main/java/org/vivecraft/mixin/client_vr/MinecraftVRMixin.java +++ b/common/src/main/java/org/vivecraft/mixin/client_vr/MinecraftVRMixin.java @@ -96,6 +96,9 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { @Unique private List vivecraft$resourcepacks; + @Unique + private CameraType vivecraft$lastCameraType; + @Final @Shadow public Gui gui; @@ -140,10 +143,6 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { @Shadow private ProfileResults fpsPieResults; - @Shadow - @Final - private RenderBuffers renderBuffers; - @Shadow @Final private EntityRenderDispatcher entityRenderDispatcher; @@ -190,8 +189,14 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { @Shadow public abstract float getFrameTime(); - @ModifyArg(method = "", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Minecraft;setOverlay(Lnet/minecraft/client/gui/screens/Overlay;)V"), index = 0) - private Overlay vivecraft$initVivecraft(Overlay overlay) { + @Shadow + @Final + private RenderBuffers renderBuffers; + + @ModifyArg(method = "", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/ResourceLoadStateTracker;startReload(Lnet/minecraft/client/ResourceLoadStateTracker$ReloadReason;Ljava/util/List;)V"), index = 0) + private ResourceLoadStateTracker.ReloadReason vivecraft$initVivecraft( + ResourceLoadStateTracker.ReloadReason reloadReason) + { RenderPassManager.INSTANCE = new RenderPassManager((MainTarget) this.mainRenderTarget); VRSettings.initSettings(); new Thread(UpdateChecker::checkForUpdates, "VivecraftUpdateThread").start(); @@ -216,7 +221,7 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { } } }); - return overlay; + return reloadReason; } @Inject(method = "setInitialScreen", at = @At("TAIL")) @@ -803,6 +808,10 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { private void vivecraft$switchVRState(boolean vrActive) { VRState.VR_RUNNING = vrActive; if (vrActive) { + // force first person camera in VR + this.vivecraft$lastCameraType = this.options.getCameraType(); + this.options.setCameraType(CameraType.FIRST_PERSON); + if (this.player != null) { // snap room origin to the player ClientDataHolderVR.getInstance().vrPlayer.snapRoomOriginToPlayerEntity(this.player, false, false); @@ -819,6 +828,11 @@ public abstract class MinecraftVRMixin implements MinecraftExtension { GuiHandler.GUI_ROTATION_ROOM = null; GuiHandler.GUI_SCALE = 1.0F; + // reset camera + if (this.vivecraft$lastCameraType != null) { + this.options.setCameraType(this.vivecraft$lastCameraType); + } + if (this.player != null) { // remove vr player instance ClientVRPlayers.getInstance().disableVR(this.player.getUUID()); diff --git a/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/LevelRendererVRMixin.java b/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/LevelRendererVRMixin.java index 40044cc8f..3a5dfdf16 100644 --- a/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/LevelRendererVRMixin.java +++ b/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/LevelRendererVRMixin.java @@ -72,6 +72,7 @@ public abstract class LevelRendererVRMixin implements ResourceManagerReloadListe @Final @Shadow private Minecraft minecraft; + @Shadow private ClientLevel level; @Shadow diff --git a/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/PostChainVRMixin.java b/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/PostChainVRMixin.java index ced47db56..dd5eb2a43 100644 --- a/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/PostChainVRMixin.java +++ b/common/src/main/java/org/vivecraft/mixin/client_vr/renderer/PostChainVRMixin.java @@ -19,6 +19,7 @@ import org.vivecraft.client_vr.ClientDataHolderVR; import org.vivecraft.client_vr.MultiPassRenderTarget; import org.vivecraft.client_vr.VRState; +import org.vivecraft.client_vr.gameplay.screenhandlers.GuiHandler; import org.vivecraft.client_vr.render.RenderPass; import org.vivecraft.client_xr.render_pass.RenderPassManager; import org.vivecraft.client_xr.render_pass.RenderPassType; @@ -45,8 +46,15 @@ public class PostChainVRMixin { { if (VRState.VR_INITIALIZED && this.screenTarget == RenderPassManager.INSTANCE.vanillaRenderTarget) { for (RenderPass pass : RenderPass.values()) { + // gui has no world renderpass + if (pass == RenderPass.GUI) { + this.vivecraft$VRPostChains.put(pass, + new PostChain(textureManager, resourceManager, GuiHandler.GUI_FRAMEBUFFER, name)); + continue; + } + // create one post chain for each active render pass - if (pass == RenderPass.GUI || WorldRenderPass.getByRenderPass(pass) == null) continue; + if (WorldRenderPass.getByRenderPass(pass) == null) continue; this.vivecraft$VRPostChains.put(pass, new PostChain(textureManager, resourceManager, WorldRenderPass.getByRenderPass(pass).target, name)); } @@ -84,7 +92,8 @@ public class PostChainVRMixin { @Inject(method = "resize", at = @At("TAIL")) private void vivecraft$resizeVRChains(CallbackInfo ci) { for (Map.Entry entry : this.vivecraft$VRPostChains.entrySet()) { - RenderTarget target = WorldRenderPass.getByRenderPass(entry.getKey()).target; + RenderTarget target = entry.getKey() == RenderPass.GUI ? GuiHandler.GUI_FRAMEBUFFER : + WorldRenderPass.getByRenderPass(entry.getKey()).target; entry.getValue().resize(target.width, target.height); } } diff --git a/common/src/main/java/org/vivecraft/mixin/server/ServerPlayerMixin.java b/common/src/main/java/org/vivecraft/mixin/server/ServerPlayerMixin.java index 2ae71291c..f0324f462 100644 --- a/common/src/main/java/org/vivecraft/mixin/server/ServerPlayerMixin.java +++ b/common/src/main/java/org/vivecraft/mixin/server/ServerPlayerMixin.java @@ -33,6 +33,7 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.vivecraft.client.Xplat; import org.vivecraft.mixin.world.entity.PlayerMixin; import org.vivecraft.server.ServerNetworking; import org.vivecraft.server.ServerVRPlayers; @@ -90,7 +91,7 @@ protected ServerPlayerMixin(EntityType entityType, Level double xOffset, double yOffset, double zOffset, double speed, Operation original) { ServerVivePlayer serverVivePlayer = vivecraft$getVivePlayer(); - if (serverVivePlayer != null && serverVivePlayer.isVR()) { + if (!Xplat.isFakePlayer((ServerPlayer) (Object) this) && serverVivePlayer != null && serverVivePlayer.isVR()) { Vec3 aim = serverVivePlayer.getBodyPartDir(serverVivePlayer.activeBodyPart); float yaw = (float) Math.atan2(-aim.x, aim.z); @@ -142,7 +143,9 @@ protected ServerPlayerMixin(EntityType entityType, Level @Local ItemEntity item) { ServerVivePlayer serverVivePlayer = vivecraft$getVivePlayer(); - if (!dropAround && serverVivePlayer != null && serverVivePlayer.isVR()) { + if (!Xplat.isFakePlayer((ServerPlayer) (Object) this) && !dropAround && serverVivePlayer != null && + serverVivePlayer.isVR()) + { // spawn item from players hand Vec3 pos = serverVivePlayer.getBodyPartPos(serverVivePlayer.activeBodyPart); Vec3 aim = serverVivePlayer.getBodyPartDir(serverVivePlayer.activeBodyPart); diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/IrisHelper.java b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/IrisHelper.java index b81d423c2..61a6e0959 100644 --- a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/IrisHelper.java +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/IrisHelper.java @@ -38,10 +38,6 @@ public class IrisHelper { private static Method CapturedRenderingState_getGbufferProjection; - private static Method WorldRenderingSettings_setUseExtendedVertexFormat; - private static Method WorldRenderingSettings_shouldUseExtendedVertexFormat; - private static Object WorldRenderingSettings_INSTANCE; - public static boolean SLOW_MODE = false; public static boolean isLoaded() { @@ -52,15 +48,7 @@ public static boolean isLoaded() { * @return if a shaderpack is in use */ public static boolean isShaderActive() { - try { - return IrisApi.getInstance().isShaderPackInUse() || - (WorldRenderingSettings_shouldUseExtendedVertexFormat != null && - (boolean) WorldRenderingSettings_shouldUseExtendedVertexFormat.invoke( - WorldRenderingSettings_INSTANCE) - ); - } catch (IllegalAccessException | InvocationTargetException ignored) { - return false; - } + return IrisApi.getInstance().isShaderPackInUse(); } /** @@ -77,20 +65,13 @@ public static boolean isRenderingShadows() { */ public static void setShadersActive(boolean enabled) { IrisApi.getInstance().getConfig().setShadersEnabledAndApply(enabled); - if (!enabled && hasIssuesWithMenuWorld()) { - try { - WorldRenderingSettings_setUseExtendedVertexFormat.invoke(WorldRenderingSettings_INSTANCE, false); - } catch (InvocationTargetException | IllegalAccessException e) { - VRSettings.LOGGER.error("Vivecraft: error disabling Iris shaders:", e); - } - } } /** * @return if the currently loaded iris version has issues with building menuworlds while shaders are enabled */ public static boolean hasIssuesWithMenuWorld() { - return init() && WorldRenderingSettings_setUseExtendedVertexFormat != null; + return false; } /** @@ -211,17 +192,6 @@ private static boolean init() { WorldRenderingPipeline_shouldRenderUnderwaterOverlay = worldRenderingPipeline.getMethod( "shouldRenderUnderwaterOverlay"); - try { - // iris versions that have this have issues with menuworld building when shaders are on - Class WorldRenderingSettings = Class.forName( - "net.irisshaders.iris.shaderpack.materialmap.WorldRenderingSettings"); - WorldRenderingSettings_setUseExtendedVertexFormat = WorldRenderingSettings.getMethod( - "setUseExtendedVertexFormat", boolean.class); - WorldRenderingSettings_shouldUseExtendedVertexFormat = WorldRenderingSettings.getMethod( - "shouldUseExtendedVertexFormat"); - WorldRenderingSettings_INSTANCE = WorldRenderingSettings.getField("INSTANCE").get(null); - } catch (ClassNotFoundException | NoSuchMethodException | NoSuchFieldException | IllegalAccessException ignore) {} - // distant horizon compat if (Xplat.isModLoaded("distanthorizons")) { diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisCommonUniformsMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisCommonUniformsMixin.java new file mode 100644 index 000000000..5cf91f523 --- /dev/null +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisCommonUniformsMixin.java @@ -0,0 +1,39 @@ +package org.vivecraft.mod_compat_vr.iris.mixin.coderbot; + +import com.llamalad7.mixinextras.sugar.Local; +import net.coderbot.iris.gl.uniform.UniformHolder; +import net.coderbot.iris.gl.uniform.UniformUpdateFrequency; +import org.apache.commons.lang3.tuple.Triple; +import org.joml.Matrix4fc; +import org.joml.Vector3f; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Pseudo; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; + +import java.util.function.Supplier; + +@Pseudo +@Mixin(targets = "net.coderbot.iris.uniforms.CommonUniforms", remap = false) +public class IrisCommonUniformsMixin { + @Inject(method = "generalCommonUniforms", at = @At("TAIL")) + private static void vivecraft$addVivecraftUniforms( + CallbackInfo ci, @Local(argsOnly = true) UniformHolder uniforms) + { + for (Triple> uniform : ShadersHelper.getUniforms()) { + switch (uniform.getMiddle()) { + case MATRIX4F -> uniforms.uniformMatrix(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (Matrix4fc) uniform.getRight().get()); + case VECTOR3F -> uniforms.uniform3f(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (Vector3f) uniform.getRight().get()); + case INTEGER -> uniforms.uniform1i(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (int) uniform.getRight().get()); + case BOOLEAN -> uniforms.uniform1b(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (boolean) uniform.getRight().get()); + default -> throw new IllegalStateException("Unexpected uniform type: " + uniform.getMiddle()); + } + } + } +} diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisStandardMacrosMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisStandardMacrosMixin.java new file mode 100644 index 000000000..1d2fec04e --- /dev/null +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/coderbot/IrisStandardMacrosMixin.java @@ -0,0 +1,35 @@ +package org.vivecraft.mod_compat_vr.iris.mixin.coderbot; + +import com.google.common.collect.ImmutableList; +import com.llamalad7.mixinextras.sugar.Local; +import net.coderbot.iris.helpers.StringPair; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Pseudo; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; + +import java.util.ArrayList; +import java.util.List; + +@Pseudo +@Mixin(targets = "net.coderbot.iris.gl.shader.StandardMacros", remap = false) +public class IrisStandardMacrosMixin { + @Shadow + private static void define(List defines, String key) {} + + @Shadow + private static void define(List defines, String key, String value) {} + + @Inject(method = "createStandardEnvironmentDefines", at = @At(value = "INVOKE", target = "Lnet/coderbot/iris/gl/shader/StandardMacros;define(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)V", ordinal = 0)) + private static void vivecraft$addVivecraftUniforms( + CallbackInfoReturnable> cir, @Local ArrayList standardDefines) + { + ShadersHelper.addMacros( + (string) -> define(standardDefines, string), + (string, value) -> define(standardDefines, string, String.valueOf(value)) + ); + } +} diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisCommonUniformsMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisCommonUniformsMixin.java new file mode 100644 index 000000000..ff2057441 --- /dev/null +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisCommonUniformsMixin.java @@ -0,0 +1,40 @@ +package org.vivecraft.mod_compat_vr.iris.mixin.irisshaders; + +import com.llamalad7.mixinextras.sugar.Local; +import net.irisshaders.iris.gl.uniform.UniformHolder; +import org.apache.commons.lang3.tuple.Triple; +import org.joml.Matrix4fc; +import org.joml.Vector3f; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Pseudo; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; + +import java.util.function.Supplier; + +import net.irisshaders.iris.gl.uniform.UniformUpdateFrequency; + +@Pseudo +@Mixin(targets = "net.irisshaders.iris.uniforms.CommonUniforms", remap = false) +public class IrisCommonUniformsMixin { + @Inject(method = "generalCommonUniforms", at = @At("TAIL")) + private static void vivecraft$addVivecraftUniforms( + CallbackInfo ci, @Local(argsOnly = true) UniformHolder uniforms) + { + for (Triple> uniform : ShadersHelper.getUniforms()) { + switch (uniform.getMiddle()) { + case MATRIX4F -> uniforms.uniformMatrix(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (Matrix4fc) uniform.getRight().get()); + case VECTOR3F -> uniforms.uniform3f(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (Vector3f) uniform.getRight().get()); + case INTEGER -> uniforms.uniform1i(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (int) uniform.getRight().get()); + case BOOLEAN -> uniforms.uniform1b(UniformUpdateFrequency.PER_FRAME, uniform.getLeft(), + () -> (boolean) uniform.getRight().get()); + default -> throw new IllegalStateException("Unexpected uniform type: " + uniform.getMiddle()); + } + } + } +} diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisStandardMacrosMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisStandardMacrosMixin.java new file mode 100644 index 000000000..a0e3ec8ac --- /dev/null +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/iris/mixin/irisshaders/IrisStandardMacrosMixin.java @@ -0,0 +1,35 @@ +package org.vivecraft.mod_compat_vr.iris.mixin.irisshaders; + +import com.google.common.collect.ImmutableList; +import com.llamalad7.mixinextras.sugar.Local; +import net.irisshaders.iris.helpers.StringPair; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Pseudo; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; + +import java.util.ArrayList; +import java.util.List; + +@Pseudo +@Mixin(targets = "net.irisshaders.iris.gl.shader.StandardMacros", remap = false) +public class IrisStandardMacrosMixin { + @Shadow + private static void define(List defines, String key) {} + + @Shadow + private static void define(List defines, String key, String value) {} + + @Inject(method = "createStandardEnvironmentDefines", at = @At(value = "INVOKE", target = "Lnet/irisshaders/iris/gl/shader/StandardMacros;define(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)V", ordinal = 0)) + private static void vivecraft$addVivecraftUniforms( + CallbackInfoReturnable> cir, @Local ArrayList standardDefines) + { + ShadersHelper.addMacros( + (string) -> define(standardDefines, string), + (string, value) -> define(standardDefines, string, String.valueOf(value)) + ); + } +} diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/OptifineHelper.java b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/OptifineHelper.java index 9a47c880c..4e9f077f3 100644 --- a/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/OptifineHelper.java +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/OptifineHelper.java @@ -8,18 +8,32 @@ import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.world.level.BlockAndTintGetter; import net.minecraft.world.phys.Vec3; +import org.apache.commons.lang3.tuple.Pair; +import org.apache.commons.lang3.tuple.Triple; +import org.joml.Matrix4fc; +import org.joml.Vector3f; +import org.joml.Vector3fc; +import org.lwjgl.system.MemoryUtil; import org.vivecraft.client_vr.settings.VRSettings; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.RecordComponent; +import java.nio.FloatBuffer; +import java.util.HashMap; +import java.util.Map; +import java.util.function.Supplier; public class OptifineHelper { private static boolean CHECKED_FOR_OPTIFINE = false; private static boolean OPTIFINE_LOADED = false; + private static final Map> SHADER_UNIFORMS = new HashMap<>(); + private static final Map SHADER_UNIFORMS_DATA = new HashMap<>(); + private static Class Config; private static Method Config_IsShaders; private static Method Config_IsRenderRegions; @@ -52,9 +66,18 @@ public class OptifineHelper { private static Method Shaders_SetCameraShadow; private static Field Shaders_DFB; private static Field Shaders_isShadowPass; + private static Field Shaders_shaderUniforms; private static Method ShadersFramebuffer_BindFramebuffer; + private static Method ShaderUniforms_make1i; + private static Method ShaderUniforms_make3f; + private static Method ShaderUniforms_makeM4; + + private static Method ShaderUniform1i_setValue; + private static Method ShaderUniform3f_setValue; + private static Method ShaderUniformM4_setValue; + private static Field Options_ofRenderRegions; private static Field Options_ofCloudHeight; private static Field Options_ofAoLevel; @@ -445,6 +468,76 @@ public static void copyRenderPositions(ModelPart.Vertex source, ModelPart.Vertex } } + /** + * creates and updates Optifines shader uniforms added by vivecraft + */ + public static void updateUniforms() { + if (!isOptifineLoaded()) return; + try { + for (Triple> uniform : ShadersHelper.getUniforms()) { + String name = uniform.getLeft(); + // create the uniform and data holder, if they aren't created yet + if (!SHADER_UNIFORMS.containsKey(name)) { + Method m = switch (uniform.getMiddle()) { + case MATRIX4F -> ShaderUniforms_makeM4; + case VECTOR3F -> ShaderUniforms_make3f; + case BOOLEAN, INTEGER -> ShaderUniforms_make1i; + }; + SHADER_UNIFORMS.put(uniform.getLeft(), + Pair.of(uniform.getMiddle(), m.invoke(Shaders_shaderUniforms.get(null), name))); + SHADER_UNIFORMS_DATA.put(name, switch (uniform.getMiddle()) { + case MATRIX4F -> MemoryUtil.memAllocFloat(16); + case VECTOR3F -> new Vector3f(); + case BOOLEAN, INTEGER -> 0; + }); + } + + // update the uniform with the given supplier + switch (uniform.getMiddle()) { + case MATRIX4F -> { + FloatBuffer floatBuffer = (FloatBuffer) SHADER_UNIFORMS_DATA.get(name); + floatBuffer.clear(); + ((Matrix4fc) uniform.getRight().get()).get(floatBuffer); + } + case VECTOR3F -> + ((Vector3f) SHADER_UNIFORMS_DATA.get(name)).set((Vector3fc) uniform.getRight().get()); + case INTEGER -> SHADER_UNIFORMS_DATA.put(name, uniform.getRight().get()); + case BOOLEAN -> SHADER_UNIFORMS_DATA.put(name, ((boolean) uniform.getRight().get()) ? 1 : 0); + default -> throw new IllegalStateException("Unexpected uniform type: " + uniform.getMiddle()); + } + } + } catch (IllegalAccessException | InvocationTargetException e) { + VRSettings.LOGGER.error("Vivecraft: error updating shader uniform data:", e); + } + } + + /** + * sets Optifines shader uniforms added by vivecraft + */ + public static void setUniforms() { + if (!isOptifineLoaded()) return; + try { + for (Map.Entry> entry : SHADER_UNIFORMS.entrySet()) { + String name = entry.getKey(); + Object data = SHADER_UNIFORMS_DATA.get(name); + Object uniform = entry.getValue().getRight(); + + switch (entry.getValue().getLeft()) { + case MATRIX4F -> ShaderUniformM4_setValue.invoke(uniform, false, data); + case VECTOR3F -> { + Vector3f vec = (Vector3f) data; + ShaderUniform3f_setValue.invoke(uniform, vec.x, vec.y, vec.z); + } + case BOOLEAN, INTEGER -> ShaderUniform1i_setValue.invoke(uniform, data); + default -> + throw new IllegalStateException("Unexpected uniform type: " + entry.getValue().getLeft()); + } + } + } catch (IllegalAccessException | InvocationTargetException e) { + VRSettings.LOGGER.error("Vivecraft: error updating shader uniform data:", e); + } + } + /** * initializes all Reflections */ @@ -486,6 +579,18 @@ private static void init() { Shaders_SetCameraShadow = Shaders.getMethod("setCameraShadow", PoseStack.class, Camera.class, float.class); Shaders_isShadowPass = Shaders.getField("isShadowPass"); + Class ShaderUniforms = Class.forName("net.optifine.shaders.uniform.ShaderUniforms"); + ShaderUniforms_make1i = ShaderUniforms.getMethod("make1i", String.class); + ShaderUniforms_make3f = ShaderUniforms.getMethod("make3f", String.class); + ShaderUniforms_makeM4 = ShaderUniforms.getMethod("makeM4", String.class); + + ShaderUniform1i_setValue = Class.forName("net.optifine.shaders.uniform.ShaderUniform1i") + .getMethod("setValue", int.class); + ShaderUniform3f_setValue = Class.forName("net.optifine.shaders.uniform.ShaderUniform3f") + .getMethod("setValue", float.class, float.class, float.class); + ShaderUniformM4_setValue = Class.forName("net.optifine.shaders.uniform.ShaderUniformM4") + .getMethod("setValue", boolean.class, FloatBuffer.class); + Class ShadersFramebuffer = Class.forName("net.optifine.shaders.ShadersFramebuffer"); ShadersFramebuffer_BindFramebuffer = ShadersFramebuffer.getMethod("bindFramebuffer"); @@ -503,6 +608,8 @@ private static void init() { // private Fields Shaders_DFB = Shaders.getDeclaredField("dfb"); Shaders_DFB.setAccessible(true); + Shaders_shaderUniforms = Shaders.getDeclaredField("shaderUniforms"); + Shaders_shaderUniforms.setAccessible(true); try { Vertex_renderPositions = ModelPart.Vertex.class.getField("renderPositions"); diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShaderMacrosVRMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShaderMacrosVRMixin.java new file mode 100644 index 000000000..ecfff7b74 --- /dev/null +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShaderMacrosVRMixin.java @@ -0,0 +1,31 @@ +package org.vivecraft.mod_compat_vr.optifine.mixin; + +import com.llamalad7.mixinextras.sugar.Local; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Pseudo; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.vivecraft.mod_compat_vr.shaders.ShadersHelper; + +@Pseudo +@Mixin(targets = "net.optifine.shaders.config.ShaderMacros", remap = false) +public class ShaderMacrosVRMixin { + + @Shadow + private static void addMacroLine(StringBuilder stringBuilder, String string, int n) {} + + @Shadow + private static void addMacroLine(StringBuilder stringBuilder, String string) {} + + @Inject(method = "getFixedMacroLines", at = @At(value = "INVOKE", target = "Lnet/optifine/shaders/config/ShaderMacros;addMacroLine(Ljava/lang/StringBuilder;Ljava/lang/String;I)V")) + private static void vivecraft$addVivecraftMacros( + CallbackInfoReturnable cir,@Local StringBuilder stringBuilder) + { + ShadersHelper.addMacros( + (string) -> addMacroLine(stringBuilder, string), + (string, value) -> addMacroLine(stringBuilder, string, value) + ); + } +} diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShadersVRMixin.java b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShadersVRMixin.java index 2cd3a8365..34219fd37 100644 --- a/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShadersVRMixin.java +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/optifine/mixin/ShadersVRMixin.java @@ -18,6 +18,7 @@ import org.vivecraft.client_vr.render.RenderPass; import org.vivecraft.client_vr.render.helpers.RenderHelper; import org.vivecraft.client_xr.render_pass.RenderPassType; +import org.vivecraft.mod_compat_vr.optifine.OptifineHelper; @Pseudo @Mixin(targets = "net.optifine.shaders.Shaders") @@ -70,4 +71,14 @@ public class ShadersVRMixin { return ClientDataHolderVR.getInstance().vrPlayer.getVRDataWorld().getEye(RenderPass.CENTER).getPosition().z; } } + + @Inject(method = "beginRender", at = @At(value = "INVOKE", target = "Ljava/nio/FloatBuffer;position(I)Ljava/nio/FloatBuffer;", ordinal = 0), remap = false) + private static void vivecraft$updateVivecraftUniforms(CallbackInfo ci) { + OptifineHelper.updateUniforms(); + } + + @Inject(method = "setProgramUniforms", at = @At("TAIL"), remap = false) + private static void vivecraft$setVivecraftUniforms(CallbackInfo ci) { + OptifineHelper.setUniforms(); + } } diff --git a/common/src/main/java/org/vivecraft/mod_compat_vr/shaders/ShadersHelper.java b/common/src/main/java/org/vivecraft/mod_compat_vr/shaders/ShadersHelper.java index f196477a9..f284f232e 100644 --- a/common/src/main/java/org/vivecraft/mod_compat_vr/shaders/ShadersHelper.java +++ b/common/src/main/java/org/vivecraft/mod_compat_vr/shaders/ShadersHelper.java @@ -1,13 +1,35 @@ package org.vivecraft.mod_compat_vr.shaders; +import net.minecraft.client.Minecraft; +import org.apache.commons.lang3.tuple.Triple; +import org.vivecraft.client_vr.ClientDataHolderVR; +import org.vivecraft.client_vr.VRState; +import org.vivecraft.client_vr.render.RenderPass; +import org.vivecraft.client_vr.render.helpers.RenderHelper; +import org.vivecraft.common.utils.MathUtils; import org.vivecraft.mod_compat_vr.iris.IrisHelper; import org.vivecraft.mod_compat_vr.optifine.OptifineHelper; +import java.util.ArrayList; +import java.util.List; +import java.util.function.BiConsumer; +import java.util.function.Consumer; +import java.util.function.Supplier; + /** * helper to wrap general shader related task in one class, independent if running Optifine or iris */ public class ShadersHelper { + public enum UniformType { + MATRIX4F, + VECTOR3F, + INTEGER, + BOOLEAN + } + + private static List>> UNIFORMS; + /** * gets the minimum light to apply to hand/gui, depending on if shaders are active or not * @@ -50,4 +72,73 @@ public static void maybeReloadShaders() { IrisHelper.reload(); } } + + /** + * adds the vivecraft macros, using the provided consumers + * + * @param createMacro a consumer that defines a name as existent + * @param createValueMacro a consumer that defines a name with a value + */ + public static void addMacros(Consumer createMacro, BiConsumer createValueMacro) { + createMacro.accept("VIVECRAFT"); + for (RenderPass pass : RenderPass.values()) { + createValueMacro.accept("VIVECRAFT_PASS_" + pass.toString(), pass.ordinal()); + } + + createValueMacro.accept("VIVECRAFT_PASS_VANILLA", -1); + } + + /** + * @return a list of uniform names and suppliers + */ + public static List>> getUniforms() { + // only create that once, it doesn't change + if (UNIFORMS == null) { + UNIFORMS = new ArrayList<>(); + ClientDataHolderVR dh = ClientDataHolderVR.getInstance(); + Minecraft mc = Minecraft.getInstance(); + // main hand + UNIFORMS.add(Triple.of("vivecraftRelativeMainHandPos", UniformType.VECTOR3F, () -> { + if (VRState.VR_RUNNING) { + return MathUtils.subtractToVector3f(mc.gameRenderer.getMainCamera().getPosition(), + RenderHelper.getControllerRenderPos(0)); + } else { + return MathUtils.ZERO; + } + })); + UNIFORMS.add(Triple.of("vivecraftRelativeMainHandRot", UniformType.MATRIX4F, () -> { + if (VRState.VR_RUNNING) { + return dh.vrPlayer.getVRDataWorld().getController(0).getMatrix(); + } else { + return MathUtils.IDENTITY; + } + })); + + // offhand + UNIFORMS.add(Triple.of("vivecraftRelativeOffHandPos", UniformType.VECTOR3F, () -> { + if (VRState.VR_RUNNING) { + return MathUtils.subtractToVector3f(mc.gameRenderer.getMainCamera().getPosition(), + RenderHelper.getControllerRenderPos(1)); + } else { + return MathUtils.ZERO; + } + })); + UNIFORMS.add(Triple.of("vivecraftRelativeOffHandRot", UniformType.MATRIX4F, () -> { + if (VRState.VR_RUNNING) { + return dh.vrPlayer.getVRDataWorld().getController(1).getMatrix(); + } else { + return MathUtils.IDENTITY; + } + })); + + // vr toggle + UNIFORMS.add(Triple.of("vivecraftIsVR", UniformType.BOOLEAN, () -> VRState.VR_RUNNING)); + + // renderpass + UNIFORMS.add(Triple.of("vivecraftRenderpass", UniformType.INTEGER, + () -> VRState.VR_RUNNING && ClientDataHolderVR.getInstance().currentPass != null ? + ClientDataHolderVR.getInstance().currentPass.ordinal() : -1)); + } + return UNIFORMS; + } } diff --git a/common/src/main/resources/assets/vivecraft/lang/de_de.json b/common/src/main/resources/assets/vivecraft/lang/de_de.json index cd0391417..fbba8f2f9 100644 --- a/common/src/main/resources/assets/vivecraft/lang/de_de.json +++ b/common/src/main/resources/assets/vivecraft/lang/de_de.json @@ -139,6 +139,8 @@ "vivecraft.options.WEAPON_COLLISION": "Waffenkollision", "vivecraft.options.FEET_COLLISION": "Fußkollision", "vivecraft.options.SWORD_BLOCK_COLLISION": "Schwert Blockkollision", + "vivecraft.options.ONLY_SWORD_COLLISION": "Nur Schwert kollisionen", + "vivecraft.options.REDUCED_PLAYER_REACH": "Reduzierte Spielerreichweite", "vivecraft.options.ALLOW_CRAWLING": "Raumskala Krabbeln", "vivecraft.options.LIMIT_TELEPORT": "Limitiere im Überlebensmodus", "vivecraft.options.REVERSE_HANDS": "Hände vertauschen", @@ -236,6 +238,8 @@ "vivecraft.options.WEAPON_COLLISION.tooltip": "Ermöglicht das Treffen von Blöcken und Entities im Raumskala.\nIst Automatisch bei Survival eingeschaltet und bei Creative ausgeschaltet.", "vivecraft.options.FEET_COLLISION.tooltip": "Ermöglicht das Treffen von Blöcken und Entities im Raumskala mit deinen Füßen.\n§6Benötigt Ganzkörper tracking um zu funktionieren.\n§6'Waffenkollision' muss aktiv sein um zu funktionieren.", "vivecraft.options.SWORD_BLOCK_COLLISION.tooltip": "Ermöglicht Blöcke mit Schwertern zu treffer, die damit abbaubar oder sofort zerstört werden können.\n§6Hat keine Auswirkungen wenn 'Waffenkollision' deaktiviert ist", + "vivecraft.options.ONLY_SWORD_COLLISION.tooltip": "Wenn aktiviert, können nur Schwerter Blöcke/Objekt schaden zufügen.", + "vivecraft.options.REDUCED_PLAYER_REACH.tooltip": "Wenn aktiviert, reduziert die Raumskala Reichweite um ander Spieler zu treffen, um unbeabsichtigte Treffer zu vermieden.", "vivecraft.options.ALLOW_CRAWLING.tooltip": "Wenn diese Option aktiviert ist, kann sich der Spieler unter dem Block ducken.", "vivecraft.options.LIMIT_TELEPORT.tooltip": "Wenn aktiviert, hat der Bogen-Teleporter im Überlebensmodus Einschränkungen. Er wird nicht in der Lage sein, seitlich an Blöcken hochzuspringen, er wird Hunger verbrauchen, und er wird einen Energieriegel haben, der sich mit der Zeit wieder auffüllt.", "vivecraft.options.REVERSE_HANDS.tooltip": "Tauschen Sie die linke/rechte Hand als dominant.\n An: Links dominant\n Aus: Rechts-dominant\n\nUm die Tastenbelegung zu vertauschen, starten Sie das Spiel neu und stellen Sie sicher, dass die Standardbindungen in SteamVR ausgewählt sind.", @@ -441,12 +445,14 @@ "vivecraft.options.screen.debug": "Debug Render Einstellungen", "vivecraft.options.screen.fbtcalibration": "Full Body Tracking Kalibrierung", "vivecraft.options.screen.playermodel": "Spielermodell Einstellungen", + "vivecraft.options.screen.weaponcollision": "Waffenkollision Einstellungen", "_comment_m2": "Buttons that lead to the screen", "vivecraft.options.screen.mixedreality.button": "Mixed Reality Einstellungen...", "vivecraft.options.screen.posteffects.button": "Postprocessing Einst...", "vivecraft.options.screen.shadercompat.button": "Shader Kompatibilitäts Einst...", "vivecraft.options.screen.fbtcalibration.button": "FBT Kalibrieren...", "vivecraft.options.screen.playermodel.button": "Spielermodell Einstellungen...", + "vivecraft.options.screen.weaponcollision.button": "Waffenkollision...", "_comment_m0": "Option values", "vivecraft.options.shaderguirender.aftershader": "Nach Shader", "vivecraft.options.shaderguirender.aftertranslucent": "Transparent", diff --git a/common/src/main/resources/assets/vivecraft/lang/en_us.json b/common/src/main/resources/assets/vivecraft/lang/en_us.json index 6b8f7b968..2d2075f03 100644 --- a/common/src/main/resources/assets/vivecraft/lang/en_us.json +++ b/common/src/main/resources/assets/vivecraft/lang/en_us.json @@ -138,6 +138,8 @@ "vivecraft.options.WEAPON_COLLISION": "Weapon Collision", "vivecraft.options.FEET_COLLISION": "Feet Collision", "vivecraft.options.SWORD_BLOCK_COLLISION": "Sword Block Collisions", + "vivecraft.options.ONLY_SWORD_COLLISION": "Only Sword Collisions", + "vivecraft.options.REDUCED_PLAYER_REACH": "Reduced Player Reach", "vivecraft.options.ALLOW_CRAWLING": "Roomscale Crawling", "vivecraft.options.LIMIT_TELEPORT": "Limit in Survival", "vivecraft.options.REVERSE_HANDS": "Reverse Hands", @@ -235,6 +237,8 @@ "vivecraft.options.WEAPON_COLLISION.tooltip": "Enables hitting blocks and entities in roomscale.\nAuto is on in survival and off in creative.", "vivecraft.options.FEET_COLLISION.tooltip": "Enables hitting blocks and entities in roomscale with your feet.\n§6Needs Full Body Tracking to work.\n§6Needs 'Weapon Collision' enabled to work.", "vivecraft.options.SWORD_BLOCK_COLLISION.tooltip": "Enables hitting blocks with swords that can be mined or instantly broken by them.\n§6Has no effect when 'Weapon Collision' is disabled", + "vivecraft.options.ONLY_SWORD_COLLISION.tooltip": "If enabled, only swords cause block/entity damage.", + "vivecraft.options.REDUCED_PLAYER_REACH.tooltip": "If enabled, reduces the roomscale reach for hitting other players, to avoid accidental hits.", "vivecraft.options.ALLOW_CRAWLING.tooltip": "If enabled the player will be able to duck under block.", "vivecraft.options.LIMIT_TELEPORT.tooltip": "If enabled the arc teleporter will be have restrictions in survival mode. It will not be able to jump up the side of blocks, it will consume food, and it will have an energy bar that refills over time.", "vivecraft.options.REVERSE_HANDS.tooltip": "Swap left/right hands as dominant.\n ON: Left dominant\n OFF: Right dominant\n\nTo swap the buttons, restart the game and make sure default bindings are selected in SteamVR.", @@ -440,12 +444,14 @@ "vivecraft.options.screen.debug": "Debug Render Settings", "vivecraft.options.screen.fbtcalibration": "Full Body Tracking Calibration", "vivecraft.options.screen.playermodel": "Playermodel Settings", + "vivecraft.options.screen.weaponcollision": "Weapon Collision Settings", "_comment_m2": "Buttons that lead to the screen", "vivecraft.options.screen.mixedreality.button": "Mixed Reality Settings...", "vivecraft.options.screen.posteffects.button": "Postprocessing Settings...", "vivecraft.options.screen.shadercompat.button": "Shader Compat Settings...", "vivecraft.options.screen.fbtcalibration.button": "Calibrate FBT...", "vivecraft.options.screen.playermodel.button": "Playermodel Settings...", + "vivecraft.options.screen.weaponcollision.button": "Weapon Collision...", "_comment_m0": "Option values", "vivecraft.options.shaderguirender.aftershader": "After Shader", "vivecraft.options.shaderguirender.aftertranslucent": "Translucent", diff --git a/common/src/main/resources/vivecraft.iris.mixins.json b/common/src/main/resources/vivecraft.iris.mixins.json index 96fa29464..25b9c549b 100644 --- a/common/src/main/resources/vivecraft.iris.mixins.json +++ b/common/src/main/resources/vivecraft.iris.mixins.json @@ -7,18 +7,22 @@ "IrisBeginFrameHack", "IrisBlockRenderingSettingsMixin", "IrisCameraUniformsMixin", + "irisshaders.IrisCommonUniformsMixin", "IrisDHCompatVRMixin", "IrisHandRendererVRMixin", "IrisLodRenderProgramVRMixin", "IrisProgramUniformsMixin", "IrisShadowMatricesMixin", "IrisShadowRendererMixin", + "irisshaders.IrisStandardMacrosMixin", "JcppProcessorVRMixin", "coderbot.IrisChunkProgramOverridesMixin", "coderbot.IrisChunkProgramOverridesMixinSodium_0_4_11", "coderbot.IrisChunkProgramOverridesMixinSodium_0_4_9", + "coderbot.IrisCommonUniformsMixin", "coderbot.IrisNewWorldRenderingPipelineVRMixin", "coderbot.IrisPipelineManagerVRMixin", + "coderbot.IrisStandardMacrosMixin", "irisshaders.IrisChunkProgramOverridesMixin", "irisshaders.IrisChunkProgramOverridesMixinSodium_0_5_8", "irisshaders.IrisChunkProgramOverridesMixinSodium_0_6", diff --git a/common/src/main/resources/vivecraft.optifine.mixins.json b/common/src/main/resources/vivecraft.optifine.mixins.json index 304c539b3..3a646715e 100644 --- a/common/src/main/resources/vivecraft.optifine.mixins.json +++ b/common/src/main/resources/vivecraft.optifine.mixins.json @@ -6,6 +6,7 @@ "client": [ "OptifineLiquidBlockRendererMixin", "OptifineModelBlockRendererMixin", + "ShaderMacrosVRMixin", "ShaderPackParserVRMixin", "ShadersRenderVRMixin", "ShadersVRMixin" diff --git a/fabric/build.gradle b/fabric/build.gradle index 7666d8ddf..733b6f1fd 100644 --- a/fabric/build.gradle +++ b/fabric/build.gradle @@ -63,10 +63,10 @@ dependencies { include(implementation('com.electronwill.night-config:toml:3.6.6')) include(implementation('com.electronwill.night-config:core:3.6.6')) - include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}")) - include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux")) - include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos")) - include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows")) + include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}")) { transitive = false } + include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux")) { transitive = false } + include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos")) { transitive = false } + include(implementation("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows")) { transitive = false } include(implementation("com.illposed.osc:javaosc-core:0.9")) diff --git a/fabric/src/main/java/org/vivecraft/client/fabric/XplatImpl.java b/fabric/src/main/java/org/vivecraft/client/fabric/XplatImpl.java index dba56e389..9a8d8d669 100644 --- a/fabric/src/main/java/org/vivecraft/client/fabric/XplatImpl.java +++ b/fabric/src/main/java/org/vivecraft/client/fabric/XplatImpl.java @@ -5,6 +5,7 @@ import net.fabricmc.api.EnvType; import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking; import net.fabricmc.fabric.api.client.render.fluid.v1.FluidRenderHandlerRegistry; +import net.fabricmc.fabric.api.entity.FakePlayer; import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking; import net.fabricmc.loader.api.FabricLoader; import net.minecraft.client.ClientBrandRetriever; @@ -15,6 +16,7 @@ import net.minecraft.core.BlockPos; import net.minecraft.network.FriendlyByteBuf; import net.minecraft.network.protocol.Packet; +import net.minecraft.server.level.ServerPlayer; import net.minecraft.tags.FluidTags; import net.minecraft.world.entity.EquipmentSlot; import net.minecraft.world.item.ItemStack; @@ -149,4 +151,8 @@ public static int getKeyModifier(KeyMapping keyMapping) { public static int getKeyModifierKey(KeyMapping keyMapping) { return -1; } + + public static boolean isFakePlayer(ServerPlayer player) { + return isModLoaded("fabric-events-interaction-v0") && player instanceof FakePlayer; + } } diff --git a/forge/build.gradle b/forge/build.gradle index 46f001850..fc1bde3d4 100644 --- a/forge/build.gradle +++ b/forge/build.gradle @@ -56,10 +56,11 @@ dependencies { // modCompileOnly("maven.modrinth:rubidium:0.6.5") // modCompileOnly("maven.modrinth:oculus:1.20-1.6.4") - forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}") - forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux") - forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos") - forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows") + forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}") { transitive = false } + forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-linux") { transitive = false } + forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-macos") { transitive = false } + forgeRuntimeLibrary("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}:natives-windows") { transitive = false } + forgeRuntimeLibrary("com.illposed.osc:javaosc-core:0.9") { transitive = false } // shadow the natives bundle("org.lwjgl:lwjgl-openvr:${rootProject.lwjgl_version}") { transitive = false } diff --git a/forge/src/main/java/org/vivecraft/client/forge/XplatImpl.java b/forge/src/main/java/org/vivecraft/client/forge/XplatImpl.java index 21f875812..06673ae2c 100644 --- a/forge/src/main/java/org/vivecraft/client/forge/XplatImpl.java +++ b/forge/src/main/java/org/vivecraft/client/forge/XplatImpl.java @@ -10,6 +10,7 @@ import net.minecraft.world.entity.EquipmentSlot; import net.minecraft.world.entity.ai.attributes.AttributeModifier; import net.minecraft.world.item.ItemStack; +import net.minecraft.server.level.ServerPlayer; import net.minecraft.world.level.BlockAndTintGetter; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.biome.BiomeSpecialEffects; @@ -151,4 +152,10 @@ public static int getKeyModifierKey(KeyMapping keyMapping) { default -> -1; }; } + + public static boolean isFakePlayer(ServerPlayer player) { + // TODO check if forge reimplemented it, it was removed with 1.20.3 + // return player instanceof FakePlayer; + return false; + } } diff --git a/gradle.properties b/gradle.properties index c563e2f2a..3df9282e3 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,7 +4,7 @@ minecraft_version=1.20.1 enabled_platforms=fabric,forge archives_base_name=vivecraft -mod_version=1.2.2 +mod_version=1.2.4 maven_group=org.vivecraft lwjgl_version=3.3.2 diff --git a/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java b/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java new file mode 100644 index 000000000..b08eafdcc --- /dev/null +++ b/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java @@ -0,0 +1,19 @@ +package net.coderbot.iris.gl.uniform; + +import org.joml.Matrix4fc; +import org.joml.Vector3f; + +import java.util.function.BooleanSupplier; +import java.util.function.IntSupplier; +import java.util.function.Supplier; + +public interface UniformHolder { + + UniformHolder uniform1i(UniformUpdateFrequency updateFrequency, String name, IntSupplier value); + + UniformHolder uniform1b(UniformUpdateFrequency updateFrequency, String name, BooleanSupplier value); + + UniformHolder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier value); + + UniformHolder uniformMatrix(UniformUpdateFrequency updateFrequency, String name, Supplier value); +} diff --git a/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java b/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java new file mode 100644 index 000000000..357ef23ef --- /dev/null +++ b/stubs/src/main/java/net/coderbot/iris/gl/uniform/UniformUpdateFrequency.java @@ -0,0 +1,8 @@ +package net.coderbot.iris.gl.uniform; + +public enum UniformUpdateFrequency { + ONCE, + PER_TICK, + PER_FRAME, + CUSTOM +} diff --git a/stubs/src/main/java/net/coderbot/iris/helpers/StringPair.java b/stubs/src/main/java/net/coderbot/iris/helpers/StringPair.java new file mode 100644 index 000000000..c7b7f8ed4 --- /dev/null +++ b/stubs/src/main/java/net/coderbot/iris/helpers/StringPair.java @@ -0,0 +1,3 @@ +package net.coderbot.iris.helpers; + +public class StringPair {} diff --git a/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformHolder.java b/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformHolder.java new file mode 100644 index 000000000..7325d99aa --- /dev/null +++ b/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformHolder.java @@ -0,0 +1,19 @@ +package net.irisshaders.iris.gl.uniform; + +import org.joml.Matrix4fc; +import org.joml.Vector3f; + +import java.util.function.BooleanSupplier; +import java.util.function.IntSupplier; +import java.util.function.Supplier; + +public interface UniformHolder { + + UniformHolder uniform1i(UniformUpdateFrequency updateFrequency, String name, IntSupplier value); + + UniformHolder uniform1b(UniformUpdateFrequency updateFrequency, String name, BooleanSupplier value); + + UniformHolder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier value); + + UniformHolder uniformMatrix(UniformUpdateFrequency updateFrequency, String name, Supplier value); +} diff --git a/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformUpdateFrequency.java b/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformUpdateFrequency.java new file mode 100644 index 000000000..3d905744b --- /dev/null +++ b/stubs/src/main/java/net/irisshaders/iris/gl/uniform/UniformUpdateFrequency.java @@ -0,0 +1,8 @@ +package net.irisshaders.iris.gl.uniform; + +public enum UniformUpdateFrequency { + ONCE, + PER_TICK, + PER_FRAME, + CUSTOM +} diff --git a/stubs/src/main/java/net/irisshaders/iris/helpers/StringPair.java b/stubs/src/main/java/net/irisshaders/iris/helpers/StringPair.java new file mode 100644 index 000000000..3ce938b24 --- /dev/null +++ b/stubs/src/main/java/net/irisshaders/iris/helpers/StringPair.java @@ -0,0 +1,3 @@ +package net.irisshaders.iris.helpers; + +public record StringPair(String key, String value) {}