mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-19 11:59:26 +00:00
Add Easing stuff
This commit is contained in:
1 parent
06a8317860
commit
689db91622
31 files changed
+3008
-270
No files matched your search
@@ -3,7 +3,6 @@ package kamkeel.npcs.command.profile;
|
||||
import net.minecraft.command.CommandException;
|
||||
import net.minecraft.command.ICommandSender;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.util.ChatComponentTranslation;
|
||||
import noppes.npcs.CustomNpcsPermissions;
|
||||
|
||||
import java.lang.reflect.Method;
|
||||
|
||||
@@ -292,6 +292,7 @@ public class ClientProxy extends CommonProxy {
|
||||
animNpc.display.texture = "customnpcs:textures/entity/humanmale/AnimationBody.png";
|
||||
save = false;
|
||||
}
|
||||
animNpc.display.setName("Animation Dude");
|
||||
return new GuiNPCManageAnimations(animNpc, save);
|
||||
} else if (gui == EnumGuiType.ManageLinked)
|
||||
return new GuiNPCManageLinked(npc);
|
||||
|
||||
@@ -8,7 +8,9 @@ import noppes.npcs.client.gui.SubGuiAnimationFrame;
|
||||
import noppes.npcs.client.gui.SubGuiAnimationOptions;
|
||||
import noppes.npcs.client.gui.SubGuiColorSelector;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
import noppes.npcs.client.gui.util.animation.AnimationGraphEditor;
|
||||
import noppes.npcs.constants.EnumAnimationPart;
|
||||
import noppes.npcs.constants.animation.EnumFrameType;
|
||||
import noppes.npcs.controllers.data.Animation;
|
||||
import noppes.npcs.controllers.data.AnimationData;
|
||||
import noppes.npcs.controllers.data.Frame;
|
||||
@@ -34,6 +36,7 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
private final GuiScreen parent;
|
||||
private long prevTick;
|
||||
|
||||
|
||||
private final GuiNpcSlider[] rotationSliders = new GuiNpcSlider[3];
|
||||
private final GuiNpcSlider[] pivotSliders = new GuiNpcSlider[3];
|
||||
|
||||
@@ -42,12 +45,18 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
private final int visibleFrames = 25;
|
||||
private boolean overrideFrame = false;
|
||||
|
||||
public AnimationGraphEditor graphEditor;
|
||||
public GuiNpcButton toggleGraph;
|
||||
private boolean toggleGraphEditor = true;
|
||||
|
||||
public GuiNPCEditAnimation(GuiScreen parent, Animation animation, EntityNPCInterface npc) {
|
||||
super((EntityCustomNpc) npc);
|
||||
this.parent = parent;
|
||||
this.followMouse = false;
|
||||
xOffset = 0;
|
||||
yOffset = -21;
|
||||
maxZoom = 120;
|
||||
drawRenderButtons = false;
|
||||
|
||||
this.animation = animation;
|
||||
AnimationData data = npc.display.animationData;
|
||||
@@ -61,6 +70,7 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
this.pivotSliders[i] = new GuiNpcSlider(this, 95 + i, guiLeft + bodyPartX, guiTop + bodyPartY + 115 + (20 * i), 0.5F);
|
||||
}
|
||||
|
||||
graphEditor = new AnimationGraphEditor(this);
|
||||
this.frameSlider = new GuiNpcSlider(this, 350, 0, 0, 0.0F);
|
||||
}
|
||||
|
||||
@@ -68,7 +78,17 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
public void initGui() {
|
||||
super.initGui();
|
||||
|
||||
if (animation == null) return;
|
||||
if (animation == null)
|
||||
return;
|
||||
yOffset = -21;
|
||||
|
||||
addButton(toggleGraph = new GuiNpcButton(777, guiLeft - 80, guiTop - 2 + 84, 70, 20, "Toggle Graph"));
|
||||
if (toggleGraphEditor) {
|
||||
yOffset = -80;
|
||||
graphEditor.initGui(guiLeft - 10, guiTop + 135, guiLeft - 10 + xSize, guiTop + 135 + 120);
|
||||
addGraphEditor(0, graphEditor);
|
||||
|
||||
}
|
||||
|
||||
frameIndex = !animation.frames.isEmpty() ? frameIndex % animation.frames.size() : 0;
|
||||
this.updateSliders();
|
||||
@@ -98,20 +118,18 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
data.animation.smooth = animation.smooth;
|
||||
data.animation.loop = 0;
|
||||
if (editingFrame != null) {
|
||||
data.animation.frames.add(editingFrame);
|
||||
data.animation.addFrame(editingFrame);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for (Frame frame : animation.frames) {
|
||||
frame.parent = animation;
|
||||
if (!frame.isCustomized()) {
|
||||
frame.speed = animation.speed;
|
||||
frame.smooth = animation.smooth;
|
||||
}
|
||||
for (Map.Entry<EnumAnimationPart, FramePart> entry : frame.frameParts.entrySet()) {
|
||||
FramePart part = entry.getValue();
|
||||
part.parent = animation;
|
||||
if (!part.isCustomized()) {
|
||||
part.speed = frame.speed;
|
||||
part.smooth = frame.smooth;
|
||||
@@ -129,37 +147,6 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
overrideFrame = false;
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(10, "animation.frames", guiLeft + 40, guiTop + 176 - 10, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(11, guiLeft - 10, guiTop + 189 - 10, 45, 20, "gui.add"));
|
||||
if (!animation.frames.isEmpty()) {
|
||||
this.addButton(new GuiNpcButton(12, guiLeft + 35, guiTop + 189 - 10, 45, 20, "gui.remove"));
|
||||
this.addButton(new GuiNpcButton(13, guiLeft + 80, guiTop + 189 - 10, 45, 20, "gui.copy"));
|
||||
this.addButton(new GuiNpcButton(14, guiLeft - 10, guiTop + 210 - 3, 20, 20, "<"));
|
||||
this.addTextField(new GuiNpcTextField(15, this, guiLeft + 15, guiTop + 212 - 3, 20, 17, frameIndex + ""));
|
||||
this.getTextField(15).integersOnly = true;
|
||||
this.getTextField(15).setMinMaxDefault(0, animation.frames.size() - 1, frameIndex);
|
||||
this.addButton(new GuiNpcButton(16, guiLeft + 40, guiTop + 210 - 3, 20, 20, ">"));
|
||||
}
|
||||
|
||||
int playPauseX = 330;
|
||||
int playPauseY = 10;
|
||||
String animTexture = "customnpcs:textures/gui/animation.png";
|
||||
if (data.animation != null && data.animation.frames.size() > 0) {
|
||||
if (!this.playingAnimation || data.animation.paused) {//Play
|
||||
this.addLabel(new GuiNpcLabel(210, data.animation.paused ? "animation.paused" : "animation.stopped", guiLeft + playPauseX - 15, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
if (data.animation.paused) {
|
||||
this.addLabel(new GuiNpcLabel(211, "", guiLeft + playPauseX + 21, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
}
|
||||
this.addButton(new GuiTexturedButton(200, "", guiLeft + playPauseX + 35, guiTop + playPauseY + 197, 11, 20, animTexture, 18, 71));
|
||||
} else {//Pause
|
||||
this.addLabel(new GuiNpcLabel(212, "animation.playing", guiLeft + playPauseX - 15, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(213, "", guiLeft + playPauseX + 20, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
this.addButton(new GuiTexturedButton(201, "", guiLeft + playPauseX + 35, guiTop + playPauseY + 197, 14, 20, animTexture, 0, 71));
|
||||
}
|
||||
if (this.playingAnimation) {//Stop
|
||||
this.addButton(new GuiTexturedButton(202, "", guiLeft + playPauseX + 55, guiTop + playPauseY + 197, 14, 20, animTexture, 33, 71));
|
||||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
@@ -194,174 +181,211 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
if (editingFrame != null) {
|
||||
int frameX = animationX;
|
||||
int frameY = playPauseY + 100;
|
||||
if (!toggleGraphEditor) {
|
||||
int guiLeft = this.guiLeft;
|
||||
this.addLabel(new GuiNpcLabel(10, "animation.frames", guiLeft + 40, guiTop + 176 - 10, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(11, guiLeft - 10, guiTop + 189 - 10, 45, 20, "gui.add"));
|
||||
if (!animation.frames.isEmpty()) {
|
||||
this.addButton(new GuiNpcButton(12, guiLeft + 35, guiTop + 189 - 10, 45, 20, "gui.remove"));
|
||||
this.addButton(new GuiNpcButton(13, guiLeft + 80, guiTop + 189 - 10, 45, 20, "gui.copy"));
|
||||
this.addButton(new GuiNpcButton(14, guiLeft - 10, guiTop + 210 - 3, 20, 20, "<"));
|
||||
this.addTextField(new GuiNpcTextField(15, this, guiLeft + 15, guiTop + 212 - 3, 20, 17, frameIndex + ""));
|
||||
this.getTextField(15).integersOnly = true;
|
||||
this.getTextField(15).setMinMaxDefault(0, animation.frames.size() - 1, frameIndex);
|
||||
this.addButton(new GuiNpcButton(16, guiLeft + 40, guiTop + 210 - 3, 20, 20, ">"));
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(50, "animation.frame", guiLeft + frameX + 50, guiTop + frameY - 3, 0xFFFFFF));
|
||||
//
|
||||
//duration - textfield
|
||||
this.addLabel(new GuiNpcLabel(51, "animation.duration", guiLeft + frameX, guiTop + frameY + 15, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(51, this, guiLeft + frameX + 88, guiTop + frameY + 11, 30, 15, editingFrame.duration + ""));
|
||||
this.getTextField(51).integersOnly = true;
|
||||
this.getTextField(51).setMinMaxDefaultFloat(0, Integer.MAX_VALUE, 10);
|
||||
int playPauseX = 330;
|
||||
int playPauseY = 10;
|
||||
|
||||
this.addButton(new GuiNpcButton(52, guiLeft + frameX, guiTop + frameY + 31, 80, 20, "animation.frameOptions"));
|
||||
this.addButton(new GuiNpcButton(53, guiLeft + frameX + getButton(52).width + 5, guiTop + frameY + 31, 35, 20, "gui.color"));
|
||||
|
||||
int bodyPartX = 280;
|
||||
int bodyPartY = -5;
|
||||
|
||||
//
|
||||
//6 body part textured buttons
|
||||
//Add/remove part button
|
||||
// 6 custom GUI textured buttons for each body part determine "this.currentPart (enum)".
|
||||
// If the current frame doesn't have that part, the button will say "Add part"
|
||||
// otherwise, the button will say "Remove", and more options for editing the part become available:
|
||||
//
|
||||
|
||||
//Head
|
||||
this.addButton(new GuiTexturedButton(60, "", guiLeft + bodyPartX, guiTop + bodyPartY, 22, 23, animTexture, 0, 0));
|
||||
//Body
|
||||
this.addButton(new GuiTexturedButton(61, "", guiLeft + bodyPartX, guiTop + bodyPartY + 23, 22, 23, animTexture, 24, 0));
|
||||
//Right Arm
|
||||
this.addButton(new GuiTexturedButton(62, "", guiLeft + bodyPartX - 9, guiTop + bodyPartY + 23, 8, 23, animTexture, 48, 0));
|
||||
//Left Arm
|
||||
this.addButton(new GuiTexturedButton(63, "", guiLeft + bodyPartX + 26, guiTop + bodyPartY + 23, 8, 23, animTexture, 48, 0));
|
||||
//Right Leg
|
||||
this.addButton(new GuiTexturedButton(64, "", guiLeft + bodyPartX + 1, guiTop + bodyPartY + 48, 10, 23, animTexture, 58, 0));
|
||||
//Left Leg
|
||||
this.addButton(new GuiTexturedButton(65, "", guiLeft + bodyPartX + 12, guiTop + bodyPartY + 48, 10, 23, animTexture, 58, 0));
|
||||
//Full Body
|
||||
this.addButton(new GuiTexturedButton(66, "", guiLeft + bodyPartX + 40, guiTop + bodyPartY + 2, 17, 23, animTexture, 70, 0));
|
||||
|
||||
for (int i = 0; i < 7; i++) {
|
||||
if (this.buttons.containsKey(60 + i)) {
|
||||
((GuiTexturedButton) this.getButton(60 + i)).scale = 1.2F;
|
||||
if (!editingFrame.frameParts.containsKey(EnumAnimationPart.values()[i])) {
|
||||
((GuiTexturedButton) this.getButton(60 + i)).textureX += 96;
|
||||
String animTexture = "customnpcs:textures/gui/animation.png";
|
||||
if (data.animation != null && data.animation.frames.size() > 0) {
|
||||
if (!this.playingAnimation || data.animation.paused) {//Play
|
||||
this.addLabel(new GuiNpcLabel(210, data.animation.paused ? "animation.paused" : "animation.stopped", guiLeft + playPauseX - 15, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
if (data.animation.paused) {
|
||||
this.addLabel(new GuiNpcLabel(211, "", guiLeft + playPauseX + 21, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
}
|
||||
this.addButton(new GuiTexturedButton(200, "", guiLeft + playPauseX + 35, guiTop + playPauseY + 197, 11, 20, animTexture, 18, 71));
|
||||
} else {//Pause
|
||||
this.addLabel(new GuiNpcLabel(212, "animation.playing", guiLeft + playPauseX - 15, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(213, "", guiLeft + playPauseX + 20, guiTop + playPauseY + 203, 0xFFFFFF));
|
||||
this.addButton(new GuiTexturedButton(201, "", guiLeft + playPauseX + 35, guiTop + playPauseY + 197, 14, 20, animTexture, 0, 71));
|
||||
}
|
||||
if (this.playingAnimation) {//Stop
|
||||
this.addButton(new GuiTexturedButton(202, "", guiLeft + playPauseX + 55, guiTop + playPauseY + 197, 14, 20, animTexture, 33, 71));
|
||||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
if (editingFrame != null) {
|
||||
int frameX = animationX;
|
||||
int frameY = playPauseY + 100;
|
||||
|
||||
if (editingPart != null) {
|
||||
//remove part button
|
||||
this.addLabel(new GuiNpcLabel(67, editingPart.part.name(), guiLeft + bodyPartX + 65, guiTop + bodyPartY + 20, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(67, guiLeft + bodyPartX + 45, guiTop + bodyPartY + 35, 60, 20, "gui.remove"));
|
||||
this.addLabel(new GuiNpcLabel(50, "animation.frame", guiLeft + frameX + 50, guiTop + frameY - 3, 0xFFFFFF));
|
||||
//
|
||||
//duration - textfield
|
||||
this.addLabel(new GuiNpcLabel(51, "animation.duration", guiLeft + frameX, guiTop + frameY + 15, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(51, this, guiLeft + frameX + 88, guiTop + frameY + 11, 30, 15, editingFrame.duration + ""));
|
||||
this.getTextField(51).integersOnly = true;
|
||||
this.getTextField(51).setMinMaxDefaultFloat(0, Integer.MAX_VALUE, 10);
|
||||
|
||||
this.addButton(new GuiNpcButton(68, guiLeft + bodyPartX + 45, guiTop + bodyPartY + 57, 60, 20, new String[]{"model.sliders", "model.manual"}, partEditMode));
|
||||
this.addButton(new GuiNpcButton(52, guiLeft + frameX, guiTop + frameY + 31, 80, 20, "animation.frameOptions"));
|
||||
this.addButton(new GuiNpcButton(53, guiLeft + frameX + getButton(52).width + 5, guiTop + frameY + 31, 35, 20, "gui.color"));
|
||||
|
||||
if (partEditMode == 0) {
|
||||
this.addButton(new GuiNpcButton(69, guiLeft + bodyPartX, guiTop + bodyPartY + 80, 60, 20, "model.rotate"));
|
||||
this.addButton(new GuiNpcButton(70, guiLeft + bodyPartX + 62, guiTop + bodyPartY + 80, 60, 20, "model.pivot"));
|
||||
int bodyPartX = 280;
|
||||
int bodyPartY = -5;
|
||||
|
||||
this.getButton(69).setEnabled(sliderSelection == 1);
|
||||
this.getButton(70).setEnabled(sliderSelection == 0);
|
||||
//
|
||||
//6 body part textured buttons
|
||||
//Add/remove part button
|
||||
// 6 custom GUI textured buttons for each body part determine "this.currentPart (enum)".
|
||||
// If the current frame doesn't have that part, the button will say "Add part"
|
||||
// otherwise, the button will say "Remove", and more options for editing the part become available:
|
||||
//
|
||||
|
||||
if (sliderSelection == 0) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
this.rotationSliders[i].width = 122;
|
||||
this.rotationSliders[i].height = 20;
|
||||
this.rotationSliders[i].xPosition = guiLeft + bodyPartX;
|
||||
//Head
|
||||
this.addButton(new GuiTexturedButton(60, "", guiLeft + bodyPartX, guiTop + bodyPartY, 22, 23, animTexture, 0, 0));
|
||||
//Body
|
||||
this.addButton(new GuiTexturedButton(61, "", guiLeft + bodyPartX, guiTop + bodyPartY + 23, 22, 23, animTexture, 24, 0));
|
||||
//Right Arm
|
||||
this.addButton(new GuiTexturedButton(62, "", guiLeft + bodyPartX - 9, guiTop + bodyPartY + 23, 8, 23, animTexture, 48, 0));
|
||||
//Left Arm
|
||||
this.addButton(new GuiTexturedButton(63, "", guiLeft + bodyPartX + 26, guiTop + bodyPartY + 23, 8, 23, animTexture, 48, 0));
|
||||
//Right Leg
|
||||
this.addButton(new GuiTexturedButton(64, "", guiLeft + bodyPartX + 1, guiTop + bodyPartY + 48, 10, 23, animTexture, 58, 0));
|
||||
//Left Leg
|
||||
this.addButton(new GuiTexturedButton(65, "", guiLeft + bodyPartX + 12, guiTop + bodyPartY + 48, 10, 23, animTexture, 58, 0));
|
||||
//Full Body
|
||||
this.addButton(new GuiTexturedButton(66, "", guiLeft + bodyPartX + 40, guiTop + bodyPartY + 2, 17, 23, animTexture, 70, 0));
|
||||
|
||||
int yOffset = 20;
|
||||
if (i != 0)
|
||||
yOffset += 3;
|
||||
yOffset *= i;
|
||||
this.rotationSliders[i].yPosition = guiTop + bodyPartY + 105 + yOffset;
|
||||
|
||||
this.addSlider(this.rotationSliders[i]);
|
||||
for (int i = 0; i < 7; i++) {
|
||||
if (this.buttons.containsKey(60 + i)) {
|
||||
((GuiTexturedButton) this.getButton(60 + i)).scale = 1.2F;
|
||||
if (!editingFrame.frameParts.containsKey(EnumAnimationPart.values()[i])) {
|
||||
((GuiTexturedButton) this.getButton(60 + i)).textureX += 96;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(90, "X", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 112, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(91, "Y", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 135, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(92, "Z", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 157, 0xFFFFFF));
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
if (editingPart != null) {
|
||||
//remove part button
|
||||
this.addLabel(new GuiNpcLabel(67, editingPart.part.name(), guiLeft + bodyPartX + 65, guiTop + bodyPartY + 20, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(67, guiLeft + bodyPartX + 45, guiTop + bodyPartY + 35, 60, 20, "gui.remove"));
|
||||
|
||||
this.addButton(new GuiNpcButton(68, guiLeft + bodyPartX + 45, guiTop + bodyPartY + 57, 60, 20, new String[]{"model.sliders", "model.manual"}, partEditMode));
|
||||
|
||||
if (partEditMode == 0) {
|
||||
this.addButton(new GuiNpcButton(69, guiLeft + bodyPartX, guiTop + bodyPartY + 80, 60, 20, "model.rotate"));
|
||||
this.addButton(new GuiNpcButton(70, guiLeft + bodyPartX + 62, guiTop + bodyPartY + 80, 60, 20, "model.pivot"));
|
||||
|
||||
this.getButton(69).setEnabled(sliderSelection == 1);
|
||||
this.getButton(70).setEnabled(sliderSelection == 0);
|
||||
|
||||
if (sliderSelection == 0) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
this.rotationSliders[i].width = 122;
|
||||
this.rotationSliders[i].height = 20;
|
||||
this.rotationSliders[i].xPosition = guiLeft + bodyPartX;
|
||||
|
||||
int yOffset = 20;
|
||||
if (i != 0)
|
||||
yOffset += 3;
|
||||
yOffset *= i;
|
||||
this.rotationSliders[i].yPosition = guiTop + bodyPartY + 105 + yOffset;
|
||||
|
||||
this.addSlider(this.rotationSliders[i]);
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(90, "X", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 112, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(91, "Y", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 135, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(92, "Z", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 157, 0xFFFFFF));
|
||||
} else {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
this.pivotSliders[i].width = 122;
|
||||
this.pivotSliders[i].height = 20;
|
||||
this.pivotSliders[i].xPosition = guiLeft + bodyPartX;
|
||||
|
||||
int yOffset = 20;
|
||||
if (i != 0)
|
||||
yOffset += 3;
|
||||
yOffset *= i;
|
||||
this.pivotSliders[i].yPosition = guiTop + bodyPartY + 105 + yOffset;
|
||||
this.addSlider(this.pivotSliders[i]);
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(95, "X", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 112, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(96, "Y", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 135, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(97, "Z", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 157, 0xFFFFFF));
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
this.pivotSliders[i].width = 122;
|
||||
this.pivotSliders[i].height = 20;
|
||||
this.pivotSliders[i].xPosition = guiLeft + bodyPartX;
|
||||
|
||||
int yOffset = 20;
|
||||
if (i != 0)
|
||||
yOffset += 3;
|
||||
yOffset *= i;
|
||||
this.pivotSliders[i].yPosition = guiTop + bodyPartY + 105 + yOffset;
|
||||
this.addSlider(this.pivotSliders[i]);
|
||||
//
|
||||
//rotation - 3 textfields
|
||||
this.addLabel(new GuiNpcLabel(70, "animation.rotations", guiLeft + bodyPartX, guiTop + bodyPartY + 85, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(70, this, guiLeft + bodyPartX, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[0] + ""));
|
||||
this.getTextField(70).floatsOnly = true;
|
||||
this.getTextField(70).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(71, this, guiLeft + bodyPartX + 40, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[1] + ""));
|
||||
this.getTextField(71).floatsOnly = true;
|
||||
this.getTextField(71).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(72, this, guiLeft + bodyPartX + 80, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[2] + ""));
|
||||
this.getTextField(72).floatsOnly = true;
|
||||
this.getTextField(72).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
//
|
||||
//pivot - 3 textfields
|
||||
this.addLabel(new GuiNpcLabel(80, "animation.pivots", guiLeft + bodyPartX, guiTop + bodyPartY + 117, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(80, this, guiLeft + bodyPartX, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[0] + ""));
|
||||
this.getTextField(80).floatsOnly = true;
|
||||
this.getTextField(80).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(81, this, guiLeft + bodyPartX + 40, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[1] + ""));
|
||||
this.getTextField(81).floatsOnly = true;
|
||||
this.getTextField(81).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(82, this, guiLeft + bodyPartX + 80, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[2] + ""));
|
||||
this.getTextField(82).floatsOnly = true;
|
||||
this.getTextField(82).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
//
|
||||
//customized - button, enables all the following options.
|
||||
this.addLabel(new GuiNpcLabel(83, "animation.customized", guiLeft + bodyPartX, guiTop + bodyPartY + 154, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(83, guiLeft + bodyPartX + 55, guiTop + bodyPartY + 148, 30, 20, new String[]{"gui.yes", "gui.no"}, editingPart.isCustomized() ? 0 : 1));
|
||||
if (editingPart.isCustomized()) {
|
||||
//
|
||||
//speed - textfield
|
||||
this.addLabel(new GuiNpcLabel(84, "stats.speed", guiLeft + bodyPartX, guiTop + bodyPartY + 174, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(84, this, guiLeft + bodyPartX + 60, guiTop + bodyPartY + 170, 30, 15, editingPart.speed + ""));
|
||||
this.getTextField(84).floatsOnly = true;
|
||||
this.getTextField(84).setMinMaxDefaultFloat(0, Float.MAX_VALUE, 1.0F);
|
||||
//
|
||||
//smooth - button
|
||||
this.addLabel(new GuiNpcLabel(85, "animation.smoothing", guiLeft + bodyPartX, guiTop + bodyPartY + 194, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(85, guiLeft + bodyPartX + 55, guiTop + bodyPartY + 190, 60, 20, new String[]{"animation.smooth", "animation.linear", "gui.none"}, editingPart.smooth));
|
||||
}
|
||||
|
||||
this.addLabel(new GuiNpcLabel(95, "X", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 112, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(96, "Y", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 135, 0xFFFFFF));
|
||||
this.addLabel(new GuiNpcLabel(97, "Z", guiLeft + bodyPartX - 10, guiTop + bodyPartY + 157, 0xFFFFFF));
|
||||
}
|
||||
} else {
|
||||
//
|
||||
//rotation - 3 textfields
|
||||
this.addLabel(new GuiNpcLabel(70, "animation.rotations", guiLeft + bodyPartX, guiTop + bodyPartY + 85, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(70, this, guiLeft + bodyPartX, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[0] + ""));
|
||||
this.getTextField(70).floatsOnly = true;
|
||||
this.getTextField(70).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(71, this, guiLeft + bodyPartX + 40, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[1] + ""));
|
||||
this.getTextField(71).floatsOnly = true;
|
||||
this.getTextField(71).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(72, this, guiLeft + bodyPartX + 80, guiTop + bodyPartY + 97, 35, 15, editingPart.rotation[2] + ""));
|
||||
this.getTextField(72).floatsOnly = true;
|
||||
this.getTextField(72).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
//
|
||||
//pivot - 3 textfields
|
||||
this.addLabel(new GuiNpcLabel(80, "animation.pivots", guiLeft + bodyPartX, guiTop + bodyPartY + 117, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(80, this, guiLeft + bodyPartX, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[0] + ""));
|
||||
this.getTextField(80).floatsOnly = true;
|
||||
this.getTextField(80).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(81, this, guiLeft + bodyPartX + 40, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[1] + ""));
|
||||
this.getTextField(81).floatsOnly = true;
|
||||
this.getTextField(81).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
this.addTextField(new GuiNpcTextField(82, this, guiLeft + bodyPartX + 80, guiTop + bodyPartY + 129, 35, 15, editingPart.pivot[2] + ""));
|
||||
this.getTextField(82).floatsOnly = true;
|
||||
this.getTextField(82).setMinMaxDefaultFloat(-Float.MAX_VALUE, Float.MAX_VALUE, 0);
|
||||
//
|
||||
//customized - button, enables all the following options.
|
||||
this.addLabel(new GuiNpcLabel(83, "animation.customized", guiLeft + bodyPartX, guiTop + bodyPartY + 154, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(83, guiLeft + bodyPartX + 55, guiTop + bodyPartY + 148, 30, 20, new String[]{"gui.yes", "gui.no"}, editingPart.isCustomized() ? 0 : 1));
|
||||
if (editingPart.isCustomized()) {
|
||||
//
|
||||
//speed - textfield
|
||||
this.addLabel(new GuiNpcLabel(84, "stats.speed", guiLeft + bodyPartX, guiTop + bodyPartY + 174, 0xFFFFFF));
|
||||
this.addTextField(new GuiNpcTextField(84, this, guiLeft + bodyPartX + 60, guiTop + bodyPartY + 170, 30, 15, editingPart.speed + ""));
|
||||
this.getTextField(84).floatsOnly = true;
|
||||
this.getTextField(84).setMinMaxDefaultFloat(0, Float.MAX_VALUE, 1.0F);
|
||||
//
|
||||
//smooth - button
|
||||
this.addLabel(new GuiNpcLabel(85, "animation.smoothing", guiLeft + bodyPartX, guiTop + bodyPartY + 194, 0xFFFFFF));
|
||||
this.addButton(new GuiNpcButton(85, guiLeft + bodyPartX + 55, guiTop + bodyPartY + 190, 60, 20, new String[]{"animation.smooth", "animation.linear", "gui.none"}, editingPart.smooth));
|
||||
}
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
} else {
|
||||
this.addLabel(new GuiNpcLabel(50, "animation.addFrame", guiLeft + 270, guiTop + 100, 0xFFFFFF));
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
} else {
|
||||
this.addLabel(new GuiNpcLabel(50, "animation.addFrame", guiLeft + 270, guiTop + 100, 0xFFFFFF));
|
||||
}
|
||||
this.addSlider(this.frameSlider);
|
||||
this.frameSlider.xPosition = guiLeft + 62;
|
||||
this.frameSlider.yPosition = guiTop + playPauseY + 197;
|
||||
this.frameSlider.width = 63;
|
||||
|
||||
this.addSlider(this.frameSlider);
|
||||
this.frameSlider.xPosition = guiLeft + 62;
|
||||
this.frameSlider.yPosition = guiTop + playPauseY + 197;
|
||||
this.frameSlider.width = 63;
|
||||
|
||||
for (int i = 0; i < this.visibleFrames; i++) {
|
||||
this.addButton(new GuiTexturedButton(300 + i, "", guiLeft + 130 + i * 7, guiTop + 210, 6, 20, animTexture, 0, 71));
|
||||
for (int i = 0; i < this.visibleFrames; i++) {
|
||||
this.addButton(new GuiTexturedButton(300 + i, "", guiLeft + 130 + i * 7, guiTop + 210, 6, 20, animTexture, 0, 71));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void updateSliders() {
|
||||
FramePart part = this.editingPart();
|
||||
if (part == null) return;
|
||||
if (part == null)
|
||||
return;
|
||||
|
||||
float[] rotations = part.getRotations();
|
||||
float[] pivots = part.getPivots();
|
||||
@@ -391,6 +415,22 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
return editingFrame.frameParts.get(this.editingPart);
|
||||
}
|
||||
|
||||
public boolean isMouseOverRenderer(int x, int y) {
|
||||
if (!allowRotate) {
|
||||
return false;
|
||||
}
|
||||
// Center of the entity rendering
|
||||
int centerX = guiLeft + 190 + xOffset; // Matches l in drawScreen()
|
||||
int centerY = guiTop + 80 + yOffset; // Matches i1 in drawScreen()
|
||||
|
||||
// Define separate buffers for X and Y axes
|
||||
int xBuffer = 75; // Horizontal buffer
|
||||
int yBuffer = 120; // Vertical buffer
|
||||
|
||||
// Check if the mouse is within the buffer area
|
||||
return mouseX >= centerX - xBuffer && mouseX <= centerX + xBuffer && mouseY >= centerY - yBuffer && mouseY <= centerY + yBuffer;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void actionPerformed(GuiButton guibutton) {
|
||||
super.actionPerformed(guibutton);
|
||||
@@ -406,9 +446,9 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
updateFrameSlider();
|
||||
} else if (guibutton.id == 13 && editingFrame != null) {
|
||||
if (frameIndex < animation.frames.size() - 1) {
|
||||
animation.frames.add(frameIndex + 1, editingFrame.copy());
|
||||
animation.addFrame(frameIndex + 1, editingFrame.copy());
|
||||
} else {
|
||||
animation.frames.add(editingFrame.copy());
|
||||
animation.addFrame(editingFrame.copy());
|
||||
}
|
||||
this.frameIndex = frameIndex + 1;
|
||||
updateFrameSlider();
|
||||
@@ -491,6 +531,10 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
}
|
||||
}
|
||||
|
||||
if (guibutton == toggleGraph) {
|
||||
toggleGraphEditor = !toggleGraphEditor;
|
||||
}
|
||||
|
||||
initGui();
|
||||
}
|
||||
|
||||
@@ -500,9 +544,9 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
|
||||
private void addFrame(Frame frame) {
|
||||
if (frameIndex < animation.frames.size() - 1) {
|
||||
animation.frames.add(frameIndex + 1, frame);
|
||||
animation.addFrame(frameIndex + 1, frame);
|
||||
} else {
|
||||
animation.frames.add(frame);
|
||||
animation.addFrame(frame);
|
||||
}
|
||||
this.frameIndex = frameIndex + 1;
|
||||
updateFrameSlider();
|
||||
@@ -510,7 +554,6 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
|
||||
@Override
|
||||
public void drawScreen(int par1, int par2, float par3) {
|
||||
super.drawScreen(par1, par2, par3);
|
||||
AnimationData data = npc.display.animationData;
|
||||
if (!data.isActive() && this.playingAnimation) {
|
||||
this.playingAnimation = false;
|
||||
@@ -518,6 +561,7 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
} else if (data.isActive()) {
|
||||
long time = mc.theWorld.getTotalWorldTime();
|
||||
if (time != prevTick) {
|
||||
npc.display.animationData.increaseTime();
|
||||
GuiNpcLabel label = this.getLabel(213);
|
||||
if (label != null) {
|
||||
label.label += ".";
|
||||
@@ -529,6 +573,8 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
prevTick = time;
|
||||
}
|
||||
|
||||
super.drawScreen(par1, par2, par3);
|
||||
|
||||
for (int i = 0; i < this.visibleFrames; i++) {
|
||||
if (getButton(300 + i) != null) {
|
||||
GuiTexturedButton button = (GuiTexturedButton) getButton(300 + i);
|
||||
@@ -564,7 +610,7 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
animation.name = text.replaceAll("[^a-zA-Z0-9_-]", "_");
|
||||
} else if (textfield.id == 15 && animation != null && animation.frames.size() > 0) {
|
||||
animation.frames.remove(frameIndex);
|
||||
animation.frames.add(textfield.getInteger(), frame);
|
||||
animation.addFrame(textfield.getInteger(), frame);
|
||||
frameIndex = textfield.getInteger();
|
||||
overrideFrame = true;
|
||||
initGui();
|
||||
@@ -575,14 +621,25 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
} else if (textfield.id == 51 && frame != null) {
|
||||
frame.duration = textfield.getInteger();
|
||||
} else if (textfield.id >= 70 && textfield.id <= 73 && part != null) {
|
||||
part.rotation[textfield.id - 70] = textfield.getFloat();
|
||||
int index = textfield.id - 70;
|
||||
float value = textfield.getFloat();
|
||||
part.rotation[index] = value;
|
||||
part.addValue(EnumFrameType.values()[index], value);
|
||||
this.updateSliders();
|
||||
} else if (textfield.id >= 80 && textfield.id <= 83 && part != null) {
|
||||
part.pivot[textfield.id - 80] = textfield.getFloat();
|
||||
int index = textfield.id - 80;
|
||||
float value = textfield.getFloat();
|
||||
part.pivot[index] = value;
|
||||
part.addValue(EnumFrameType.values()[3 + index], value);
|
||||
this.updateSliders();
|
||||
}
|
||||
}
|
||||
|
||||
public void onGuiClosed() {
|
||||
super.onGuiClosed();
|
||||
graphEditor.close();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void close() {
|
||||
if (!this.hasSubGui()) {
|
||||
@@ -618,13 +675,17 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
}
|
||||
if (id >= 90 && id < 93) {
|
||||
int value = (int) (360.0F * 2.0F * (guiNpcSlider.sliderValue - 0.5F));
|
||||
part.rotation[id - 90] = value;
|
||||
int index = id - 90;
|
||||
part.rotation[index] = value;
|
||||
part.addValue(EnumFrameType.values()[index], value);
|
||||
guiNpcSlider.setString(value + "");
|
||||
}
|
||||
if (id >= 95 && id < 98) {
|
||||
int value = (int) (100.0F * (guiNpcSlider.sliderValue - 0.5F));
|
||||
guiNpcSlider.setString(value + "");
|
||||
part.pivot[id - 95] = value;
|
||||
int index = id - 95;
|
||||
part.pivot[index] = value;
|
||||
part.addValue(EnumFrameType.values()[3 + index], value);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -648,7 +709,12 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
|
||||
@Override
|
||||
public void keyTyped(char par1, int par2) {
|
||||
boolean old = closeOnEsc;
|
||||
if (graphEditor.presetOverlay.showOverlay)
|
||||
closeOnEsc = false;
|
||||
|
||||
super.keyTyped(par1, par2);
|
||||
closeOnEsc = old;
|
||||
|
||||
if (GuiScreen.isCtrlKeyDown() && par2 != 29 && !GuiNpcTextField.isFieldActive()) {
|
||||
switch (par2) {
|
||||
@@ -660,7 +726,6 @@ public class GuiNPCEditAnimation extends GuiModelInterface implements ITextfield
|
||||
case 47:
|
||||
if (copiedFrame != null) {
|
||||
Frame frame = new Frame(10);
|
||||
frame.parent = this.animation;
|
||||
frame.readFromNBT(copiedFrame.writeToNBT());
|
||||
this.addFrame(frame);
|
||||
this.initGui();
|
||||
|
||||
@@ -38,6 +38,7 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
this.setSave(save);
|
||||
this.xOffset = -148 + 70;
|
||||
this.yOffset = -170 + 137;
|
||||
maxZoom = 120;
|
||||
PacketClient.sendClient(new AnimationsGetPacket());
|
||||
|
||||
AnimationData data = npc.display.animationData;
|
||||
@@ -73,9 +74,8 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
|
||||
if (this.animation.frames.size() > 0) {
|
||||
Frame firstFrame = new Frame();
|
||||
firstFrame.parent = data.animation;
|
||||
firstFrame.readFromNBT(this.animation.frames.get(0).writeToNBT());
|
||||
data.animation.addFrame(firstFrame);
|
||||
firstFrame.readFromNBT(this.animation.frames.get(0).writeToNBT());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -104,8 +104,7 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawScreen(int par1, int par2, float par3) {
|
||||
super.drawScreen(par1, par2, par3);
|
||||
public void drawScreen(int par1, int par2, float partialTicks) {
|
||||
AnimationData data = npc.display.animationData;
|
||||
if (!data.isActive() && this.playingAnimation) {
|
||||
this.playingAnimation = false;
|
||||
@@ -113,6 +112,7 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
} else if (data.isActive()) {
|
||||
long time = mc.theWorld.getTotalWorldTime();
|
||||
if (time != prevTick) {
|
||||
npc.display.animationData.increaseTime();
|
||||
GuiNpcLabel label = this.getLabel(94);
|
||||
if (label != null) {
|
||||
label.label += ".";
|
||||
@@ -123,6 +123,7 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
}
|
||||
prevTick = time;
|
||||
}
|
||||
super.drawScreen(par1, par2, partialTicks);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -276,4 +277,20 @@ public class GuiNPCManageAnimations extends GuiModelInterface2 implements IScrol
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isMouseOverRenderer(int x, int y) {
|
||||
if (!allowRotate) {
|
||||
return false;
|
||||
}
|
||||
// Center of the entity rendering
|
||||
int centerX = guiLeft + 190 + xOffset; // Matches l in drawScreen()
|
||||
int centerY = guiTop + 130 + yOffset; // Matches i1 in drawScreen()
|
||||
|
||||
// Define separate buffers for X and Y axes
|
||||
int xBuffer = 100; // Horizontal buffer
|
||||
int yBuffer = 90; // Vertical buffer
|
||||
|
||||
// Check if the mouse is within the buffer area
|
||||
return mouseX >= centerX - xBuffer && mouseX <= centerX + xBuffer && mouseY >= centerY - yBuffer && mouseY <= centerY + yBuffer;
|
||||
}
|
||||
}
|
||||
@@ -10,12 +10,10 @@ import net.minecraft.nbt.NBTTagList;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.NBTTags;
|
||||
import noppes.npcs.NoppesStringUtils;
|
||||
import noppes.npcs.client.NoppesUtil;
|
||||
import noppes.npcs.client.gui.global.GuiNPCManageLinked;
|
||||
import noppes.npcs.client.gui.util.*;
|
||||
import noppes.npcs.constants.EnumScriptType;
|
||||
import noppes.npcs.controllers.ScriptContainer;
|
||||
import noppes.npcs.controllers.ScriptController;
|
||||
import noppes.npcs.controllers.data.LinkedItem;
|
||||
import noppes.npcs.controllers.data.LinkedItemScript;
|
||||
|
||||
|
||||
@@ -21,7 +21,7 @@ public class GuiModelInterface extends GuiNPCInterface {
|
||||
private GuiNpcButton left, right, zoom, unzoom;
|
||||
|
||||
private static float zoomed = 60;
|
||||
public float minSize = 10, maxSize = 100;
|
||||
public float minZoom = 10, maxZoom = 100;
|
||||
|
||||
public int xOffset = 0, xOffsetButton = 0;
|
||||
public int yOffset = 0, yOffsetButton = 0;
|
||||
@@ -98,16 +98,16 @@ public class GuiModelInterface extends GuiNPCInterface {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawScreen(int par1, int par2, float par3) {
|
||||
if (Mouse.isButtonDown(0)) {
|
||||
public void drawScreen(int par1, int par2, float partialTicks) {
|
||||
if (Mouse.isButtonDown(0) && drawRenderButtons) {
|
||||
if (this.left.mousePressed(this.mc, par1, par2)) {
|
||||
rotation += par3 * 1.5F;
|
||||
rotation += partialTicks * 1.5F;
|
||||
} else if (this.right.mousePressed(this.mc, par1, par2)) {
|
||||
rotation -= par3 * 1.5F;
|
||||
} else if (this.zoom.mousePressed(this.mc, par1, par2) && zoomed < maxSize) {
|
||||
zoomed += par3 * 1.0F;
|
||||
} else if (this.unzoom.mousePressed(this.mc, par1, par2) && zoomed > minSize) {
|
||||
zoomed -= par3 * 1.0F;
|
||||
rotation -= partialTicks * 1.5F;
|
||||
} else if (this.zoom.mousePressed(this.mc, par1, par2) && zoomed < maxZoom) {
|
||||
zoomed += partialTicks * 1.0F;
|
||||
} else if (this.unzoom.mousePressed(this.mc, par1, par2) && zoomed > minZoom) {
|
||||
zoomed -= partialTicks * 1.0F;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -118,10 +118,10 @@ public class GuiModelInterface extends GuiNPCInterface {
|
||||
}
|
||||
}
|
||||
|
||||
if (zoomed > maxSize)
|
||||
zoomed = maxSize;
|
||||
if (zoomed < minSize)
|
||||
zoomed = minSize;
|
||||
if (zoomed > maxZoom)
|
||||
zoomed = maxZoom;
|
||||
if (zoomed < minZoom)
|
||||
zoomed = minZoom;
|
||||
|
||||
if (hasSubGui() && !drawNPConSub)
|
||||
return;
|
||||
@@ -156,13 +156,13 @@ public class GuiModelInterface extends GuiNPCInterface {
|
||||
GL11.glRotatef(-(float) Math.atan(f6 / 800F) * 20F, 1.0F, 0.0F, 0.0F);
|
||||
entity.prevRenderYawOffset = entity.renderYawOffset = rotation;
|
||||
entity.prevRotationYaw = entity.rotationYaw = (float) Math.atan(f5 / 80F) * 40F + rotation;
|
||||
entity.rotationPitch = followMouse ? -(float) Math.atan(f6 / 40F) * 20F : 0;
|
||||
entity.rotationPitch = entity.prevRotationPitch = followMouse ? -(float) Math.atan(f6 / 40F) * 20F : 0;
|
||||
entity.prevRotationYawHead = entity.rotationYawHead = followMouse ? entity.rotationYaw : rotation;
|
||||
GL11.glTranslatef(0.0F, entity.yOffset, 1F);
|
||||
RenderManager.instance.playerViewY = 180F;
|
||||
|
||||
try {
|
||||
RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, 1.0F);
|
||||
RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, partialTicks);
|
||||
} catch (Exception e) {
|
||||
playerdata.setEntityClass(null);
|
||||
}
|
||||
@@ -178,7 +178,7 @@ public class GuiModelInterface extends GuiNPCInterface {
|
||||
OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(0.0F, 0f, 500.065F);
|
||||
super.drawScreen(par1, par2, par3);
|
||||
super.drawScreen(par1, par2, partialTicks);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
postRender(entity);
|
||||
|
||||
@@ -22,6 +22,8 @@ public class GuiModelInterface2 extends GuiNPCInterface2 {
|
||||
private GuiNpcButton left, right, zoom, unzoom;
|
||||
|
||||
private static float zoomed = 60;
|
||||
public float minZoom = 10, maxZoom = 100;
|
||||
public boolean allowRotate = true;
|
||||
|
||||
public int xOffset = 0;
|
||||
public int yOffset = 0;
|
||||
@@ -60,21 +62,50 @@ public class GuiModelInterface2 extends GuiNPCInterface2 {
|
||||
|
||||
private long start = -1;
|
||||
|
||||
public boolean isMouseOverRenderer(int x, int y) {
|
||||
if (!allowRotate) {
|
||||
return false;
|
||||
}
|
||||
// Center of the entity rendering
|
||||
int centerX = guiLeft + 190 + xOffset; // Matches l in drawScreen()
|
||||
int centerY = guiTop + 180 + yOffset; // Matches i1 in drawScreen()
|
||||
|
||||
// Define separate buffers for X and Y axes
|
||||
int xBuffer = 100; // Horizontal buffer
|
||||
int yBuffer = 150; // Vertical buffer
|
||||
|
||||
// Check if the mouse is within the buffer area
|
||||
return mouseX >= centerX - xBuffer && mouseX <= centerX + xBuffer && mouseY >= centerY - yBuffer && mouseY <= centerY + yBuffer;
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public void drawScreen(int par1, int par2, float par3) {
|
||||
public void drawScreen(int par1, int par2, float partialTicks) {
|
||||
if (Mouse.isButtonDown(0)) {
|
||||
if (left.mousePressed(mc, par1, par2))
|
||||
rotation += par3 * 2;
|
||||
rotation += partialTicks * 2;
|
||||
else if (right.mousePressed(mc, par1, par2))
|
||||
rotation -= par3 * 2;
|
||||
rotation -= partialTicks * 2;
|
||||
else if (zoom.mousePressed(mc, par1, par2))
|
||||
zoomed += par3 * 2;
|
||||
zoomed += partialTicks * 2;
|
||||
else if (unzoom.mousePressed(mc, par1, par2) && zoomed > 10)
|
||||
zoomed -= par3 * 2;
|
||||
zoomed -= partialTicks * 2;
|
||||
|
||||
}
|
||||
|
||||
super.drawScreen(par1, par2, par3);
|
||||
if (isMouseOverRenderer(par1, par2)) {
|
||||
zoomed += Mouse.getDWheel() * 0.035f;
|
||||
if (Mouse.isButtonDown(0) || Mouse.isButtonDown(1)) {
|
||||
rotation -= Mouse.getDX() * 0.75f;
|
||||
}
|
||||
}
|
||||
|
||||
if (zoomed > maxZoom)
|
||||
zoomed = maxZoom;
|
||||
if (zoomed < minZoom)
|
||||
zoomed = minZoom;
|
||||
|
||||
super.drawScreen(par1, par2, partialTicks);
|
||||
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
|
||||
@@ -105,13 +136,13 @@ public class GuiModelInterface2 extends GuiNPCInterface2 {
|
||||
GL11.glRotatef(-(float) Math.atan(f6 / 80F) * 20F, 1.0F, 0.0F, 0.0F);
|
||||
entity.prevRenderYawOffset = entity.renderYawOffset = rotation;
|
||||
entity.prevRotationYaw = entity.rotationYaw = (float) Math.atan(f5 / 80F) * 40F + rotation;
|
||||
entity.rotationPitch = -(float) Math.atan(f6 / 80F) * 20F;
|
||||
entity.rotationPitch = entity.prevRotationPitch = -(float) Math.atan(f6 / 80F) * 20F;
|
||||
entity.prevRotationYawHead = entity.rotationYawHead = entity.rotationYaw;
|
||||
GL11.glTranslatef(0.0F, entity.yOffset, 0.0F);
|
||||
RenderManager.instance.playerViewY = 180F;
|
||||
|
||||
try {
|
||||
RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, 1.0F);
|
||||
RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, partialTicks);
|
||||
} catch (Exception e) {
|
||||
playerdata.setEntityClass(null);
|
||||
}
|
||||
|
||||
@@ -13,6 +13,7 @@ import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import noppes.npcs.client.CustomNpcResourceListener;
|
||||
import noppes.npcs.client.TextBlockClient;
|
||||
import noppes.npcs.client.gui.util.animation.ViewportGraphEditor;
|
||||
import noppes.npcs.entity.EntityNPCInterface;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.input.Mouse;
|
||||
@@ -37,6 +38,7 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
protected HashMap<Integer, GuiNpcSlider> sliders = new HashMap<Integer, GuiNpcSlider>();
|
||||
protected HashMap<Integer, GuiScreen> extra = new HashMap<Integer, GuiScreen>();
|
||||
protected HashMap<Integer, GuiScrollWindow> scrollWindows = new HashMap<>();
|
||||
protected HashMap<Integer, ViewportGraphEditor> graphEditors = new HashMap<>();
|
||||
protected HashMap<Integer, GuiDiagram> diagrams = new HashMap<>();
|
||||
|
||||
public static boolean resizingActive = false;
|
||||
@@ -92,6 +94,7 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
scrolls.clear();
|
||||
sliders.clear();
|
||||
scrollWindows.clear();
|
||||
graphEditors.clear();
|
||||
diagrams.clear();
|
||||
Keyboard.enableRepeatEvents(true);
|
||||
}
|
||||
@@ -106,6 +109,13 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
tf.updateCursorCounter();
|
||||
}
|
||||
super.updateScreen();
|
||||
|
||||
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values())
|
||||
guiScrollableComponent.updateScreen();
|
||||
|
||||
for (ViewportGraphEditor graphEditor : graphEditors.values())
|
||||
graphEditor.updateScreen();
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -120,6 +130,10 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
scrollWindows.put(id, gui);
|
||||
}
|
||||
|
||||
public void addGraphEditor(int id, ViewportGraphEditor graph) {
|
||||
graphEditors.put(id, graph);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a GuiDiagram to the interface.
|
||||
* The diagram is initialized with the current resolution and cached.
|
||||
@@ -145,6 +159,9 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
guiScrollableComponent.mouseClicked(i, j, k);
|
||||
}
|
||||
|
||||
for (ViewportGraphEditor graphEditor : graphEditors.values())
|
||||
graphEditor.mouseClicked(i, j, k);
|
||||
|
||||
if (k == 0) {
|
||||
for (GuiCustomScroll scroll : new ArrayList<GuiCustomScroll>(scrolls.values())) {
|
||||
scroll.mouseClicked(i, j, k);
|
||||
@@ -168,6 +185,10 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
subgui.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
|
||||
return;
|
||||
}
|
||||
|
||||
for (GuiScrollWindow window : scrollWindows.values())
|
||||
window.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
|
||||
|
||||
super.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
|
||||
}
|
||||
|
||||
@@ -202,9 +223,11 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
for (GuiNpcTextField tf : textfields.values())
|
||||
tf.textboxKeyTyped(c, i);
|
||||
|
||||
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) {
|
||||
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values())
|
||||
guiScrollableComponent.keyTyped(c, i);
|
||||
}
|
||||
|
||||
for (ViewportGraphEditor graphEditor : graphEditors.values())
|
||||
graphEditor.keyTyped(c, i);
|
||||
|
||||
// Fixes closing sub with escape closes all of its parents
|
||||
boolean enoughTimeSinceSubClosed = Minecraft.getSystemTime() - timeClosedSubGui > 50;
|
||||
@@ -310,16 +333,22 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
for (GuiNpcTextField tf : textfields.values()) {
|
||||
tf.drawTextBox(i, j);
|
||||
}
|
||||
int wheel = Mouse.getDWheel();
|
||||
for (GuiCustomScroll scroll : scrolls.values()) {
|
||||
scroll.updateSubGUI(subGui);
|
||||
scroll.drawScreen(i, j, f, !subGui && scroll.isMouseOver(i, j) ? Mouse.getDWheel() : 0);
|
||||
scroll.drawScreen(i, j, f, !subGui && scroll.isMouseOver(i, j) ? wheel : 0);
|
||||
}
|
||||
for (GuiScreen gui : extra.values())
|
||||
gui.drawScreen(i, j, f);
|
||||
|
||||
// Draw scrollable windows.
|
||||
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) {
|
||||
guiScrollableComponent.drawScreen(i, j, f, !subGui && guiScrollableComponent.isMouseOver(i, j) ? Mouse.getDWheel() : 0);
|
||||
guiScrollableComponent.drawScreen(i, j, f, !subGui && guiScrollableComponent.isMouseOver(i, j) ? wheel : 0);
|
||||
}
|
||||
|
||||
for (ViewportGraphEditor graphEditor : graphEditors.values())
|
||||
graphEditor.drawScreen(i, j, f, wheel);
|
||||
|
||||
for (GuiDiagram diagram : diagrams.values()) {
|
||||
diagram.drawDiagram(i, j, subGui);
|
||||
}
|
||||
@@ -442,7 +471,7 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
float f4 = entity.rotationPitch;
|
||||
float f7 = entity.rotationYawHead;
|
||||
float f5 = (float) (guiLeft + x) - mouseX;
|
||||
float f6 = (float) ((guiTop + y) - 50 * scale * zoomed) - mouseY;
|
||||
float f6 = (guiTop + y) - 50 * scale * zoomed - mouseY;
|
||||
int orientation = 0;
|
||||
if (npc != null) {
|
||||
orientation = npc.ais.orientation;
|
||||
@@ -484,8 +513,8 @@ public abstract class GuiNPCInterface extends GuiScreen {
|
||||
public void openLink(String link) {
|
||||
try {
|
||||
Class oclass = Class.forName("java.awt.Desktop");
|
||||
Object object = oclass.getMethod("getDesktop", new Class[0]).invoke((Object) null, new Object[0]);
|
||||
oclass.getMethod("browse", new Class[]{URI.class}).invoke(object, new Object[]{new URI(link)});
|
||||
Object object = oclass.getMethod("getDesktop", new Class[0]).invoke(null);
|
||||
oclass.getMethod("browse", new Class[]{URI.class}).invoke(object, new URI(link));
|
||||
} catch (Throwable throwable) {
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,8 +5,8 @@ import noppes.npcs.entity.EntityNPCInterface;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public abstract class GuiNPCInterface2 extends GuiNPCInterface {
|
||||
private ResourceLocation background = new ResourceLocation("customnpcs:textures/gui/menubg.png");
|
||||
private GuiNpcMenu menu;
|
||||
private final ResourceLocation background = new ResourceLocation("customnpcs:textures/gui/menubg.png");
|
||||
private final GuiNpcMenu menu;
|
||||
|
||||
public GuiNPCInterface2(EntityNPCInterface npc) {
|
||||
this(npc, -1);
|
||||
|
||||
@@ -113,6 +113,9 @@ public class GuiScrollWindow extends GuiScreen implements ITextfieldListener, IC
|
||||
public void mouseEvent(int i, int j, int k) {
|
||||
}
|
||||
|
||||
public void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void actionPerformed(GuiButton guibutton) {
|
||||
@@ -266,7 +269,7 @@ public class GuiScrollWindow extends GuiScreen implements ITextfieldListener, IC
|
||||
super.drawDefaultBackground();
|
||||
}
|
||||
|
||||
protected void setClip(int x, int y, int width, int height) {
|
||||
public void setClip(int x, int y, int width, int height) {
|
||||
if (scaledResolution == null)
|
||||
return;
|
||||
int scaleFactor = scaledResolution.getScaleFactor();
|
||||
|
||||
@@ -0,0 +1,164 @@
|
||||
package noppes.npcs.client.gui.util;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.ScaledResolution;
|
||||
import net.minecraft.client.renderer.OpenGlHelper;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public class GuiUtil {
|
||||
|
||||
public static void setScissorClip(int x, int y, int width, int height) {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution res = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
int scale = res.getScaleFactor();
|
||||
|
||||
|
||||
// Adjust position to Top-Left origin (OpenGL window/screen space uses bottom-left origin)
|
||||
y = mc.displayHeight - y * scale;
|
||||
height *= scale;
|
||||
|
||||
// Set clip
|
||||
GL11.glScissor(x * scale, y - height, width * scale, height);
|
||||
}
|
||||
|
||||
public static void drawHorizontalLine(double y, double startX, double endX, int color) {
|
||||
if (endX < startX) {
|
||||
double i1 = startX;
|
||||
startX = endX;
|
||||
endX = i1;
|
||||
}
|
||||
|
||||
drawRectD(startX, y, endX + 1, y + 1, color);
|
||||
}
|
||||
|
||||
public static void drawVerticalLine(double x, double startY, double endY, int color) {
|
||||
if (endY < startY) {
|
||||
double i1 = startY;
|
||||
startY = endY;
|
||||
endY = i1;
|
||||
}
|
||||
|
||||
drawRectD(x, startY + 1, x + 1, endY, color);
|
||||
}
|
||||
|
||||
public static void drawRectD(double left, double top, double right, double bottom, int color) {
|
||||
double j1;
|
||||
|
||||
if (left < right) {
|
||||
j1 = left;
|
||||
left = right;
|
||||
right = j1;
|
||||
}
|
||||
|
||||
if (top < bottom) {
|
||||
j1 = top;
|
||||
top = bottom;
|
||||
bottom = j1;
|
||||
}
|
||||
|
||||
float f3 = (float) (color >> 24 & 255) / 255.0F;
|
||||
float f = (float) (color >> 16 & 255) / 255.0F;
|
||||
float f1 = (float) (color >> 8 & 255) / 255.0F;
|
||||
float f2 = (float) (color & 255) / 255.0F;
|
||||
Tessellator tessellator = Tessellator.instance;
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
OpenGlHelper.glBlendFunc(770, 771, 1, 0);
|
||||
GL11.glColor4f(f, f1, f2, 1);
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.addVertex(left, bottom, 0.0D);
|
||||
tessellator.addVertex(right, bottom, 0.0D);
|
||||
tessellator.addVertex(right, top, 0.0D);
|
||||
tessellator.addVertex(left, top, 0.0D);
|
||||
tessellator.draw();
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
}
|
||||
|
||||
public static void drawGradientRect(int left, int top, int right, int bottom, int startColor, int endColor) {
|
||||
double zLevel = 0;
|
||||
|
||||
float f = (float) (startColor >> 24 & 255) / 255.0F;
|
||||
float f1 = (float) (startColor >> 16 & 255) / 255.0F;
|
||||
float f2 = (float) (startColor >> 8 & 255) / 255.0F;
|
||||
float f3 = (float) (startColor & 255) / 255.0F;
|
||||
float f4 = (float) (endColor >> 24 & 255) / 255.0F;
|
||||
float f5 = (float) (endColor >> 16 & 255) / 255.0F;
|
||||
float f6 = (float) (endColor >> 8 & 255) / 255.0F;
|
||||
float f7 = (float) (endColor & 255) / 255.0F;
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glDisable(GL11.GL_ALPHA_TEST);
|
||||
OpenGlHelper.glBlendFunc(770, 771, 1, 0);
|
||||
GL11.glShadeModel(GL11.GL_SMOOTH);
|
||||
Tessellator tessellator = Tessellator.instance;
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.setColorRGBA_F(f1, f2, f3, f);
|
||||
tessellator.addVertex(right, top, zLevel);
|
||||
tessellator.addVertex(left, top, zLevel);
|
||||
tessellator.setColorRGBA_F(f5, f6, f7, f4);
|
||||
tessellator.addVertex(left, bottom, zLevel);
|
||||
tessellator.addVertex(right, bottom, zLevel);
|
||||
tessellator.draw();
|
||||
GL11.glShadeModel(GL11.GL_FLAT);
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glEnable(GL11.GL_ALPHA_TEST);
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
}
|
||||
|
||||
public static void drawTexturedModalRect(double x, double y, double width, double height, int textureX, int textureY) {
|
||||
double zLevel = 0;
|
||||
float f = 1 / 256f;
|
||||
float f1 = 1 / 256f;
|
||||
Tessellator tessellator = Tessellator.instance;
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.addVertexWithUV(x + 0, y + height, zLevel, (float) (textureX) * f, (float) (textureY + height) * f1);
|
||||
tessellator.addVertexWithUV(x + width, y + height, zLevel, (float) (textureX + width) * f, (float) (textureY + height) * f1);
|
||||
tessellator.addVertexWithUV(x + width, y + 0, zLevel, (float) (textureX + width) * f, (float) (textureY) * f1);
|
||||
tessellator.addVertexWithUV(x + 0, y + 0, zLevel, (float) (textureX) * f, (float) (textureY) * f1);
|
||||
tessellator.draw();
|
||||
}
|
||||
|
||||
public static void setMouse(int guiX, int guiY) {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
|
||||
int factor = scaledResolution.getScaleFactor();
|
||||
|
||||
Mouse.setCursorPosition(guiX * factor, mc.displayHeight - (guiY * factor));
|
||||
}
|
||||
|
||||
public static void setMouseX(int guiX) {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
|
||||
int factor = scaledResolution.getScaleFactor();
|
||||
Mouse.setCursorPosition(guiX * factor, Mouse.getY());
|
||||
}
|
||||
|
||||
public static void setMouseY(int guiY) {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
|
||||
int factor = scaledResolution.getScaleFactor();
|
||||
Mouse.setCursorPosition(Mouse.getX(), mc.displayHeight - (guiY * factor));
|
||||
}
|
||||
|
||||
public static double preciseMouseX() {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
|
||||
double width = scaledResolution.getScaledWidth();
|
||||
return Mouse.getX() * width / mc.displayWidth;
|
||||
}
|
||||
|
||||
public static double preciseMouseY() {
|
||||
Minecraft mc = Minecraft.getMinecraft();
|
||||
ScaledResolution scaledResolution = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
|
||||
|
||||
double height = scaledResolution.getScaledHeight();
|
||||
return height - Mouse.getY() * height / mc.displayHeight - 1;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import noppes.npcs.client.gui.util.GuiNPCInterface;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.panel.PanelFrameType;
|
||||
|
||||
public class AnimationGraphEditor extends ViewportGraphEditor {
|
||||
public PanelFrameType frameTypePanel = new PanelFrameType(this);
|
||||
|
||||
public AnimationGraphEditor(GuiNPCInterface parent) {
|
||||
super(parent);
|
||||
}
|
||||
|
||||
public void initGui(int startX, int startY, int endX, int endY) {
|
||||
super.initGui(startX, startY, endX, endY);
|
||||
frameTypePanel.initGui(startX - 60, startY, startX, endY);
|
||||
}
|
||||
|
||||
public void drawScreen(int mouseX, int mouseY, float partialTicks, int wheel) {
|
||||
GuiUtil.drawGradientRect(startX, startY, endX, endY, 0xFF303030, 0xFF303030);
|
||||
|
||||
frameTypePanel.draw();
|
||||
grid.draw(mouseX, mouseY, partialTicks, wheel);
|
||||
presetOverlay.draw(mouseX, mouseY, wheel);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import org.lwjgl.BufferUtils;
|
||||
import org.lwjgl.LWJGLException;
|
||||
import org.lwjgl.input.Cursor;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public enum Cursors {
|
||||
|
||||
MOVE(0, 0, 0, 0, 19, 19);
|
||||
|
||||
|
||||
public int offsetX, offsetY, textureX, textureY, width, height;
|
||||
|
||||
Cursors(int offsetX, int offsetY, int textureX, int textureY, int width, int height) {
|
||||
|
||||
this.textureX = textureX;
|
||||
this.textureY = textureY;
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
this.offsetX = -width / 2;
|
||||
this.offsetY = offsetY;
|
||||
}
|
||||
|
||||
public void draw(double mouseX, double mouseY) {
|
||||
offsetX = width / 2;
|
||||
offsetY = height / 2;
|
||||
float scale = 0.5f;
|
||||
double screenX = (mouseX / scale - offsetX);
|
||||
double screenY = (mouseY / scale - offsetY);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
Minecraft.getMinecraft().getTextureManager().bindTexture(TEXTURE);
|
||||
GuiUtil.drawTexturedModalRect(screenX, screenY, width, height, textureX, textureY);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public static Cursors currentCursor;
|
||||
|
||||
public static void setCursor(Cursors cursor) {
|
||||
try {
|
||||
Cursor c = null;
|
||||
if (cursor != null)
|
||||
c = new Cursor(1, 1, 0, 0, 1, BufferUtils.createIntBuffer(1), null);
|
||||
Mouse.setNativeCursor(c);
|
||||
} catch (LWJGLException e) {
|
||||
}
|
||||
currentCursor = cursor;
|
||||
}
|
||||
|
||||
public static void reset() {
|
||||
setCursor(null);
|
||||
}
|
||||
|
||||
private static ResourceLocation TEXTURE = new ResourceLocation("customnpcs:textures/gui/cursors.png");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,388 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import net.minecraft.client.gui.Gui;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.keys.GraphEditorKeyPresets;
|
||||
import noppes.npcs.client.gui.util.animation.keys.KeyPreset;
|
||||
import noppes.npcs.util.ValueUtil;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import static org.lwjgl.opengl.GL11.*;
|
||||
|
||||
public class Grid {
|
||||
ViewportGraphEditor parent;
|
||||
public int startX, startY; // Positioning
|
||||
public int endX, endY; // Positioning
|
||||
public int yAxisHeight = 12;
|
||||
|
||||
public int mouseX, mouseY;
|
||||
|
||||
public float zoomX = 20f, targetZoomX = 20f, zoomY = 1f, targetZoomY = 1f; //Zoom smoothness
|
||||
public float panX = 0, panY = 0, targetPanX, targetPanY; // pan offsets
|
||||
public int startPanX, startPanY;
|
||||
public boolean smoothenPanX, smoothenPanY;
|
||||
public int subDivisionX = 1, subDivisionY = 2;
|
||||
|
||||
public boolean isDragging, isResetting;
|
||||
public boolean centerAroundMouse = true;
|
||||
|
||||
public GridPointManager manager;
|
||||
|
||||
public Grid(ViewportGraphEditor parent) {
|
||||
this.parent = parent;
|
||||
manager = new GridPointManager(this);
|
||||
keys();
|
||||
}
|
||||
|
||||
public void keys() {
|
||||
GraphEditorKeyPresets keys = parent.keys;
|
||||
|
||||
keys.RESET_GRID.setTask((pressType) -> {
|
||||
if (pressType == KeyPreset.PRESS) {
|
||||
if (!isResetting) {
|
||||
if (xDown()) {
|
||||
targetPanX = 0;
|
||||
targetZoomX = 20;
|
||||
smoothenPanX = true;
|
||||
} else if (yDown()) {
|
||||
targetPanY = -((parent.height) * subDivisionY / 2);
|
||||
targetZoomY = 1.0f;
|
||||
smoothenPanY = true;
|
||||
} else {
|
||||
targetPanY = -((parent.height) * subDivisionY / 2);
|
||||
targetPanX = 0;
|
||||
targetZoomX = 20;
|
||||
targetZoomY = 1.0f;
|
||||
smoothenPanX = smoothenPanY = true;
|
||||
}
|
||||
isResetting = true;
|
||||
centerAroundMouse = false;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
keys.PAN_GRID.setTask((pressType) -> {
|
||||
if (pressType == KeyPreset.PRESS) {
|
||||
isDragging = true;
|
||||
startPanX = mouseX;
|
||||
startPanY = mouseY;
|
||||
} else if (pressType == KeyPreset.RELEASE)
|
||||
isDragging = false;
|
||||
});
|
||||
}
|
||||
|
||||
public void init(int startX, int startY, int endX, int endY) {
|
||||
this.startX = startX;
|
||||
this.startY = startY;
|
||||
this.endX = endX;
|
||||
this.endY = endY;
|
||||
|
||||
panY = -(parent.height * subDivisionY / 2);
|
||||
}
|
||||
|
||||
public void draw(int mouseX, int mouseY, float partialTicks, int wheel) {
|
||||
this.mouseX = mouseX;
|
||||
this.mouseY = mouseY;
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Panning
|
||||
|
||||
if (isDragging && parent.isWithin(mouseX, mouseY) && !isResetting) {
|
||||
if (xDown())
|
||||
panX -= (mouseX - startPanX) / zoomX;
|
||||
else if (yDown())
|
||||
panY -= (mouseY - startPanY) / zoomY;
|
||||
else {
|
||||
panX -= (mouseX - startPanX) / zoomX;
|
||||
panY -= (mouseY - startPanY) / zoomY * subDivisionY;
|
||||
}
|
||||
startPanX = mouseX;
|
||||
startPanY = mouseY;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Zoom logic
|
||||
if (wheel != 0 && !parent.presetOverlay.showOverlay) {
|
||||
float xRate = zoomX < 15 ? 1.1f : 1.25f;
|
||||
float yRate = zoomY < 15 ? 1.1f : 1.25f;
|
||||
|
||||
if (xDown())
|
||||
targetZoomX = ValueUtil.clamp(wheel > 0 ? targetZoomX * xRate : targetZoomX / xRate, 0.025f, 100);
|
||||
else if (yDown())
|
||||
targetZoomY = ValueUtil.clamp(wheel > 0 ? targetZoomY * yRate : targetZoomY / yRate, 0.025f, 100);
|
||||
else {
|
||||
targetZoomX = ValueUtil.clamp(wheel > 0 ? targetZoomX * xRate : targetZoomX / xRate, 0.025f, 100);
|
||||
targetZoomY = ValueUtil.clamp(wheel > 0 ? targetZoomY * yRate : targetZoomY / yRate, 0.025f, 100);
|
||||
}
|
||||
}
|
||||
|
||||
if (zoomX != targetZoomX || zoomY != targetZoomY)
|
||||
zoom(mouseX, mouseY, wheel);
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////
|
||||
// Reset logic
|
||||
if (isResetting) {
|
||||
if (zoomX == targetZoomX && zoomY == targetZoomY && (smoothenPanX ? panX == targetPanX : smoothenPanY ? panY == targetPanY : true)) {
|
||||
isResetting = smoothenPanX = smoothenPanY = false;
|
||||
centerAroundMouse = true;
|
||||
}
|
||||
|
||||
float rate = 0.1f;
|
||||
if (smoothenPanX && panX != targetPanX) {
|
||||
panX = ValueUtil.lerp(panX, targetPanX, rate);
|
||||
if (Math.abs(panX - targetPanX) < 0.1)
|
||||
panX = targetPanX;
|
||||
}
|
||||
|
||||
if (smoothenPanY && panY != targetPanY) {
|
||||
panY = ValueUtil.lerp(panY, targetPanY, rate);
|
||||
if (Math.abs(panY - targetPanY) < 0.1)
|
||||
panY = targetPanY;
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////
|
||||
Gui.drawRect(startX, startY - yAxisHeight, endX, startY, 0xFF161616); //background
|
||||
GL11.glEnable(GL11.GL_SCISSOR_TEST);
|
||||
GuiUtil.setScissorClip(startX, startY, parent.width, parent.height);
|
||||
|
||||
GL11.glDepthMask(false);
|
||||
drawLines(mouseX, mouseY);
|
||||
GL11.glDepthMask(true);
|
||||
|
||||
manager.draw(mouseX, mouseY, partialTicks);
|
||||
GL11.glDisable(GL11.GL_SCISSOR_TEST);
|
||||
}
|
||||
|
||||
public void zoom(int mouseX, int mouseY, int wheel) {
|
||||
///////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////
|
||||
//Zooms in on mouse point
|
||||
double beforeWorldX = worldX(mouseX - startX);
|
||||
double beforeWorldY = worldY(mouseY - startY);
|
||||
|
||||
float rate = isResetting ? 0.1f : 0.05f;
|
||||
zoomX = ValueUtil.lerp(zoomX, targetZoomX, rate);
|
||||
zoomY = ValueUtil.lerp(zoomY, targetZoomY, rate);
|
||||
|
||||
// Snap to exact target value
|
||||
if (Math.abs(zoomX - targetZoomX) < 0.001)
|
||||
zoomX = targetZoomX;
|
||||
if (Math.abs(zoomY - targetZoomY) < 0.001)
|
||||
zoomY = targetZoomY;
|
||||
|
||||
double afterWorldX = worldX(mouseX - startX);
|
||||
double afterWorldY = worldY(mouseY - startY);
|
||||
|
||||
if (centerAroundMouse) {
|
||||
if (xDown())
|
||||
panX += beforeWorldX - afterWorldX;
|
||||
else if (yDown())
|
||||
panY += beforeWorldY - afterWorldY;
|
||||
else {
|
||||
panX += beforeWorldX - afterWorldX;
|
||||
panY += beforeWorldY - afterWorldY;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void drawLines(int mouseX, int mouseY) {
|
||||
int darkGray = 0xFF1a1a1a; // Major grid
|
||||
int lightGray = 0xFF2a2a2a; // Minor grid
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Vertical
|
||||
double stepX = getStepX();
|
||||
double firstGridX = Math.floor((panX) / stepX) * stepX;
|
||||
for (double x = firstGridX, i = 0; x <= worldX(endX); x += stepX / 5, i++) {
|
||||
boolean isMajor = i % 5 == 0;
|
||||
double screenX = screenX(x);
|
||||
|
||||
glPushMatrix();
|
||||
glTranslatef(startX, 0, 0);
|
||||
GuiUtil.drawVerticalLine(screenX, startY, endY, isMajor ? darkGray : lightGray);
|
||||
glPopMatrix();
|
||||
}
|
||||
|
||||
//Expand boundaries of scissor clip
|
||||
GuiUtil.setScissorClip(startX, startY - yAxisHeight, parent.width, parent.height + yAxisHeight);
|
||||
for (double x = firstGridX; x <= worldX(endX); x += stepX)
|
||||
drawXValue((int) screenX(x), (int) x);
|
||||
|
||||
//Reset clip
|
||||
GuiUtil.setScissorClip(startX, startY, parent.width, parent.height);
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Horizontal
|
||||
double stepY = getStepY();
|
||||
double firstGridY = Math.floor((panY) / stepY) * stepY;
|
||||
for (double y = firstGridY, i = 0; y <= worldY(endY); y += stepY / 5, i++) {
|
||||
boolean isMajor = i % 5 == 0;
|
||||
double screenY = screenY(y);
|
||||
|
||||
glPushMatrix();
|
||||
glTranslatef(0, startY, 0);
|
||||
GuiUtil.drawHorizontalLine(screenY, startX, endX, isMajor ? darkGray : lightGray);
|
||||
glPopMatrix();
|
||||
}
|
||||
|
||||
for (double y = firstGridY; y <= worldY(endY); y += stepY)
|
||||
drawYValue((int) screenY(y), (int) -y);
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
}
|
||||
|
||||
public double getStepX() {
|
||||
double stepSize = 0;
|
||||
if (zoomX < 0.1) // 0-1000
|
||||
stepSize = 1000;
|
||||
else if (zoomX < 0.2) // 0-500
|
||||
stepSize = 500;
|
||||
else if (zoomX < 0.5) // 0-200
|
||||
stepSize = 200;
|
||||
else if (zoomX <= 1) // 0-100
|
||||
stepSize = 100;
|
||||
else if (zoomX < 1.5) //0-50
|
||||
stepSize = 50;
|
||||
else if (zoomX < 3) //0-20
|
||||
stepSize = 20;
|
||||
else if (zoomX < 4.5) //0-10
|
||||
stepSize = 10;
|
||||
else if (zoomX < 10) //0-5
|
||||
stepSize = 5;
|
||||
else if (zoomX < 18) //0-2 For Default reset
|
||||
stepSize = 2;
|
||||
else if (zoomX <= 100) //0-1
|
||||
stepSize = 1;
|
||||
return stepSize;
|
||||
}
|
||||
|
||||
public double getStepY() {
|
||||
double stepSize = 0;
|
||||
if (zoomY < 0.1) // 0-1000
|
||||
stepSize = 1000;
|
||||
else if (zoomY < 0.2) // 0-500
|
||||
stepSize = 500;
|
||||
else if (zoomY < 0.5) // 0-200
|
||||
stepSize = 200;
|
||||
else if (zoomY < 0.9) // 0-100 For Default reset
|
||||
stepSize = 100;
|
||||
else if (zoomY < 1.5) //0-50
|
||||
stepSize = 50;
|
||||
else if (zoomY < 3) //0-20
|
||||
stepSize = 20;
|
||||
else if (zoomY < 4.5) //0-10
|
||||
stepSize = 10;
|
||||
else if (zoomY < 10) //0-5
|
||||
stepSize = 5;
|
||||
else if (zoomY < 20) //0-2
|
||||
stepSize = 2;
|
||||
else if (zoomY <= 100) //0-1
|
||||
stepSize = 1;
|
||||
return stepSize;
|
||||
}
|
||||
|
||||
public void drawXValue(int screenX, int value) {
|
||||
GL11.glPushMatrix();
|
||||
float scale = 0.75f;
|
||||
int adjustedX = (int) ((screenX + 1) / scale); // Offset to the left of grid line
|
||||
int adjustedY = (int) ((startY - yAxisHeight + 4) / scale); // Adjust Y position
|
||||
|
||||
GL11.glTranslatef(startX, 0, 1f);
|
||||
GL11.glScalef(scale, scale, 1f);
|
||||
parent.drawString(String.valueOf(value), adjustedX, adjustedY, 0xFFA0A0A0);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public void drawYValue(int screenY, int value) {
|
||||
GL11.glPushMatrix();
|
||||
float scale = 0.5f;
|
||||
int adjustedX = (int) ((startX + 10) / scale); // Offset to the left of grid line
|
||||
int adjustedY = (int) ((screenY - 1) / scale); // Adjust Y position
|
||||
|
||||
GL11.glTranslatef(0, startY, 1f);
|
||||
GL11.glScalef(scale, scale, 1f);
|
||||
parent.drawString(String.valueOf(value), adjustedX, adjustedY, 0xFFFFFF);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
manager.mouseClicked(mouseX, mouseY, button);
|
||||
|
||||
}
|
||||
|
||||
public void keyTyped(char c, int i) {
|
||||
manager.keyTyped(c, i);
|
||||
}
|
||||
|
||||
public boolean xDown() {
|
||||
return manager.keys.LOCK_X.isDown;
|
||||
}
|
||||
|
||||
public boolean yDown() {
|
||||
return manager.keys.LOCK_Y.isDown;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Double
|
||||
public double worldX(double screenX) {
|
||||
return screenX * subDivisionX / zoomX + panX;
|
||||
}
|
||||
|
||||
public double worldY(double screenY) {
|
||||
return screenY * subDivisionY / zoomY + panY;
|
||||
}
|
||||
|
||||
public double screenX(double worldX) {
|
||||
return (worldX - panX) * zoomX / subDivisionX;
|
||||
}
|
||||
|
||||
public double screenY(double worldY) {
|
||||
return (worldY - panY) * zoomY / subDivisionY;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Float
|
||||
public double worldX(float screenX) {
|
||||
return screenX * subDivisionX / zoomX + panX;
|
||||
}
|
||||
|
||||
public double worldY(float screenY) {
|
||||
return screenY * subDivisionY / zoomY + panY;
|
||||
}
|
||||
|
||||
public double screenX(float worldX) {
|
||||
return (worldX - panX) * zoomX / subDivisionX;
|
||||
}
|
||||
|
||||
public double screenY(float worldY) {
|
||||
return (worldY - panY) * zoomY / subDivisionY;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Int
|
||||
public double worldX(int screenX) {
|
||||
return screenX * subDivisionX / zoomX + panX;
|
||||
}
|
||||
|
||||
public double worldY(int screenY) {
|
||||
return screenY * subDivisionY / zoomY + panY;
|
||||
}
|
||||
|
||||
public double screenX(int worldX) {
|
||||
return (worldX - panX) * zoomX / subDivisionX;
|
||||
}
|
||||
|
||||
public double screenY(int worldY) {
|
||||
return (worldY - panY) * zoomY / subDivisionY;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,464 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.keys.GraphEditorKeyPresets;
|
||||
import noppes.npcs.client.gui.util.animation.keys.KeyPreset;
|
||||
import noppes.npcs.client.utils.Color;
|
||||
import noppes.npcs.constants.animation.EnumFrameType;
|
||||
import noppes.npcs.util.Ease;
|
||||
import noppes.npcs.util.ValueUtil;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.function.BiConsumer;
|
||||
|
||||
public class GridPointManager {
|
||||
public Grid grid;
|
||||
public GraphEditorKeyPresets keys;
|
||||
public HashMap<EnumFrameType, TreeMap<Double, Point>> typePoints = new HashMap<>();
|
||||
public List<EnumFrameType> highlightedTypes = new ArrayList<>();
|
||||
public List<Point> highlightedPoints = new ArrayList<>();
|
||||
public Point selectedPoint;
|
||||
public Playhead playhead = new Playhead(0);
|
||||
|
||||
public boolean isFreeTransforming;
|
||||
public double ftGrabX, ftGrabY; //where point is grabbed on free transforming
|
||||
|
||||
public GridPointManager(Grid grid) {
|
||||
this.grid = grid;
|
||||
keys = grid.parent.keys;
|
||||
keys();
|
||||
}
|
||||
|
||||
public void keys() {
|
||||
EnumFrameType type = EnumFrameType.ROTATION_X;
|
||||
|
||||
keys.SELECT_POINT.setTask((pressType) -> {
|
||||
if (pressType == KeyPreset.PRESS) {
|
||||
forEachActive((pointType, point) -> {
|
||||
if (point.isMouseAbove(grid.mouseX, grid.mouseY))
|
||||
setSelectedPoint(point);
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
keys.ADD_POINT.setTask((pressType) -> {
|
||||
if (pressType == KeyPreset.PRESS) {
|
||||
if (!highlightedTypes.contains(type))
|
||||
highlightedTypes.add(type);
|
||||
|
||||
TreeMap<Double, Point> points = pointsOf(type);
|
||||
Point point = points != null ? points.get((double) playhead.worldX) : null; //check if it exists
|
||||
if (point == null)
|
||||
point = addPoint(type, playhead.worldX, 0); // worldX(mouseX - startX), worldY(mouseY - startY)
|
||||
|
||||
setSelectedPoint(point);
|
||||
}
|
||||
});
|
||||
|
||||
keys.DELETE_POINT.setTask((pressType) -> {
|
||||
if ((pressType == KeyPreset.PRESS) && selectedPoint != null && !grid.isDragging) {
|
||||
deletePoint(type, selectedPoint.worldX);
|
||||
}
|
||||
});
|
||||
|
||||
keys.FREE_TRANSFORM.setTask((pressType) -> {
|
||||
if (pressType == KeyPreset.PRESS && selectedPoint != null) {
|
||||
if (isFreeTransforming) {
|
||||
selectedPoint.set(ftGrabX, ftGrabY);
|
||||
ftGrabX = ftGrabY = 0;
|
||||
Cursors.reset();
|
||||
} else {
|
||||
ftGrabX = selectedPoint.worldX;
|
||||
ftGrabY = selectedPoint.worldY;
|
||||
Cursors.setCursor(Cursors.MOVE);
|
||||
}
|
||||
|
||||
isFreeTransforming = !isFreeTransforming;
|
||||
}
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
if (button == 0 && selectedPoint != null && !isFreeTransforming) {
|
||||
if (grid.parent.isWithin(mouseX, mouseY) && !selectedPoint.isMouseAbove(mouseX, mouseY))
|
||||
setSelectedPoint(null);
|
||||
}
|
||||
|
||||
if (button == 0 && isFreeTransforming) {
|
||||
selectedPoint.updateKey();
|
||||
Cursors.reset();
|
||||
isFreeTransforming = false;
|
||||
}
|
||||
|
||||
playhead.mouseClicked(mouseX, mouseY, button);
|
||||
forEachActive((type, point) -> {
|
||||
point.mouseClicked(mouseX, mouseY, button);
|
||||
});
|
||||
}
|
||||
|
||||
public Point addPoint(EnumFrameType type, double x, double y) {
|
||||
return addPoint(type, new Point(type, x, y));
|
||||
}
|
||||
|
||||
public Point addPoint(EnumFrameType type, Point point) {
|
||||
TreeMap<Double, Point> points = pointsOf(type);
|
||||
if (points == null) {
|
||||
points = new TreeMap<>();
|
||||
typePoints.put(type, points);
|
||||
}
|
||||
|
||||
points.put(point.worldX, point);
|
||||
return point;
|
||||
}
|
||||
|
||||
public void deletePoint(EnumFrameType type, double x) {
|
||||
TreeMap<Double, Point> points = pointsOf(type);
|
||||
if (points == null)
|
||||
return;
|
||||
|
||||
Point point = points.remove(x);
|
||||
if (point == selectedPoint)
|
||||
setSelectedPoint(null);
|
||||
}
|
||||
|
||||
public Point getPoint(EnumFrameType type, double x) {
|
||||
TreeMap<Double, Point> points = pointsOf(type);
|
||||
if (points == null)
|
||||
return null;
|
||||
|
||||
return points.get(x);
|
||||
}
|
||||
|
||||
public TreeMap<Double, Point> pointsOf(EnumFrameType type) {
|
||||
return typePoints.get(type);
|
||||
}
|
||||
|
||||
public void forEachActive(BiConsumer<EnumFrameType, Point> consumer) {
|
||||
for (Map.Entry<EnumFrameType, TreeMap<Double, Point>> entry : typePoints.entrySet()) {
|
||||
EnumFrameType type = entry.getKey();
|
||||
|
||||
if (!highlightedTypes.contains(type))
|
||||
continue;
|
||||
|
||||
for (Map.Entry<Double, Point> points : entry.getValue().entrySet()) {
|
||||
Point point = points.getValue();
|
||||
consumer.accept(type, point);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void setSelectedPoint(Point point) {
|
||||
if (selectedPoint != null)
|
||||
selectedPoint.highlighted = false;
|
||||
|
||||
this.selectedPoint = point;
|
||||
|
||||
if (point != null)
|
||||
point.highlighted = true;
|
||||
}
|
||||
|
||||
public Point getNext(Point point) {
|
||||
TreeMap<Double, Point> points = pointsOf(point.type);
|
||||
if (points == null)
|
||||
return null;
|
||||
|
||||
Map.Entry<Double, Point> entry = points.higherEntry(point.worldX);
|
||||
if (entry != null)
|
||||
return entry.getValue();
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public void drawEasedCurve(Point from, Point to) {
|
||||
if (from == null || to == null)
|
||||
return;
|
||||
|
||||
GL11.glDisable(GL11.GL_TEXTURE_2D);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL11.glEnable(GL11.GL_LINE_SMOOTH);
|
||||
GL11.glHint(GL11.GL_LINE_SMOOTH_HINT, GL11.GL_NICEST);
|
||||
GL11.glLineWidth(2F);
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(grid.startX, grid.startY, 0);
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
|
||||
Tessellator tessellator = Tessellator.instance;
|
||||
tessellator.startDrawing(GL11.GL_LINE_STRIP);
|
||||
|
||||
|
||||
for (float t = 0; t <= 1; t += 0.01) {
|
||||
float easedT = Ease.INOUTQUINT.apply(t);
|
||||
double xt = ValueUtil.lerp(from.screenX() + 0.5, to.screenX() + 0.5, t);
|
||||
double yt = ValueUtil.lerp(from.screenY() + 0.5, to.screenY() + 0.5, easedT);
|
||||
|
||||
tessellator.addVertex(xt, yt, 0);
|
||||
}
|
||||
|
||||
tessellator.draw();
|
||||
GL11.glPopMatrix();
|
||||
|
||||
GL11.glLineWidth(1F);
|
||||
GL11.glDisable(GL11.GL_LINE_SMOOTH);
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
GL11.glEnable(GL11.GL_TEXTURE_2D);
|
||||
}
|
||||
|
||||
public void draw(int mouseX, int mouseY, float partialTicks) {
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// Free transform logic
|
||||
if (isFreeTransforming && selectedPoint != null) {
|
||||
if (grid.xDown())
|
||||
selectedPoint.setX(Math.round(grid.worldX(GuiUtil.preciseMouseX() - grid.startX)));
|
||||
else if (grid.yDown())
|
||||
selectedPoint.setY(grid.worldY(GuiUtil.preciseMouseY() - grid.startY));
|
||||
else
|
||||
selectedPoint.set(Math.round(grid.worldX(GuiUtil.preciseMouseX() - grid.startX)), grid.worldY(GuiUtil.preciseMouseY() - grid.startY));
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
playhead.draw(mouseX, mouseY, partialTicks);
|
||||
|
||||
forEachActive((type, point) -> {
|
||||
drawEasedCurve(point, getNext(point));
|
||||
point.draw(mouseX, mouseY, partialTicks);
|
||||
});
|
||||
|
||||
if (Cursors.currentCursor != null)
|
||||
Cursors.currentCursor.draw(mouseX, mouseY);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// Pans grid while free transforming
|
||||
// MUST BE DONE AT THE VERY END -> CHANGES CURSOR POSITION WITHOUT
|
||||
// CHANGING GuiScreen.drawScreen(mouseX,mouseY) VALUES
|
||||
if (isFreeTransforming) {
|
||||
if (mouseX < grid.startX) {
|
||||
int deltaX = mouseX - grid.startX;
|
||||
grid.panX += deltaX / grid.zoomX;
|
||||
GuiUtil.setMouseX(grid.startX - 1);
|
||||
}
|
||||
if (mouseX > grid.endX) {
|
||||
int deltaX = mouseX - grid.endX;
|
||||
grid.panX += (deltaX / grid.zoomX);
|
||||
GuiUtil.setMouseX(grid.endX + 1);
|
||||
}
|
||||
if (mouseY < grid.startY) {
|
||||
int deltaY = mouseY - grid.startY;
|
||||
grid.panY += deltaY / grid.zoomY;
|
||||
GuiUtil.setMouseY(grid.startY);
|
||||
}
|
||||
if (mouseY > grid.endY) {
|
||||
int deltaY = mouseY - grid.endY;
|
||||
grid.panY += deltaY / grid.zoomY;
|
||||
GuiUtil.setMouseY(grid.endY + 2);
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
}
|
||||
|
||||
public void keyTyped(char c, int key) {
|
||||
}
|
||||
|
||||
private static ResourceLocation TEXTURE = new ResourceLocation("customnpcs:textures/gui/animation.png");
|
||||
|
||||
public class Point {
|
||||
public EnumFrameType type;
|
||||
public double worldX, worldY;
|
||||
public boolean highlighted;
|
||||
|
||||
public double previousX;
|
||||
|
||||
public Point(EnumFrameType type, double worldX, double worldY) {
|
||||
this.type = type;
|
||||
this.worldX = previousX = worldX;
|
||||
this.worldY = worldY;
|
||||
}
|
||||
|
||||
public void setX(double x) {
|
||||
worldX = (int) x;
|
||||
}
|
||||
|
||||
public void setY(double y) {
|
||||
worldY = y;
|
||||
}
|
||||
|
||||
public void set(double x, double y) {
|
||||
setX(x);
|
||||
setY(y);
|
||||
}
|
||||
|
||||
public void updateKey() {
|
||||
TreeMap<Double, Point> points = pointsOf(type);
|
||||
if (points == null)
|
||||
return;
|
||||
|
||||
points.remove(previousX);
|
||||
points.put(worldX, this);
|
||||
previousX = worldX;
|
||||
}
|
||||
|
||||
public void draw(int mouseX, int mouseY, float partialTicks) {
|
||||
float scale = 0.1f;
|
||||
int textureWidth = 32, textureHeight = 32;
|
||||
float offsetX = (textureHeight / 2) * scale - 0.5f, offsetY = (textureHeight / 2) * scale - 0.5f;
|
||||
double screenX = screenX() / scale, screenY = screenY() / scale;
|
||||
|
||||
grid.parent.mc.getTextureManager().bindTexture(TEXTURE);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
new Color(highlighted ? 0xffbe33 : 0xbfbfbf, 1).glColor();
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(grid.startX - offsetX, grid.startY - offsetY, 0);
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
GuiUtil.drawTexturedModalRect(screenX, screenY, textureWidth, textureHeight, 256 - textureWidth, 256 - textureHeight);
|
||||
|
||||
GL11.glPopMatrix();
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
}
|
||||
|
||||
public boolean isMouseAbove(int mouseX, int mouseY) {
|
||||
int rMX = mouseX - grid.startX, rMY = mouseY - grid.startY; //relative to grid
|
||||
float scale = 0.1f;
|
||||
float textureWidth = (32), textureHeight = (32);
|
||||
float offsetX = (textureWidth / 2) * scale - 0.5f, offsetY = (textureHeight / 2) * scale - 0.5f;
|
||||
|
||||
int screenX = (int) (screenX() - offsetX);
|
||||
int screenY = (int) ((screenY()) - offsetY);
|
||||
|
||||
return rMX >= screenX && rMX < screenX + textureWidth * scale && rMY >= screenY && rMY < screenY + textureHeight * scale;
|
||||
}
|
||||
|
||||
public double screenX() {
|
||||
|
||||
return grid.screenX(worldX);
|
||||
}
|
||||
|
||||
public double screenY() {
|
||||
return grid.screenY(worldY);
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
}
|
||||
}
|
||||
|
||||
public class Playhead {
|
||||
public int worldX;
|
||||
public boolean isDragging;
|
||||
|
||||
public Playhead(int currentX) {
|
||||
this.worldX = currentX;
|
||||
}
|
||||
|
||||
public void draw(int mouseX, int mouseY, float partialTicks) {
|
||||
// Dragging
|
||||
if (isDragging && !Mouse.isButtonDown(0))
|
||||
isDragging = false;
|
||||
|
||||
if (isDragging)
|
||||
worldX = (int) Math.round(grid.worldX(GuiUtil.preciseMouseX() - grid.startX));
|
||||
|
||||
//Expand clip boundary
|
||||
GuiUtil.setScissorClip(grid.startX, grid.startY - grid.yAxisHeight, grid.parent.width, grid.parent.height + grid.yAxisHeight);
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Head lines
|
||||
double screenX = screenX();
|
||||
float height = grid.endY - grid.startY;
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslated(grid.startX + screenX, grid.startY, 0);
|
||||
GL11.glDepthMask(false);
|
||||
GuiUtil.drawVerticalLine(-1, 0, height, 0xFF212121);
|
||||
GuiUtil.drawVerticalLine(0, -5, height, 0xFF4772b3);
|
||||
GuiUtil.drawVerticalLine(1, 0, height, 0xFF212121);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Head texture
|
||||
FontRenderer fontRenderer = grid.parent.getFontRenderer();
|
||||
float textureScaleX = 0.5f, textureScaleY = 0.5f;
|
||||
|
||||
// Texture width dynamically scales with string width
|
||||
int defaultWidth = 6, width = fontRenderer.getStringWidth(worldX + "");
|
||||
if (width / defaultWidth > 1)
|
||||
textureScaleX += width / defaultWidth * 0.125;
|
||||
|
||||
int textureWidth = 25, textureHeight = 17;
|
||||
float offset = (textureWidth / 2) * textureScaleX;
|
||||
float screenY = grid.startY - grid.yAxisHeight;
|
||||
|
||||
grid.parent.mc.getTextureManager().bindTexture(TEXTURE);
|
||||
GL11.glEnable(GL11.GL_BLEND);
|
||||
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
|
||||
new Color(0x426dae, 1).glColor();
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(grid.startX, 0, 0);
|
||||
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(-offset, 0, 0);
|
||||
GL11.glScalef(textureScaleX, textureScaleY, 1);
|
||||
|
||||
GuiUtil.drawTexturedModalRect(screenX / textureScaleX, (screenY + 2) / textureScaleY, textureWidth, textureHeight, 228, 199);
|
||||
|
||||
GL11.glPopMatrix();
|
||||
GL11.glDisable(GL11.GL_BLEND);
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
// Head value
|
||||
float vScale = 0.75f;
|
||||
double valueScreenX = (screenX + 1) / vScale;
|
||||
double valueScreenY = (screenY + 4) / vScale;
|
||||
GL11.glScalef(vScale, vScale, 1);
|
||||
grid.parent.drawString(String.valueOf(worldX), (int) valueScreenX, (int) valueScreenY, 0xFFccd7e9);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////
|
||||
//Reset clip
|
||||
GuiUtil.setScissorClip(grid.startX, grid.startY, grid.parent.width, grid.parent.height);
|
||||
}
|
||||
|
||||
public boolean isMouseAbove(int mouseX, int mouseY) {
|
||||
int rMX = mouseX - grid.startX, rMY = mouseY - grid.startY; //relative to grid
|
||||
float scale = 0.5f;
|
||||
float textureWidth = (25 * scale), textureHeight = (17 * scale);
|
||||
float offsetX = (textureWidth / 2) * scale;
|
||||
|
||||
int screenX = (int) Math.round(screenX() - (offsetX / scale));
|
||||
int screenY = -grid.yAxisHeight + 2;
|
||||
|
||||
return rMX >= screenX && rMX <= screenX + textureWidth && rMY >= screenY && rMY < screenY + textureHeight;
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
|
||||
if (button == 0 && mouseX >= grid.startX && mouseX <= grid.endX && mouseY >= grid.startY - grid.yAxisHeight && mouseY <= grid.startY) {
|
||||
worldX = (int) Math.round(grid.worldX(GuiUtil.preciseMouseX() - grid.startX));
|
||||
isDragging = true;
|
||||
}
|
||||
}
|
||||
|
||||
public double screenX() {
|
||||
return grid.screenX(worldX);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,419 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.keys.KeyPreset;
|
||||
import noppes.npcs.client.gui.util.animation.keys.KeyPresetManager;
|
||||
import noppes.npcs.client.utils.Color;
|
||||
import noppes.npcs.util.ValueUtil;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
|
||||
public class OverlayKeyPresetViewer {
|
||||
private static final ResourceLocation TEXTURE = new ResourceLocation("customnpcs:textures/gui/keypreset_highres.png");
|
||||
|
||||
public int startX, startY, endX, endY, width, height;
|
||||
public int mouseX, mouseY;
|
||||
public boolean showOverlay;
|
||||
|
||||
public int elementSpacing = 5, yStartSpacing = 5;
|
||||
public float scale = 0.75f;
|
||||
public Scrollable scroll = new Scrollable();
|
||||
|
||||
public KeyPresetManager manager;
|
||||
public OverlayButton viewButton = new OverlayButton();
|
||||
public LinkedList<PresetElement> list = new LinkedList<>();
|
||||
|
||||
private final FontRenderer font = Minecraft.getMinecraft().fontRenderer;
|
||||
|
||||
public OverlayKeyPresetViewer(KeyPresetManager manager) {
|
||||
this.manager = manager;
|
||||
|
||||
manager.keys.forEach((key) -> {
|
||||
PresetElement element = new PresetElement(key);
|
||||
list.add(element);
|
||||
});
|
||||
}
|
||||
|
||||
public void initGui(int startX, int startY, int endX, int endY) {
|
||||
this.startX = startX;
|
||||
this.startY = startY;
|
||||
this.endX = endX;
|
||||
this.endY = endY;
|
||||
this.width = endX - startX;
|
||||
this.height = endY - startY;
|
||||
scroll.init();
|
||||
}
|
||||
|
||||
public void draw(int mouseX, int mouseY, int wheel) {
|
||||
this.mouseX = mouseX;
|
||||
this.mouseY = mouseY;
|
||||
boolean aboveButton = viewButton.isMouseAbove(mouseX, mouseY);
|
||||
boolean aboveOverlay = isMouseAbove(mouseX, mouseY);
|
||||
|
||||
if (aboveButton)
|
||||
showOverlay = true;
|
||||
|
||||
if (showOverlay) {
|
||||
drawOverlay(wheel);
|
||||
|
||||
if (!aboveOverlay && !aboveButton)
|
||||
showOverlay = false;
|
||||
}
|
||||
|
||||
viewButton.drawButton();
|
||||
}
|
||||
|
||||
public void drawOverlay(int wheel) {
|
||||
scroll.update(wheel);
|
||||
|
||||
GL11.glEnable(GL11.GL_SCISSOR_TEST);
|
||||
GuiUtil.drawGradientRect(startX, startY, endX, endY, 0x88000000, 0x88303030);
|
||||
if (scroll.maxScroll > 0)
|
||||
scroll.drawBar();
|
||||
|
||||
GuiUtil.setScissorClip(startX, startY, scroll.maxScroll > 0 ? width - scroll.barWidth : width, height);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef((startX + 2), startY + yStartSpacing - scroll.scrollY, 0);
|
||||
|
||||
for (int i = 0, height = 0; i < list.size(); i++) {
|
||||
PresetElement element = list.get(i);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
GL11.glTranslatef(0, Math.round(height / scale), 0);
|
||||
element.drawDescription();
|
||||
GL11.glPopMatrix();
|
||||
|
||||
element.drawBox(height);
|
||||
height += element.getHeight();
|
||||
}
|
||||
|
||||
GL11.glPopMatrix();
|
||||
GL11.glDisable(GL11.GL_SCISSOR_TEST);
|
||||
}
|
||||
|
||||
public void keyTyped(char c, int i) {
|
||||
if (!showOverlay)
|
||||
return;
|
||||
|
||||
list.forEach((element) -> {
|
||||
if (element.isEditing)
|
||||
element.keyTyped(i);
|
||||
});
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
if (!showOverlay)
|
||||
return;
|
||||
|
||||
list.forEach((element) -> {
|
||||
if (!element.isMouseAboveBox(mouseX, mouseY)) {
|
||||
if (element.isEditing)
|
||||
element.cancelEdit();
|
||||
} else
|
||||
element.boxClicked(button);
|
||||
|
||||
if (element.isMouseAboveReset(mouseX, mouseY) && !element.key.isDefault()) {
|
||||
element.key.defaultState.writeTo(element.key.currentState);
|
||||
manager.save();
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
public boolean isMouseAbove(int mouseX, int mouseY) {
|
||||
if (scroll.isMouseDragging)
|
||||
return true;
|
||||
|
||||
return mouseX >= startX && mouseX < endX && mouseY >= startY && mouseY < endY;
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
return (int) (width / scale);
|
||||
}
|
||||
|
||||
public class Scrollable {
|
||||
private float scrollY, targetScrollY, maxScroll;
|
||||
private int totalHeight, scrollbarHeight, barWidth = 2;
|
||||
private float heightFactor, scrollFactor;
|
||||
|
||||
private boolean isMouseDragging;
|
||||
private int startDragY;
|
||||
|
||||
public Scrollable() {
|
||||
}
|
||||
|
||||
public void init() {
|
||||
totalHeight = 0;
|
||||
for (PresetElement element : list)
|
||||
totalHeight += element.getHeight();
|
||||
|
||||
totalHeight -= yStartSpacing;
|
||||
heightFactor = height / totalHeight;
|
||||
scrollbarHeight = Math.max((int) (height * heightFactor), 20);
|
||||
scrollFactor = (height - yStartSpacing - scrollbarHeight) / maxScroll;
|
||||
|
||||
scroll.maxScroll = Math.max(0, totalHeight - height);
|
||||
}
|
||||
|
||||
public void update(int wheel) {
|
||||
if (wheel != 0 && isMouseAbove(mouseX, mouseY))
|
||||
targetScrollY = ValueUtil.clamp(targetScrollY - wheel / 15, 0, maxScroll);
|
||||
|
||||
|
||||
if (Mouse.isButtonDown(0)) {
|
||||
if (!isMouseDragging && isMouseAboveBar(mouseX, mouseY)) {
|
||||
isMouseDragging = true;
|
||||
startDragY = (int) (mouseY - scrollY * scrollFactor);
|
||||
}
|
||||
} else
|
||||
isMouseDragging = false;
|
||||
|
||||
if (isMouseDragging)
|
||||
scrollY = targetScrollY = ValueUtil.clamp((mouseY - startDragY) / scrollFactor, 0, maxScroll);
|
||||
|
||||
if (scrollY != targetScrollY) {
|
||||
scrollY = ValueUtil.lerp(scrollY, targetScrollY, 0.1f);
|
||||
|
||||
if (Math.abs(scrollY - targetScrollY) < 0.001) // Snap to exact target value
|
||||
scrollY = targetScrollY;
|
||||
}
|
||||
|
||||
scrollY = ValueUtil.clamp(scrollY, 0, maxScroll);
|
||||
}
|
||||
|
||||
public void drawBar() {
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef(endX - barWidth - 2, startY + yStartSpacing + scrollY * scrollFactor, 0);
|
||||
GuiUtil.drawRectD(0, 0, barWidth, scrollbarHeight, (isMouseAboveBar(mouseX, mouseY) || isMouseDragging) ? 0xffbababa : 0xff767676);
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public boolean isMouseAboveBar(int mouseX, int mouseY) {
|
||||
int barX = endX - barWidth - 2;
|
||||
int barY = (int) (startY + yStartSpacing + scrollY * scrollFactor);
|
||||
|
||||
return mouseX >= barX && mouseX < barX + barWidth && mouseY >= barY && mouseY < barY + scrollbarHeight;
|
||||
}
|
||||
}
|
||||
|
||||
public class PresetElement {
|
||||
public KeyPreset key;
|
||||
public boolean isEditing;
|
||||
public float boxScreenX, boxScreenY;
|
||||
|
||||
public KeyPreset.KeyState newState = new KeyPreset.KeyState();
|
||||
|
||||
public PresetElement(KeyPreset key) {
|
||||
this.key = key;
|
||||
}
|
||||
|
||||
public void drawDescription() {
|
||||
String name = String.format("> %s", key.name);
|
||||
font.drawString(name, 0, 0, 0xffffff);
|
||||
|
||||
if (!key.shouldConflict)
|
||||
font.drawString("(Conflict-free)", font.getStringWidth(name) + 5, 0, 0xface40);
|
||||
|
||||
String description = String.format("- %s", key.description);
|
||||
font.drawSplitString(description, 9, font.FONT_HEIGHT, getMaxStringWidth() - 9, 0x888888);
|
||||
}
|
||||
|
||||
public void drawBox(int offsetY) {
|
||||
////////////////////////////////////////////
|
||||
////////////////////////////////////////////
|
||||
//Box texture
|
||||
Minecraft.getMinecraft().getTextureManager().bindTexture(TEXTURE);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glColor4f(1, 1, 1, 1);
|
||||
float boxScaleX = 1.75f;
|
||||
float boxWidth = 32 * boxScaleX;
|
||||
boxScreenX = getMaxStringWidth() * scale + 8; //remove scaling from maxStringWidth
|
||||
GL11.glScalef(boxScaleX, 1, 0);
|
||||
|
||||
if (isEditing)
|
||||
new Color(0x4772b3, 1).glColor();
|
||||
else if (isMouseAboveBox(mouseX, mouseY))
|
||||
new Color(0x656565, 1).glColor();
|
||||
else
|
||||
new Color(0x545454, 1).glColor();
|
||||
GuiUtil.drawTexturedModalRect(boxScreenX / boxScaleX, boxScreenY = offsetY - 5, 32, 20, 0, 492);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
//Reset box
|
||||
boolean isDefault = key.isDefault();
|
||||
float resetWidth = 10;
|
||||
float resetScreenX = boxScreenX + boxWidth + 2;
|
||||
|
||||
if (isMouseAboveReset(mouseX, mouseY) && !isDefault)
|
||||
new Color(0x656565, 1).glColor();
|
||||
else
|
||||
new Color(0x545454, 1).glColor();
|
||||
GuiUtil.drawTexturedModalRect(resetScreenX, boxScreenY, 10, 20, 33, 492);
|
||||
|
||||
////////////////////////////////////////////
|
||||
////////////////////////////////////////////
|
||||
//Key name
|
||||
String name = getBoxKeyName();
|
||||
float nameWidth = font.getStringWidth(name);
|
||||
float nameScale = scale;
|
||||
float nameBoxRatio = nameWidth * scale / boxWidth;
|
||||
|
||||
GL11.glPushMatrix();
|
||||
if (nameBoxRatio > 0.9) {
|
||||
nameScale /= nameWidth / boxWidth / 1.2f;
|
||||
GL11.glTranslatef(0, nameBoxRatio * 0.5f, 0);
|
||||
}
|
||||
|
||||
float nameX = boxScreenX + boxWidth / 2 - (nameWidth / 2 * nameScale);
|
||||
float nameY = offsetY + 11.5f - (font.FONT_HEIGHT / 2);
|
||||
GL11.glScalef(nameScale, nameScale, 1);
|
||||
GL11.glTranslatef(nameX / nameScale, nameY / nameScale, 1);
|
||||
font.drawStringWithShadow(name, 0, 0, conflicts() ? 0xff5555 : 0xffffffff);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
//Reset letter
|
||||
char letter = 'X';
|
||||
float letterX = resetScreenX + (resetWidth / 2) - (font.getCharWidth(letter) / 2 * scale) + 0.25f;
|
||||
GL11.glPushMatrix();
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
GL11.glTranslatef(letterX / scale, nameY / scale, 1);
|
||||
font.drawStringWithShadow(String.valueOf(letter), 0, 0, isDefault ? 0xff8a8a8a : 0xffffffff);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
////////////////////////////////////////////
|
||||
////////////////////////////////////////////
|
||||
}
|
||||
|
||||
public void boxClicked(int button) {
|
||||
if (isEditing)
|
||||
setKey(-100 + button);
|
||||
else if (button == 0)
|
||||
isEditing = true;
|
||||
}
|
||||
|
||||
public void keyTyped(int typedKey) {
|
||||
if (typedKey == 1) {
|
||||
setKey(0);
|
||||
return;
|
||||
}
|
||||
|
||||
newState.setState(newState.keyCode, KeyPreset.isCtrlKeyDown(), KeyPreset.isAltKeyDown(), KeyPreset.isShiftKeyDown());
|
||||
if (KeyPreset.isNotCtrlAltShift(typedKey))
|
||||
setKey(typedKey);
|
||||
}
|
||||
|
||||
public void setKey(int keyCode) {
|
||||
if (keyCode == 0)
|
||||
newState.clear();
|
||||
|
||||
newState.keyCode = keyCode;
|
||||
newState.writeTo(key.currentState);
|
||||
cancelEdit();
|
||||
manager.save();
|
||||
}
|
||||
|
||||
public void cancelEdit() {
|
||||
newState.clear();
|
||||
isEditing = false;
|
||||
}
|
||||
|
||||
public boolean conflicts() {
|
||||
return list.stream().anyMatch(element -> key.shouldConflict && element.key.shouldConflict && element.key != this.key && element.key.equals(this.key));
|
||||
}
|
||||
|
||||
public String getBoxKeyName() {
|
||||
if (isEditing) {
|
||||
String modifiers = "";
|
||||
if (KeyPreset.isCtrlKeyDown())
|
||||
modifiers += "CTRL ";
|
||||
if (KeyPreset.isAltKeyDown())
|
||||
modifiers += "ALT ";
|
||||
if (KeyPreset.isShiftKeyDown())
|
||||
modifiers += "SHIFT ";
|
||||
|
||||
return !modifiers.isEmpty() ? modifiers : "Press a key";
|
||||
}
|
||||
|
||||
return key.currentState.getName();
|
||||
}
|
||||
|
||||
public boolean isMouseAboveBox(int mouseX, int mouseY) {
|
||||
mouseX -= startX + 2;
|
||||
mouseY -= startY + 5 - scroll.scrollY;
|
||||
|
||||
float boxScaleX = 1.75f;
|
||||
float screenY = boxScreenY + 10;
|
||||
|
||||
return mouseX >= boxScreenX && mouseX < boxScreenX + 32 * boxScaleX && mouseY >= screenY && mouseY < screenY + 10;
|
||||
}
|
||||
|
||||
public boolean isMouseAboveReset(int mouseX, int mouseY) {
|
||||
mouseX -= startX + 2;
|
||||
mouseY -= startY + 5 - scroll.scrollY;
|
||||
|
||||
float boxScaleX = 1.75f;
|
||||
float resetWidth = 10, boxWidth = 32 * boxScaleX;
|
||||
float screenX = boxScreenX + boxWidth + 2;
|
||||
float screenY = boxScreenY + 10;
|
||||
|
||||
return mouseX >= screenX && mouseX < screenX + resetWidth && mouseY >= screenY && mouseY < screenY + 10;
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
List<String> wrappedDescription = font.listFormattedStringToWidth(String.format("- %s", key.description), getMaxStringWidth());
|
||||
|
||||
int nameHeight = font.FONT_HEIGHT;
|
||||
int translations = font.FONT_HEIGHT;
|
||||
int descriptionHeight = wrappedDescription.size() * (font.FONT_HEIGHT);
|
||||
|
||||
return Math.round((nameHeight + descriptionHeight + translations) * scale) + elementSpacing;
|
||||
}
|
||||
|
||||
public int getMaxStringWidth() {
|
||||
return (int) (getWidth() * 2.5f / 4);
|
||||
}
|
||||
}
|
||||
|
||||
public class OverlayButton {
|
||||
public int startX, startY, endX, width, height;
|
||||
public int textureWidth = 252, textureHeight = 109;
|
||||
public float scale = 0.25f;
|
||||
|
||||
public OverlayButton() {
|
||||
}
|
||||
|
||||
public void initGui(int endX, int startY) {
|
||||
this.endX = endX;
|
||||
this.startY = startY;
|
||||
|
||||
startX = (int) (endX - textureWidth * scale / 2);
|
||||
}
|
||||
|
||||
public void drawButton() {
|
||||
Minecraft.getMinecraft().getTextureManager().bindTexture(TEXTURE);
|
||||
|
||||
double screenX = startX / scale, screenY = startY / scale;
|
||||
int oldMinFilter = GL11.glGetTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER);
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
|
||||
|
||||
GL11.glPushMatrix();
|
||||
float color = 0.55f;
|
||||
GL11.glColor4f(color, color, color, 1);
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
GuiUtil.drawTexturedModalRect(screenX, screenY, textureWidth, textureHeight, 0, 0);
|
||||
GL11.glPopMatrix();
|
||||
|
||||
GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, oldMinFilter);
|
||||
}
|
||||
|
||||
public boolean isMouseAbove(int mouseX, int mouseY) {
|
||||
return mouseX >= startX && mouseX < startX + textureWidth * scale / 2 && mouseY >= startY - 4 && mouseY < startY + textureHeight * scale / 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package noppes.npcs.client.gui.util.animation;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.gui.FontRenderer;
|
||||
import noppes.npcs.client.gui.util.GuiNPCInterface;
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.keys.GraphEditorKeyPresets;
|
||||
|
||||
public class ViewportGraphEditor {
|
||||
public Minecraft mc = Minecraft.getMinecraft();
|
||||
public GuiNPCInterface parent;
|
||||
|
||||
public int startX, startY, endX, endY, width, height;
|
||||
|
||||
public GraphEditorKeyPresets keys = new GraphEditorKeyPresets();
|
||||
public OverlayKeyPresetViewer presetOverlay = new OverlayKeyPresetViewer(keys);
|
||||
|
||||
public Grid grid = new Grid(this);
|
||||
|
||||
public ViewportGraphEditor(GuiNPCInterface parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
public void initGui(int startX, int startY, int endX, int endY) {
|
||||
this.startX = startX;
|
||||
this.startY = startY;
|
||||
this.endX = endX;
|
||||
this.endY = endY;
|
||||
this.width = endX - this.startX;
|
||||
this.height = endY - this.startY;
|
||||
|
||||
grid.init(this.startX, this.startY, endX, endY);
|
||||
presetOverlay.initGui(endX - (width / 2) - 37, startY + (height / 4), endX, endY);
|
||||
presetOverlay.viewButton.initGui(endX + 1, endY + 2);
|
||||
}
|
||||
|
||||
public void updateScreen() {
|
||||
keys.tick();
|
||||
}
|
||||
|
||||
public void drawScreen(int mouseX, int mouseY, float partialTicks, int wheel) {
|
||||
GuiUtil.drawGradientRect(startX, startY, endX, endY, 0xFF303030, 0xFF303030);
|
||||
grid.draw(mouseX, mouseY, partialTicks, wheel);
|
||||
presetOverlay.draw(mouseX, mouseY, wheel);
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
grid.mouseClicked(mouseX, mouseY, button);
|
||||
presetOverlay.mouseClicked(mouseX, mouseY, button);
|
||||
}
|
||||
|
||||
public void keyTyped(char c, int i) {
|
||||
grid.keyTyped(c, i);
|
||||
presetOverlay.keyTyped(c, i);
|
||||
}
|
||||
|
||||
public boolean isWithin(int mouseX, int mouseY) {
|
||||
if (parent.hasSubGui())
|
||||
return false;
|
||||
|
||||
return mouseX >= startX && mouseX <= startX + width && mouseY >= startY && mouseY <= startY + height;
|
||||
}
|
||||
|
||||
public void drawString(String text, int x, int y, int color) {
|
||||
parent.drawCenteredString(getFontRenderer(), text, x, y, color);
|
||||
}
|
||||
|
||||
public FontRenderer getFontRenderer() {
|
||||
return parent.getFontRenderer();
|
||||
}
|
||||
|
||||
public void close() {
|
||||
if (Cursors.currentCursor != null)
|
||||
Cursors.reset();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package noppes.npcs.client.gui.util.animation.keys;
|
||||
|
||||
import org.lwjgl.input.Keyboard;
|
||||
|
||||
public class GraphEditorKeyPresets extends KeyPresetManager {
|
||||
|
||||
////////////////////
|
||||
//Grid controls
|
||||
public final KeyPreset PAN_GRID = add("Pan Grid").setDefaultState(KeyPreset.RIGHT_MOUSE, false, false, false).setDescription("Holding pans the grid with mouse cursor");
|
||||
public final KeyPreset LOCK_X = add("Lock X Axis").setDefaultState(Keyboard.KEY_X, false, false, false).setDescription("Holding locks the X axis while zooming or panning").shouldConflict(false);
|
||||
public final KeyPreset LOCK_Y = add("Lock Y Axis").setDefaultState(Keyboard.KEY_Y, false, false, false).setDescription("Holding locks the Y axis while zooming or panning").shouldConflict(false);
|
||||
public final KeyPreset RESET_GRID = add("Reset Grid").setDefaultState(Keyboard.KEY_R, false, false, false).setDescription("Resets the grid's XY scale and translation to the origins");
|
||||
|
||||
|
||||
////////////////////
|
||||
//Grid Point controls
|
||||
public final KeyPreset SELECT_POINT = add("Select Point").setDefaultState(KeyPreset.LEFT_MOUSE, false, false, false).setDescription("Select point under cursor");
|
||||
public final KeyPreset ADD_POINT = add("Add Point").setDefaultState(Keyboard.KEY_Z, false, false, false).setDescription("Add a new point at the play-head's X");
|
||||
public final KeyPreset DELETE_POINT = add("Delete Point").setDefaultState(Keyboard.KEY_X, true, false, false).setDescription("Delete selected point");
|
||||
public final KeyPreset FREE_TRANSFORM = add("Free Transform").setDefaultState(Keyboard.KEY_G, false, false, false).setDescription("Freely transform the selected point with the mouse").markDone(this);
|
||||
|
||||
public GraphEditorKeyPresets() {
|
||||
super("graph_editor");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
package noppes.npcs.client.gui.util.animation.keys;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.settings.GameSettings;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.input.Mouse;
|
||||
|
||||
import java.util.function.Consumer;
|
||||
|
||||
public class KeyPreset {
|
||||
/**
|
||||
* @field SINGLE_PRESS => on releasing before 5 ticks press time
|
||||
* @field PRESS_RELEASE => on pressing and releasing
|
||||
*/
|
||||
public static final int PRESS = 0, HOLD = 1, RELEASE = 2, SINGLE_PRESS = 3, PRESS_RELEASE = 4;
|
||||
|
||||
public KeyState defaultState = new KeyState();
|
||||
public KeyState currentState = new KeyState();
|
||||
|
||||
public String name, description;
|
||||
public boolean shouldConflict = true;
|
||||
public Consumer<Integer> task;
|
||||
|
||||
public int pressTime;
|
||||
public boolean isDown;
|
||||
|
||||
|
||||
public KeyPreset(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
public KeyPreset setDefaultState(int keyCode, boolean hasCtrl, boolean hasAlt, boolean hasShift) {
|
||||
defaultState.setState(keyCode, hasCtrl, hasAlt, hasShift);
|
||||
currentState.setState(keyCode, hasCtrl, hasAlt, hasShift);
|
||||
return this;
|
||||
}
|
||||
|
||||
public KeyPreset setDescription(String description) {
|
||||
this.description = description;
|
||||
return this;
|
||||
}
|
||||
|
||||
public KeyPreset setTask(Consumer<Integer> task) {
|
||||
this.task = task;
|
||||
return this;
|
||||
}
|
||||
|
||||
public KeyPreset shouldConflict(boolean shouldConflict) {
|
||||
this.shouldConflict = shouldConflict;
|
||||
return this;
|
||||
}
|
||||
|
||||
public void tick() {
|
||||
int keyCode = keyCode();
|
||||
if (keyCode == -1 || keyCode == 0)
|
||||
return;
|
||||
|
||||
boolean isDown = isMouseKey() ? Mouse.isButtonDown(keyCode + 100) : Keyboard.isKeyDown(keyCode);
|
||||
isDown = isDown && (hasCtrl() ? isCtrlKeyDown() : true) && (hasAlt() ? isAltKeyDown() : true && (hasShift() ? isShiftKeyDown() : true));
|
||||
|
||||
setDown(isDown);
|
||||
}
|
||||
|
||||
public void setDown(boolean down) {
|
||||
if (down && !isDown)
|
||||
onAction(PRESS, PRESS_RELEASE);
|
||||
|
||||
if (!down && isDown) {
|
||||
if (pressTime <= 5)
|
||||
onAction(SINGLE_PRESS);
|
||||
|
||||
onAction(RELEASE, PRESS_RELEASE);
|
||||
pressTime = 0;
|
||||
}
|
||||
|
||||
if (isDown || down) //to fire in both press & release
|
||||
onAction(HOLD);
|
||||
|
||||
if (isDown)
|
||||
pressTime++;
|
||||
|
||||
this.isDown = down;
|
||||
}
|
||||
|
||||
public KeyPreset onAction(int... pressTypes) {
|
||||
if (task != null) {
|
||||
for (int pressType : pressTypes)
|
||||
this.task.accept(pressType);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
public boolean isDefault() {
|
||||
return currentState.equals(defaultState);
|
||||
}
|
||||
|
||||
public boolean isMouseKey() {
|
||||
return keyCode() < -1;
|
||||
}
|
||||
|
||||
public int keyCode() {
|
||||
return currentState.keyCode;
|
||||
}
|
||||
|
||||
public boolean hasCtrl() {
|
||||
return currentState.hasCtrl;
|
||||
}
|
||||
|
||||
public boolean hasAlt() {
|
||||
return currentState.hasAlt;
|
||||
}
|
||||
|
||||
public boolean hasShift() {
|
||||
return currentState.hasShift;
|
||||
}
|
||||
|
||||
public String getKeyName() {
|
||||
return currentState.getName();
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
currentState.clear();
|
||||
}
|
||||
|
||||
//call on the last key added, to load saved presets
|
||||
public KeyPreset markDone(KeyPresetManager manager) {
|
||||
manager.load();
|
||||
return this;
|
||||
}
|
||||
|
||||
public void writeToNbt(NBTTagCompound c) {
|
||||
c.setTag(name, currentState.writeToNbt());
|
||||
}
|
||||
|
||||
public void readFromNbt(NBTTagCompound compound) {
|
||||
currentState.readFromNbt(compound.getCompoundTag(name));
|
||||
}
|
||||
|
||||
public boolean equals(Object preset) {
|
||||
if (preset == this)
|
||||
return true;
|
||||
|
||||
if (preset instanceof KeyPreset) {
|
||||
KeyPreset key = (KeyPreset) preset;
|
||||
return key.currentState.equals(currentState);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
public static class KeyState {
|
||||
public int keyCode = -1;
|
||||
public boolean hasCtrl, hasAlt, hasShift;
|
||||
|
||||
public void setState(int keyCode, boolean hasCtrl, boolean hasAlt, boolean hasShift) {
|
||||
this.keyCode = keyCode;
|
||||
this.hasCtrl = hasCtrl;
|
||||
this.hasAlt = hasAlt;
|
||||
this.hasShift = hasShift;
|
||||
}
|
||||
|
||||
public void readFrom(KeyState state) {
|
||||
keyCode = state.keyCode;
|
||||
hasCtrl = state.hasCtrl;
|
||||
hasShift = state.hasShift;
|
||||
hasAlt = state.hasAlt;
|
||||
}
|
||||
|
||||
public void writeTo(KeyState state) {
|
||||
state.setState(keyCode, hasCtrl, hasAlt, hasShift);
|
||||
}
|
||||
|
||||
public boolean hasState() {
|
||||
return keyCode != -1;
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
this.keyCode = -1;
|
||||
hasCtrl = hasAlt = hasShift = false;
|
||||
}
|
||||
|
||||
public boolean equals(Object preset) {
|
||||
if (preset == this)
|
||||
return true;
|
||||
|
||||
if (preset instanceof KeyState) {
|
||||
KeyState state = (KeyState) preset;
|
||||
return state.keyCode == keyCode && state.hasCtrl == hasCtrl && state.hasAlt == hasAlt && state.hasShift == hasShift;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public NBTTagCompound writeToNbt() {
|
||||
NBTTagCompound compound = new NBTTagCompound();
|
||||
compound.setInteger("keyCode", keyCode);
|
||||
compound.setBoolean("hasCtrl", hasCtrl);
|
||||
compound.setBoolean("hasShift", hasShift);
|
||||
compound.setBoolean("hasAlt", hasAlt);
|
||||
return compound;
|
||||
}
|
||||
|
||||
public void readFromNbt(NBTTagCompound compound) {
|
||||
this.keyCode = compound.getInteger("keyCode");
|
||||
this.hasCtrl = compound.getBoolean("hasCtrl");
|
||||
this.hasShift = compound.getBoolean("hasShift");
|
||||
this.hasAlt = compound.getBoolean("hasAlt");
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
int code = keyCode;
|
||||
String name = "";
|
||||
|
||||
if (code == LEFT_MOUSE)
|
||||
name = "Left Mouse";
|
||||
else if (code == RIGHT_MOUSE)
|
||||
name = "Right Mouse";
|
||||
else if (code == MIDDLE_MOUSE)
|
||||
name = "Middle Mouse";
|
||||
else {
|
||||
name = code == -1 ? "" : GameSettings.getKeyDisplayString(code);
|
||||
if (name.contains("Button"))
|
||||
name = name.replace("Button", "Mouse");
|
||||
}
|
||||
|
||||
return (hasCtrl ? "CTRL " : "") + (hasAlt ? "ALT " : "") + (hasShift ? "SHIFT " : "") + name;
|
||||
}
|
||||
}
|
||||
|
||||
public static final int LEFT_MOUSE = -100, RIGHT_MOUSE = -99, MIDDLE_MOUSE = -98, MOUSE_4 = -97, MOUSE_5 = -96;
|
||||
|
||||
public static boolean isCtrlKeyDown() {
|
||||
return Minecraft.isRunningOnMac ? Keyboard.isKeyDown(219) || Keyboard.isKeyDown(220) : Keyboard.isKeyDown(29) || Keyboard.isKeyDown(157);
|
||||
}
|
||||
|
||||
public static boolean isAltKeyDown() {
|
||||
return Keyboard.isKeyDown(56) || Keyboard.isKeyDown(184);
|
||||
}
|
||||
|
||||
public static boolean isShiftKeyDown() {
|
||||
return Keyboard.isKeyDown(42) || Keyboard.isKeyDown(54);
|
||||
}
|
||||
|
||||
public static boolean isNotCtrlAltShift(int key) {
|
||||
return key != 219 && key != 220 && key != 29 && key != 157 && key != 42 && key != 54 && key != 56 && key != 184;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package noppes.npcs.client.gui.util.animation.keys;
|
||||
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.CustomNpcs;
|
||||
import noppes.npcs.LogWriter;
|
||||
import noppes.npcs.util.NBTJsonUtil;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class KeyPresetManager {
|
||||
public List<KeyPreset> keys = new ArrayList<>();
|
||||
public String fileName;
|
||||
|
||||
public KeyPresetManager(String fileName) {
|
||||
this.fileName = fileName;
|
||||
}
|
||||
|
||||
public KeyPreset add(String name) {
|
||||
KeyPreset preset = new KeyPreset(name);
|
||||
keys.add(preset);
|
||||
return preset;
|
||||
}
|
||||
|
||||
public void tick() {
|
||||
for (KeyPreset key : keys)
|
||||
key.tick();
|
||||
}
|
||||
|
||||
|
||||
public void load() {
|
||||
try {
|
||||
File dir = getDir();
|
||||
File file = new File(dir, fileName + ".json");
|
||||
if (!file.exists())
|
||||
return;
|
||||
|
||||
NBTTagCompound compound = NBTJsonUtil.LoadFile(file);
|
||||
for (KeyPreset key : keys)
|
||||
key.readFromNbt(compound);
|
||||
|
||||
} catch (Exception e) {
|
||||
LogWriter.except(e);
|
||||
}
|
||||
}
|
||||
|
||||
public void save() {
|
||||
try {
|
||||
File dir = getDir();
|
||||
String filename = fileName + ".json";
|
||||
|
||||
File newFile = new File(dir, filename + "_new");
|
||||
File originalFile = new File(dir, filename);
|
||||
|
||||
NBTTagCompound compound = new NBTTagCompound();
|
||||
for (KeyPreset key : keys)
|
||||
key.writeToNbt(compound);
|
||||
|
||||
NBTJsonUtil.SaveFile(newFile, compound);
|
||||
|
||||
if (originalFile.exists())
|
||||
originalFile.delete();
|
||||
|
||||
newFile.renameTo(originalFile);
|
||||
} catch (Exception e) {
|
||||
LogWriter.except(e);
|
||||
}
|
||||
}
|
||||
|
||||
public File getDir() {
|
||||
File dir = new File(CustomNpcs.Dir, "keypresets");
|
||||
if (!dir.exists())
|
||||
dir.mkdir();
|
||||
return dir;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package noppes.npcs.client.gui.util.animation.panel;
|
||||
|
||||
import noppes.npcs.client.gui.util.GuiUtil;
|
||||
import noppes.npcs.client.gui.util.animation.AnimationGraphEditor;
|
||||
import noppes.npcs.constants.animation.EnumFrameType;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
import java.util.LinkedList;
|
||||
|
||||
public class PanelFrameType {
|
||||
public AnimationGraphEditor graph;
|
||||
|
||||
public int startX, startY, endX, endY, width, height;
|
||||
public float scale = 0.66f;
|
||||
public int elementHeight = 5, elementSpacing = 7;
|
||||
|
||||
public LinkedList<Element> list = new LinkedList<>();
|
||||
|
||||
public PanelFrameType(AnimationGraphEditor graph) {
|
||||
this.graph = graph;
|
||||
|
||||
for (EnumFrameType type : EnumFrameType.values())
|
||||
list.add(new Element(type));
|
||||
}
|
||||
|
||||
public void initGui(int startX, int startY, int endX, int endY) {
|
||||
this.startX = startX;
|
||||
this.startY = startY;
|
||||
this.endX = endX;
|
||||
this.endY = endY;
|
||||
this.width = endX - startX;
|
||||
this.height = endY - startY;
|
||||
}
|
||||
|
||||
public void draw() {
|
||||
// GuiUtil.drawRectD(startX,startY,endX,endY, 0xffffffff);
|
||||
GL11.glPushMatrix();
|
||||
GL11.glTranslatef((startX + 2), startY, 0);
|
||||
|
||||
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
Element element = list.get(i);
|
||||
element.draw(i);
|
||||
}
|
||||
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
|
||||
public void keyTyped(char c, int i) {
|
||||
list.forEach((element) -> {
|
||||
});
|
||||
}
|
||||
|
||||
public void mouseClicked(int mouseX, int mouseY, int button) {
|
||||
list.forEach((element) -> {
|
||||
});
|
||||
}
|
||||
|
||||
public boolean isMouseAbove(int mouseX, int mouseY) {
|
||||
return mouseX >= startX && mouseX < endX && mouseY >= startY && mouseY < endY;
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
return (int) (width / scale);
|
||||
}
|
||||
|
||||
public class Element {
|
||||
public EnumFrameType type;
|
||||
|
||||
public Element(EnumFrameType key) {
|
||||
this.type = key;
|
||||
}
|
||||
|
||||
public void draw(int index) {
|
||||
|
||||
|
||||
// GuiUtil.drawRectD(100,100,endX,endY, type.color);
|
||||
float offsetY = index * (elementHeight + elementSpacing + 2) / scale;
|
||||
GL11.glPushMatrix();
|
||||
GL11.glScalef(scale, scale, 1);
|
||||
GL11.glTranslatef(0, offsetY, 0);
|
||||
GuiUtil.drawRectD(0, 0, width / scale, (elementHeight + elementSpacing) / scale, 0x0);
|
||||
GuiUtil.drawRectD(0, 0, 3, (elementHeight + elementSpacing) / scale, type.color);
|
||||
|
||||
GL11.glTranslatef(0, ((elementHeight + elementSpacing) / 2), 0);
|
||||
String name = String.format("%s", type.toString());
|
||||
graph.getFontRenderer().drawString(name, 6, 0, 0xffffff);
|
||||
|
||||
GL11.glPopMatrix();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package noppes.npcs.client.utils;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
|
||||
public class Color {
|
||||
public int color;
|
||||
public float alpha;
|
||||
|
||||
public Color(int color, float alpha) {
|
||||
setColor(color, alpha);
|
||||
}
|
||||
|
||||
public Color(int red, int green, int blue, float alpha) {
|
||||
setColor(red, green, blue, alpha);
|
||||
}
|
||||
|
||||
public void setColor(int color, float alpha) {
|
||||
this.color = color;
|
||||
this.alpha = alpha;
|
||||
}
|
||||
|
||||
public void setColor(int red, int green, int blue, float alpha) {
|
||||
this.color = (red << 16) + (green << 8) + blue;
|
||||
this.alpha = alpha;
|
||||
}
|
||||
|
||||
public static Color lerpRGBA(Color color1, Color color2, float fraction) {
|
||||
fraction = Math.min(fraction, 1f);
|
||||
int red = (int) (color1.getRed() + ((color2.getRed() - color1.getRed()) * fraction));
|
||||
int green = (int) (color1.getGreen() + ((color2.getGreen() - color1.getGreen()) * fraction));
|
||||
int blue = (int) (color1.getBlue() + ((color2.getBlue() - color1.getBlue()) * fraction));
|
||||
float newAlpha = color1.alpha + ((color2.alpha - color1.alpha) * fraction);
|
||||
int newColor = (red << 16) + (green << 8) + blue;
|
||||
return new Color(newColor, newAlpha);
|
||||
}
|
||||
|
||||
public Color lerpRGBA(Color color2, float fraction) {
|
||||
return Color.lerpRGBA(this, color2, fraction);
|
||||
}
|
||||
|
||||
public Color multiply(float multi) {
|
||||
int r = (int) ((getRed() * multi));
|
||||
int g = (int) ((getGreen() * multi));
|
||||
int b = (int) ((getBlue() * multi));
|
||||
float a = alpha * multi;
|
||||
return new Color((r << 16) + (g << 8) + b, a);
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public void glColor() {
|
||||
GL11.glColor4f(getRedF(), getGreenF(), getBlueF(), alpha);
|
||||
}
|
||||
|
||||
public NBTTagCompound writeToNBT(NBTTagCompound compound, String name) {
|
||||
compound.setInteger(name + "Color", color);
|
||||
compound.setFloat(name + "Alpha", alpha);
|
||||
|
||||
return compound;
|
||||
}
|
||||
|
||||
public void readFromNBT(NBTTagCompound compound, String name) {
|
||||
setColor(compound.getInteger(name + "Color"), compound.getFloat(name + "Alpha"));
|
||||
}
|
||||
|
||||
public int getRed() {
|
||||
return (color >> 16 & 0xFF);
|
||||
}
|
||||
|
||||
public float getRedF() {
|
||||
return (float) (color >> 16 & 0xFF) / 255f;
|
||||
}
|
||||
|
||||
public int getGreen() {
|
||||
return (color >> 8 & 0xFF);
|
||||
}
|
||||
|
||||
public float getGreenF() {
|
||||
return (float) (color >> 8 & 0xFF) / 255f;
|
||||
}
|
||||
|
||||
public int getBlue() {
|
||||
return (color & 0xFF);
|
||||
}
|
||||
|
||||
public float getBlueF() {
|
||||
return (float) (color & 0xFF) / 255f;
|
||||
}
|
||||
|
||||
public static String getColor(int color) {
|
||||
String str;
|
||||
for (str = Integer.toHexString(color); str.length() < 6; str = "0" + str) {
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
public static String getColor(int color, float alpha) {
|
||||
String str = getColor(color);
|
||||
return str + " | " + (int) (alpha * 255);
|
||||
}
|
||||
|
||||
public Color clone() {
|
||||
return new Color(color, alpha);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package noppes.npcs.constants.animation;
|
||||
|
||||
import noppes.npcs.client.utils.Color;
|
||||
|
||||
public enum EnumFrameType {
|
||||
ROTATION_X(0xff3352), ROTATION_Y(0x8bdc00), ROTATION_Z(0x2890ff), PIVOT_X(0xff3352), PIVOT_Y(0x8bdc00), PIVOT_Z(0x2890ff);
|
||||
|
||||
public int color;
|
||||
|
||||
EnumFrameType(int color) {
|
||||
this.color = color;
|
||||
}
|
||||
|
||||
public Color getColor() {
|
||||
return new Color(color, 1);
|
||||
}
|
||||
}
|
||||
@@ -54,6 +54,14 @@ public class Animation implements IAnimation {
|
||||
return this.parent;
|
||||
}
|
||||
|
||||
public boolean hasFrame(int index) {
|
||||
return index >= 0 && index < frames.size();
|
||||
}
|
||||
|
||||
public IFrame getFrame(int index) {
|
||||
return hasFrame(index) ? frames.get(index) : null;
|
||||
}
|
||||
|
||||
public IFrame currentFrame() {
|
||||
return currentFrame < frames.size() ? frames.get(currentFrame) : null;
|
||||
}
|
||||
@@ -76,12 +84,22 @@ public class Animation implements IAnimation {
|
||||
}
|
||||
|
||||
public IAnimation addFrame(IFrame frame) {
|
||||
this.frames.add((Frame) frame);
|
||||
return this;
|
||||
return addFrame((Frame) frame);
|
||||
}
|
||||
|
||||
public IAnimation addFrame(int index, IFrame frame) {
|
||||
this.frames.add(index, (Frame) frame);
|
||||
return addFrame(index, (Frame) frame);
|
||||
}
|
||||
|
||||
public IAnimation addFrame(Frame frame) {
|
||||
frame.setParent(this);
|
||||
this.frames.add(frame);
|
||||
return this;
|
||||
}
|
||||
|
||||
public IAnimation addFrame(int index, Frame frame) {
|
||||
frame.setParent(this);
|
||||
this.frames.add(index, frame);
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -192,7 +210,7 @@ public class Animation implements IAnimation {
|
||||
for (int i = 0; i < list.tagCount(); i++) {
|
||||
NBTTagCompound item = list.getCompoundTagAt(i);
|
||||
Frame frame = new Frame();
|
||||
frame.parent = this;
|
||||
frame.setParent(this);
|
||||
frame.readFromNBT(item);
|
||||
frames.add(frame);
|
||||
}
|
||||
@@ -230,6 +248,18 @@ public class Animation implements IAnimation {
|
||||
return compound;
|
||||
}
|
||||
|
||||
public int getCurrentTick() {
|
||||
int time = 0;
|
||||
for (int i = 0; i < this.frames.size(); i++) {
|
||||
if (i >= this.currentFrame) {
|
||||
break;
|
||||
}
|
||||
time += this.frames.get(i).getDuration();
|
||||
}
|
||||
time += this.currentFrameTime;
|
||||
return time;
|
||||
}
|
||||
|
||||
public boolean increaseTime() {
|
||||
if (paused)
|
||||
return false;
|
||||
|
||||
@@ -9,9 +9,8 @@ import noppes.npcs.constants.EnumAnimationPart;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
|
||||
public class Frame implements IFrame {
|
||||
public Animation parent;
|
||||
private Animation parent;
|
||||
public HashMap<EnumAnimationPart, FramePart> frameParts = new HashMap<>();
|
||||
public int duration = 0;
|
||||
|
||||
@@ -36,16 +35,42 @@ public class Frame implements IFrame {
|
||||
this.customized = true;
|
||||
}
|
||||
|
||||
public int getStartTick() {
|
||||
int time = 0;
|
||||
for (int i = 0; i < parent.frames.size(); i++) {
|
||||
Frame f = parent.frames.get(i);
|
||||
if (f == this)
|
||||
break;
|
||||
|
||||
time += f.getDuration();
|
||||
}
|
||||
return time;
|
||||
}
|
||||
|
||||
public void setParent(Animation parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
public Animation getParent() {
|
||||
return parent;
|
||||
}
|
||||
|
||||
public HashMap<EnumAnimationPart, FramePart> getFrameMap() {
|
||||
return frameParts;
|
||||
}
|
||||
|
||||
public void addPart(EnumAnimationPart key, FramePart frame) {
|
||||
frame.setParent(parent);
|
||||
frameParts.put(key, frame);
|
||||
}
|
||||
|
||||
public IFramePart[] getParts() {
|
||||
return frameParts.values().toArray(new IFramePart[0]);
|
||||
}
|
||||
|
||||
public IFrame addPart(IFramePart partConfig) {
|
||||
this.frameParts.put(((FramePart) partConfig).getPart(), (FramePart) partConfig);
|
||||
((FramePart) partConfig).setParent(parent);
|
||||
addPart(((FramePart) partConfig).getPart(), (FramePart) partConfig);
|
||||
return this;
|
||||
}
|
||||
|
||||
@@ -150,6 +175,7 @@ public class Frame implements IFrame {
|
||||
for (int i = 0; i < list.tagCount(); i++) {
|
||||
NBTTagCompound item = list.getCompoundTagAt(i);
|
||||
FramePart framePart = new FramePart();
|
||||
framePart.setParent(parent);
|
||||
framePart.readFromNBT(item);
|
||||
if (!framePart.customized) {
|
||||
framePart.smooth = this.smooth;
|
||||
@@ -184,7 +210,7 @@ public class Frame implements IFrame {
|
||||
Frame frame = new Frame(this.duration);
|
||||
HashMap<EnumAnimationPart, FramePart> frameParts = this.frameParts;
|
||||
for (Map.Entry<EnumAnimationPart, FramePart> entry : frameParts.entrySet()) {
|
||||
frame.frameParts.put(entry.getKey(), entry.getValue().copy());
|
||||
frame.addPart(entry.getKey(), entry.getValue().copy());
|
||||
}
|
||||
frame.parent = this.parent;
|
||||
frame.duration = this.duration;
|
||||
|
||||
@@ -6,13 +6,22 @@ import net.minecraft.nbt.NBTTagCompound;
|
||||
import noppes.npcs.api.handler.data.IFramePart;
|
||||
import noppes.npcs.client.ClientEventHandler;
|
||||
import noppes.npcs.constants.EnumAnimationPart;
|
||||
import noppes.npcs.constants.animation.EnumFrameType;
|
||||
import noppes.npcs.util.Ease;
|
||||
import noppes.npcs.util.ValueUtil;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public class FramePart implements IFramePart {
|
||||
|
||||
public Animation parent;
|
||||
public EnumAnimationPart part;
|
||||
public float[] rotation = {0, 0, 0};
|
||||
public float[] pivot = {0, 0, 0};
|
||||
|
||||
public HashMap<EnumFrameType, Value> values = new HashMap<>();
|
||||
|
||||
boolean customized = false;
|
||||
|
||||
public float speed = 1.0F;
|
||||
@@ -32,6 +41,14 @@ public class FramePart implements IFramePart {
|
||||
this.part = part;
|
||||
}
|
||||
|
||||
public void setParent(Animation parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
public Animation getParent() {
|
||||
return parent;
|
||||
}
|
||||
|
||||
public EnumAnimationPart getPart() {
|
||||
return part;
|
||||
}
|
||||
@@ -114,12 +131,28 @@ public class FramePart implements IFramePart {
|
||||
public void readFromNBT(NBTTagCompound compound) {
|
||||
part = EnumAnimationPart.valueOf(compound.getString("Part"));
|
||||
for (int i = 0; i < 3; i++) {
|
||||
rotation[i] = compound.getFloat("Rotation" + i);
|
||||
if (compound.hasKey("Rotation" + i)) {
|
||||
rotation[i] = compound.getFloat("Rotation" + i);
|
||||
addValue(EnumFrameType.values()[i], rotation[i]);
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < 3; i++) {
|
||||
pivot[i] = compound.getFloat("Pivot" + i);
|
||||
if (compound.hasKey("Pivot" + i)) {
|
||||
pivot[i] = compound.getFloat("Pivot" + i);
|
||||
addValue(EnumFrameType.values()[3 + i], rotation[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (compound.hasKey("Rotation0")) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
rotation[i] = compound.getFloat("Rotation" + i);
|
||||
addValue(EnumFrameType.values()[i], rotation[i]);
|
||||
pivot[i] = compound.getFloat("Pivot" + i);
|
||||
addValue(EnumFrameType.values()[3 + i], rotation[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Customized = TRUE if Speed or Smooth Exist
|
||||
if (compound.hasKey("Speed")) {
|
||||
customized = true;
|
||||
@@ -129,6 +162,15 @@ public class FramePart implements IFramePart {
|
||||
customized = true;
|
||||
smooth = compound.getByte("Smooth");
|
||||
}
|
||||
|
||||
for (EnumFrameType type : EnumFrameType.values()) {
|
||||
String name = type.toString().toLowerCase();
|
||||
if (compound.hasKey(name)) {
|
||||
NBTTagCompound cmpd = compound.getCompoundTag(name);
|
||||
Ease easing = Ease.valueOf(cmpd.getString("easing"));
|
||||
addValue(type, cmpd.getFloat("value"), easing);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public NBTTagCompound writeToNBT() {
|
||||
@@ -141,6 +183,11 @@ public class FramePart implements IFramePart {
|
||||
compound.setFloat("Pivot" + i, pivot[i]);
|
||||
}
|
||||
|
||||
for (Map.Entry<EnumFrameType, Value> entry : values.entrySet()) {
|
||||
EnumFrameType type = entry.getKey();
|
||||
compound.setTag(type.toString().toLowerCase(), entry.getValue().writeToNBT());
|
||||
}
|
||||
|
||||
if (customized) {
|
||||
compound.setFloat("Speed", speed);
|
||||
compound.setByte("Smooth", smooth);
|
||||
@@ -165,33 +212,75 @@ public class FramePart implements IFramePart {
|
||||
return;
|
||||
|
||||
float pi = (float) Math.PI / 180;
|
||||
if (this.smooth == 2) {
|
||||
this.prevRotations[0] = this.rotation[0] * pi;
|
||||
this.prevRotations[1] = this.rotation[1] * pi;
|
||||
this.prevRotations[2] = this.rotation[2] * pi;
|
||||
} else if (this.partialRotationTick != ClientEventHandler.partialRenderTick) {
|
||||
if (this.partialRotationTick != ClientEventHandler.partialRenderTick) {
|
||||
this.partialRotationTick = ClientEventHandler.partialRenderTick;
|
||||
if (this.smooth == 0) {
|
||||
this.prevRotations[0] = (this.rotation[0] * pi - this.prevRotations[0]) * Math.abs(this.speed) / 10f + this.prevRotations[0];
|
||||
this.prevRotations[1] = (this.rotation[1] * pi - this.prevRotations[1]) * Math.abs(this.speed) / 10f + this.prevRotations[1];
|
||||
this.prevRotations[2] = (this.rotation[2] * pi - this.prevRotations[2]) * Math.abs(this.speed) / 10f + this.prevRotations[2];
|
||||
} else {
|
||||
int directionX = Float.compare(this.rotation[0] * pi, this.prevRotations[0]);
|
||||
this.prevRotations[0] += directionX * this.speed / 10f;
|
||||
this.prevRotations[0] = directionX == 1 ?
|
||||
Math.min(this.rotation[0] * pi, this.prevRotations[0]) : Math.max(this.rotation[0] * pi, this.prevRotations[0]);
|
||||
int directionY = Float.compare(this.rotation[1] * pi, this.prevRotations[1]);
|
||||
this.prevRotations[1] += directionY * this.speed / 10f;
|
||||
this.prevRotations[1] = directionY == 1 ?
|
||||
Math.min(this.rotation[1] * pi, this.prevRotations[1]) : Math.max(this.rotation[1] * pi, this.prevRotations[1]);
|
||||
int directionZ = Float.compare(this.rotation[2] * pi, this.prevRotations[2]);
|
||||
this.prevRotations[2] += directionZ * this.speed / 10f;
|
||||
this.prevRotations[2] = directionZ == 1 ?
|
||||
Math.min(this.rotation[2] * pi, this.prevRotations[2]) : Math.max(this.rotation[2] * pi, this.prevRotations[2]);
|
||||
boolean newLogic = true;
|
||||
if (newLogic && parent != null) {
|
||||
Frame next = (Frame) parent.getFrame(parent.currentFrame + 1);
|
||||
if (next != null) {
|
||||
FramePart nextPart = next.frameParts.get(part);
|
||||
if (nextPart != null) {
|
||||
float value = Ease.OUTBOUNCE.apply(getInterpolationValue());
|
||||
this.prevRotations[0] = ValueUtil.lerp(values.get(EnumFrameType.ROTATION_X).value * pi, nextPart.values.get(EnumFrameType.ROTATION_X).value * pi, value);
|
||||
this.prevRotations[1] = ValueUtil.lerp(values.get(EnumFrameType.ROTATION_Y).value * pi, nextPart.values.get(EnumFrameType.ROTATION_Y).value * pi, value);
|
||||
this.prevRotations[2] = ValueUtil.lerp(values.get(EnumFrameType.ROTATION_Z).value * pi, nextPart.values.get(EnumFrameType.ROTATION_Z).value * pi, value);
|
||||
|
||||
this.prevRotations[0] = ValueUtil.lerp(this.rotation[0] * pi, nextPart.rotation[0] * pi, value);
|
||||
this.prevRotations[1] = ValueUtil.lerp(this.rotation[1] * pi, nextPart.rotation[1] * pi, value);
|
||||
this.prevRotations[2] = ValueUtil.lerp(this.rotation[2] * pi, nextPart.rotation[2] * pi, value);
|
||||
}
|
||||
}
|
||||
} else { /**
|
||||
* Smoothing 0 - Interpolated => equivalent to {@link Ease#INSINE}
|
||||
*/
|
||||
float value = Math.abs(speed) / 20f;
|
||||
this.prevRotations[0] = ValueUtil.lerp(this.prevRotations[0], this.rotation[0] * pi, value);
|
||||
this.prevRotations[1] = ValueUtil.lerp(this.prevRotations[1], this.rotation[1] * pi, value);
|
||||
this.prevRotations[2] = ValueUtil.lerp(this.prevRotations[2], this.rotation[2] * pi, value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public float getInterpolationValue() { // a 0-1 that lerps between currentFrame startTick and nextFrame startTick
|
||||
float currentTick = parent.getCurrentTick();
|
||||
if (currentTick == 0)
|
||||
return 0;
|
||||
|
||||
Frame current = parent.frames.get(parent.currentFrame);
|
||||
float partialTicks = parent.paused ? 0 : partialRotationTick;
|
||||
currentTick += partialTicks;
|
||||
float ratio = (currentTick - current.getStartTick()) / current.duration; //
|
||||
|
||||
System.out.println("currentTick " + currentTick + ", interp_value " + ratio);
|
||||
return ratio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Smoothing 2 - None => equivalent to {@link Ease#CONSTANT}
|
||||
*/
|
||||
public void constant() {
|
||||
float pi = (float) Math.PI / 180;
|
||||
this.prevRotations[0] = this.rotation[0] * pi;
|
||||
this.prevRotations[1] = this.rotation[1] * pi;
|
||||
this.prevRotations[2] = this.rotation[2] * pi;
|
||||
}
|
||||
|
||||
/**
|
||||
* Smoothing 1 - Linear => equivalent to {@link Ease#LINEAR}
|
||||
*/
|
||||
public void linear() {
|
||||
float pi = (float) Math.PI / 180;
|
||||
int directionX = Float.compare(this.rotation[0] * pi, this.prevRotations[0]);
|
||||
this.prevRotations[0] += directionX * this.speed / 10f;
|
||||
this.prevRotations[0] = directionX == 1 ? Math.min(this.rotation[0] * pi, this.prevRotations[0]) : Math.max(this.rotation[0] * pi, this.prevRotations[0]);
|
||||
int directionY = Float.compare(this.rotation[1] * pi, this.prevRotations[1]);
|
||||
this.prevRotations[1] += directionY * this.speed / 10f;
|
||||
this.prevRotations[1] = directionY == 1 ? Math.min(this.rotation[1] * pi, this.prevRotations[1]) : Math.max(this.rotation[1] * pi, this.prevRotations[1]);
|
||||
int directionZ = Float.compare(this.rotation[2] * pi, this.prevRotations[2]);
|
||||
this.prevRotations[2] += directionZ * this.speed / 10f;
|
||||
this.prevRotations[2] = directionZ == 1 ? Math.min(this.rotation[2] * pi, this.prevRotations[2]) : Math.max(this.rotation[2] * pi, this.prevRotations[2]);
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public void interpolateOffset() {
|
||||
if (parent != null && parent.paused)
|
||||
@@ -210,16 +299,13 @@ public class FramePart implements IFramePart {
|
||||
} else {
|
||||
int directionX = Float.compare(this.pivot[0], this.prevPivots[0]);
|
||||
this.prevPivots[0] += directionX * this.speed / 10f;
|
||||
this.prevPivots[0] = directionX == 1 ?
|
||||
Math.min(this.pivot[0], this.prevPivots[0]) : Math.max(this.pivot[0], this.prevPivots[0]);
|
||||
this.prevPivots[0] = directionX == 1 ? Math.min(this.pivot[0], this.prevPivots[0]) : Math.max(this.pivot[0], this.prevPivots[0]);
|
||||
int directionY = Float.compare(this.pivot[1], this.prevPivots[1]);
|
||||
this.prevPivots[1] += directionY * this.speed / 10f;
|
||||
this.prevPivots[1] = directionY == 1 ?
|
||||
Math.min(this.pivot[1], this.prevPivots[1]) : Math.max(this.pivot[1], this.prevPivots[1]);
|
||||
this.prevPivots[1] = directionY == 1 ? Math.min(this.pivot[1], this.prevPivots[1]) : Math.max(this.pivot[1], this.prevPivots[1]);
|
||||
int directionZ = Float.compare(this.pivot[2], this.prevPivots[2]);
|
||||
this.prevPivots[2] += directionZ * this.speed / 10f;
|
||||
this.prevPivots[2] = directionZ == 1 ?
|
||||
Math.min(this.pivot[2], this.prevPivots[2]) : Math.max(this.pivot[2], this.prevPivots[2]);
|
||||
this.prevPivots[2] = directionZ == 1 ? Math.min(this.pivot[2], this.prevPivots[2]) : Math.max(this.pivot[2], this.prevPivots[2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -238,4 +324,53 @@ public class FramePart implements IFramePart {
|
||||
this.prevRotations[1] = this.rotation[1] * pi;
|
||||
this.prevRotations[2] = this.rotation[2] * pi;
|
||||
}
|
||||
|
||||
public IFramePart addValue(String type, float value) {
|
||||
addValue(EnumFrameType.valueOf(type.toUpperCase()), value, Ease.INSINE);
|
||||
return this;
|
||||
}
|
||||
|
||||
public IFramePart addValue(String type, float value, String easing) {
|
||||
addValue(EnumFrameType.valueOf(type.toUpperCase()), value, Ease.valueOf(easing.toUpperCase()));
|
||||
return this;
|
||||
}
|
||||
|
||||
public void addValue(EnumFrameType type, float value) {
|
||||
addValue(type, value, Ease.INSINE);
|
||||
}
|
||||
|
||||
public void addValue(EnumFrameType type, float value, Ease ease) {
|
||||
Value val = new Value(value, ease);
|
||||
|
||||
if (!values.containsKey(type))
|
||||
values.put(type, val);
|
||||
else
|
||||
values.replace(type, val);
|
||||
}
|
||||
|
||||
public void setEase(EnumFrameType type, Ease ease) {
|
||||
if (values.containsKey(type))
|
||||
values.get(type).easing = ease;
|
||||
}
|
||||
|
||||
public class Value {
|
||||
public float value;
|
||||
public Ease easing;
|
||||
|
||||
public Value(float value, Ease ease) {
|
||||
this.value = value;
|
||||
this.easing = ease;
|
||||
}
|
||||
|
||||
public Value(float value) {
|
||||
this(value, Ease.INOUTSINE);
|
||||
}
|
||||
|
||||
public NBTTagCompound writeToNBT() {
|
||||
NBTTagCompound cmpd = new NBTTagCompound();
|
||||
cmpd.setFloat("value", value);
|
||||
cmpd.setString("easing", easing.toString());
|
||||
return cmpd;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -173,7 +173,7 @@ public class Magic implements IMagic {
|
||||
|
||||
@Override
|
||||
public float getInteraction(int magicID, float value) {
|
||||
if(hasInteraction(magicID))
|
||||
if (hasInteraction(magicID))
|
||||
return interactions.get(magicID);
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
@@ -18,7 +18,8 @@ public class MagicCycle implements IMagicCycle {
|
||||
public EnumDiagramLayout layout = EnumDiagramLayout.CIRCULAR;
|
||||
public HashMap<Integer, MagicAssociation> associations = new HashMap<>();
|
||||
|
||||
public MagicCycle(){}
|
||||
public MagicCycle() {
|
||||
}
|
||||
|
||||
public void readNBT(NBTTagCompound compound) {
|
||||
id = compound.getInteger("ID");
|
||||
@@ -93,7 +94,7 @@ public class MagicCycle implements IMagicCycle {
|
||||
|
||||
@Override
|
||||
public void setLayoutType(int layout) {
|
||||
if(layout < 0 || layout > EnumDiagramLayout.values().length - 1)
|
||||
if (layout < 0 || layout > EnumDiagramLayout.values().length - 1)
|
||||
return;
|
||||
this.layout = EnumDiagramLayout.values()[layout];
|
||||
}
|
||||
|
||||
@@ -0,0 +1,61 @@
|
||||
package noppes.npcs.util;
|
||||
|
||||
public enum Ease {
|
||||
LINEAR(0, f -> f, "ease."), CONSTANT(1, f -> 0f, "ease."),
|
||||
INSINE(2, Easing::inSine, "ease."), OUTSINE(3, Easing::outSine, "ease."), INOUTSINE(4, Easing::inOutSine, "ease."),
|
||||
INCUBIC(5, Easing::inCubic, "ease."), OUTCUBIC(6, Easing::outCubic, "ease."), INOUTCUBIC(7, Easing::inOutCubic, "ease."),
|
||||
INQUAD(8, Easing::inQuad, "ease."), OUTQUAD(9, Easing::outQuad, "ease."), INOUTQUAD(10, Easing::inOutQuad, "ease."),
|
||||
INQUART(11, Easing::inQuart, "ease."), OUTQUART(12, Easing::outQuart, "ease."), INOUTQUART(13, Easing::inOutQuart, "ease."),
|
||||
INQUINT(14, Easing::inQuint, "ease."), OUTQUINT(15, Easing::outQuint, "ease."), INOUTQUINT(16, Easing::inOutQuint, "ease."),
|
||||
INEXPO(17, Easing::inExpo, "ease."), OUTEXPO(18, Easing::outExpo, "ease."), INOUTEXPO(19, Easing::inOutExpo, "ease."),
|
||||
INCIRC(20, Easing::inCirc, "ease."), OUTCIRC(21, Easing::outCirc, "ease."), INOUTCIRC(22, Easing::inOutCirc, "ease."),
|
||||
INBACK(23, Easing::inBack, "ease."), OUTBACK(24, Easing::outBack, "ease."), INOUTBACK(25, Easing::inOutBack, "ease."),
|
||||
INELASTIC(26, Easing::inElastic, "ease."), OUTELASTIC(27, Easing::outElastic, "ease."), INOUTELASTIC(28, Easing::inOutElastic, "ease."),
|
||||
INBOUNCE(29, Easing::inBounce, "ease."), OUTBOUNCE(30, Easing::outBack, "ease."), INOUTBOUNCE(31, Easing::inOutBounce, "ease.");
|
||||
|
||||
final byte id;
|
||||
private final EasingFunction impl;
|
||||
public String lang;
|
||||
|
||||
Ease(byte id, EasingFunction impl, String lang) {
|
||||
this.id = id;
|
||||
this.impl = impl;
|
||||
}
|
||||
|
||||
Ease(int id, EasingFunction impl, String lang) {
|
||||
this((byte) id, impl, "ease.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply the easing
|
||||
*
|
||||
* @param f float between 0 and 1
|
||||
* @return ease(f)
|
||||
*/
|
||||
public float apply(float f) {
|
||||
return impl.invoke(f);
|
||||
}
|
||||
|
||||
//To be able to send these as bytes instead of String names.
|
||||
public static Ease getEase(byte b) {
|
||||
for (Ease ease : Ease.values()) {
|
||||
if (ease.id == b) return ease;
|
||||
}
|
||||
return LINEAR;
|
||||
}
|
||||
|
||||
public static Ease getFromOld(byte smoothing) {
|
||||
switch (smoothing) {
|
||||
case 1:
|
||||
return LINEAR;
|
||||
case 2:
|
||||
return CONSTANT;
|
||||
default:
|
||||
return INSINE;
|
||||
}
|
||||
}
|
||||
|
||||
private interface EasingFunction {
|
||||
float invoke(float f);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
package noppes.npcs.util;
|
||||
|
||||
public class Easing {
|
||||
|
||||
/**
|
||||
* Easing functions from easings.net
|
||||
* All function have a string codename
|
||||
* EasingFromString
|
||||
* <p>
|
||||
* All function needs an input between 0 and 1
|
||||
* <p>
|
||||
* Just use {@link Ease#apply(float)}
|
||||
*/
|
||||
public static float easingFromEnum(Ease type, float f) {
|
||||
return type != null ? type.apply(f) : f;
|
||||
}
|
||||
|
||||
public static Ease easeFromString(String string) {
|
||||
try {
|
||||
if (string.equals("step"))
|
||||
return Ease.CONSTANT;
|
||||
if (string.substring(0, 4).equalsIgnoreCase("EASE")) {
|
||||
string = string.substring(4);
|
||||
}
|
||||
return Ease.valueOf(string.toUpperCase());
|
||||
} catch (Exception exception) {
|
||||
//Main.log(Level.ERROR, "Ease name unknown: \"" + string + "\" using linear", true);
|
||||
//Main.log(Level.WARN, exception.toString());
|
||||
return Ease.LINEAR;
|
||||
}
|
||||
}
|
||||
|
||||
private static final float c1 = 1.70158f;
|
||||
private static final float c2 = c1 * 1.525f;
|
||||
private static final float c3 = c1 + 1;
|
||||
private static final float c4 = (float) ((2 * Math.PI) / 3);
|
||||
private static final float c5 = (float) ((2 * Math.PI) / 4.5);
|
||||
private static final float n1 = 7.5625f;
|
||||
private static final float d1 = 2.75f;
|
||||
|
||||
public static float inSine(float f) {
|
||||
return (float) (1 - Math.cos((f * Math.PI) / 2));
|
||||
}
|
||||
|
||||
public static float outSine(float f) {
|
||||
return (float) (Math.sin((f * Math.PI) / 2));
|
||||
}
|
||||
|
||||
public static float inOutSine(float f) {
|
||||
return (float) (-(Math.cos(Math.PI * f) - 1) / 2);
|
||||
}
|
||||
|
||||
public static float inCubic(float f) {
|
||||
return f * f * f;
|
||||
}
|
||||
|
||||
public static float outCubic(float f) {
|
||||
return (float) (1 - Math.pow(1 - f, 3));
|
||||
}
|
||||
|
||||
public static float inOutCubic(float x) {
|
||||
return (float) ((x < 0.5) ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2);
|
||||
}
|
||||
|
||||
public static float inQuad(float x) {
|
||||
return (x * x);
|
||||
}
|
||||
|
||||
public static float outQuad(float x) {
|
||||
return (1 - (1 - x) * (1 - x));
|
||||
}
|
||||
|
||||
public static float inOutQuad(float x) {
|
||||
return (float) ((x < 0.5) ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2);
|
||||
}
|
||||
|
||||
public static float inQuart(float x) {
|
||||
return (x * x * x * x);
|
||||
}
|
||||
|
||||
public static float outQuart(float x) {
|
||||
return (float) (1 - Math.pow(1 - x, 4));
|
||||
}
|
||||
|
||||
public static float inOutQuart(float x) {
|
||||
return (float) (x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2);
|
||||
}
|
||||
|
||||
public static float inQuint(float x) {
|
||||
return (x * x * x * x * x);
|
||||
}
|
||||
|
||||
public static float outQuint(float x) {
|
||||
return (float) (1 - Math.pow(1 - x, 5));
|
||||
}
|
||||
|
||||
public static float inOutQuint(float x) {
|
||||
return (float) (x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2);
|
||||
}
|
||||
|
||||
public static float inExpo(float x) {
|
||||
return (float) (x == 0 ? 0 : Math.pow(2, 10 * x - 10));
|
||||
}
|
||||
|
||||
public static float outExpo(float x) {
|
||||
return (float) (x == 1 ? 1 : 1 - Math.pow(2, -10 * x));
|
||||
}
|
||||
|
||||
public static float inOutExpo(float x) {
|
||||
return (float) (x == 0 ? 0 : x == 1 ? 1 : x < 0.5 ? Math.pow(2, 20 * x - 10) / 2 : (2 - Math.pow(2, -20 * x + 10)) / 2);
|
||||
}
|
||||
|
||||
public static float inCirc(float x) {
|
||||
return (float) (1 - Math.sqrt(1 - Math.pow(x, 2)));
|
||||
}
|
||||
|
||||
public static float outCirc(float x) {
|
||||
return (float) (Math.sqrt(1 - Math.pow(x - 1, 2)));
|
||||
}
|
||||
|
||||
public static float inOutCirc(float x) {
|
||||
return (float) (x < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2);
|
||||
}
|
||||
|
||||
public static float inBack(float x) {
|
||||
return c3 * x * x * x - c1 * x * x;
|
||||
}
|
||||
|
||||
public static float outBack(float x) {
|
||||
return (float) (1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2));
|
||||
}
|
||||
|
||||
public static float inOutBack(float x) {
|
||||
return (float) (x < 0.5 ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2 : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2);
|
||||
}
|
||||
|
||||
public static float inElastic(float x) {
|
||||
return (float) (x == 0 ? 0 : x == 1 ? 1 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4));
|
||||
}
|
||||
|
||||
public static float outElastic(float x) {
|
||||
return (float) (x == 0 ? 0 : x == 1 ? 1 : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1);
|
||||
}
|
||||
|
||||
public static float inOutElastic(float x) {
|
||||
return (float) (x == 0 ? 0 : x == 1 ? 1 : x < 0.5 ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2 : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 + 1);
|
||||
}
|
||||
|
||||
public static float inBounce(float x) {
|
||||
return 1 - outBounce(1 - x);
|
||||
}
|
||||
|
||||
public static float outBounce(float x) {
|
||||
if (x < 1 / d1) {
|
||||
return n1 * x * x;
|
||||
} else if (x < 2 / d1) {
|
||||
return (float) (n1 * (x -= 1.5 / d1) * x + 0.75);
|
||||
} else if (x < 2.5 / d1) {
|
||||
return (float) (n1 * (x -= 2.25 / d1) * x + 0.9375);
|
||||
} else {
|
||||
return (float) (n1 * (x -= 2.625 / d1) * x + 0.984375);
|
||||
}
|
||||
}
|
||||
|
||||
public static float inOutBounce(float x) {
|
||||
return x < 0.5 ? (1 - outBounce(1 - 2 * x)) / 2 : (1 + outBounce(2 * x - 1)) / 2;
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,14 @@
|
||||
package noppes.npcs.util;
|
||||
|
||||
public class ValueUtil {
|
||||
public static float lerp(float start, float end, float delta) {
|
||||
return start + delta * (end - start);
|
||||
}
|
||||
|
||||
public static double lerp(double start, double end, double delta) {
|
||||
return start + delta * (end - start);
|
||||
}
|
||||
|
||||
public static float clamp(float given, float min, float max) {
|
||||
if (given < min)
|
||||
return min;
|
||||
|
||||
Reference in new issue
Block a user