- Выберите загрузчик игры
- Fabric
Мои первые темы тут, сливаю вам TargetESP на ексос с кристаликами с анимкой, гпт кодик оуда, жду del )
Маркеры кто хочет удалите(у меня их 6 штук), кину фул код таргет есп, видео ->
Маркеры кто хочет удалите(у меня их 6 штук), кину фул код таргет есп, видео ->
Пожалуйста, авторизуйтесь для просмотра ссылки.
КОД TargetESP:
package ru.levin.modules.render;
import com.mojang.blaze3d.platform.GlStateManager;
import com.mojang.blaze3d.systems.RenderSystem;
import net.minecraft.client.gl.ShaderProgramKeys;
import net.minecraft.client.render.*;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.RotationAxis;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import ru.levin.events.Event;
import ru.levin.events.impl.render.EventRender3D;
import ru.levin.manager.IMinecraft;
import ru.levin.manager.Manager;
import ru.levin.modules.Function;
import ru.levin.modules.FunctionAnnotation;
import ru.levin.modules.Type;
import ru.levin.modules.setting.ModeSetting;
import ru.levin.modules.setting.SliderSetting;
import ru.levin.util.animations.Animation;
import ru.levin.util.animations.impl.EaseInOutQuad;
import ru.levin.util.color.ColorUtil;
import ru.levin.util.math.RayTraceUtil;
import ru.levin.util.render.RenderUtil;
import ru.levin.util.render.providers.ResourceProvider;
import java.awt.*;
import static ru.levin.util.math.MathUtil.interpolate;
import static ru.levin.util.math.MathUtil.interpolateFloat;
import static ru.levin.util.render.RenderUtil.*;
@SuppressWarnings("All")
@FunctionAnnotation(name = "TargetESP", desc = "Красивый указатель на вашем противнике", type = Type.Render)
public class TargetESP extends Function {
private final ModeSetting mode = new ModeSetting("Мод", "Маркер", "Маркер","Маркер2", "Маркер3", "Маркер4", "Маркер5","Маркер6","Призраки", "Кружок", "Кристаллы");
private final SliderSetting crystalCount = new SliderSetting("Количество кристаллов", 10f, 6f, 20f, 1f, () -> mode.is("Кристаллы"));
private final SliderSetting crystalSpeed = new SliderSetting("Скорость вращения", 1.5f, 0.5f, 4f, 0.1f, () -> mode.is("Кристаллы"));
private final SliderSetting crystalRadius = new SliderSetting("Радиус", 1.2f, 0.8f, 2.5f, 0.1f, () -> mode.is("Кристаллы"));
private final SliderSetting crystalSize = new SliderSetting("Размер кристаллов", 0.2f, 0.1f, 0.4f, 0.02f, () -> mode.is("Кристаллы"));
private final SliderSetting pulseSpeed = new SliderSetting("Скорость пульсации", 2f, 0.5f, 5f, 0.5f, () -> mode.is("Кристаллы"));
private final float[] SCALE_CACHE = new float[101];
private final EaseInOutQuad animation = new EaseInOutQuad(800, 1);
private Entity lastTarget = null;
private double scale = 0.0D;
private long crystalStartTime = 0;
public TargetESP() {
addSettings(mode, crystalCount, crystalSpeed, crystalRadius, crystalSize, pulseSpeed);
for (int i = 0; i <= 100; i++) SCALE_CACHE[i] = Math.max(0.28f * (i / 100f), 0.2f);
}
@Override
public void onEvent(Event event) {
if (!(event instanceof EventRender3D renderEvent)) return;
Entity currentTarget = Manager.FUNCTION_MANAGER.attackAura.target;
if (currentTarget != null && (lastTarget == null || !lastTarget.equals(currentTarget))) {
animation.setDirection(net.minecraft.util.math.Direction.AxisDirection.POSITIVE);
crystalStartTime = System.currentTimeMillis();
} else if (currentTarget == null) {
animation.setDirection(net.minecraft.util.math.Direction.AxisDirection.NEGATIVE);
}
lastTarget = currentTarget;
if (currentTarget != null) {
if (mode.is("Призраки")) {
renderGhosts(14, 8, 1.8f, 3f, currentTarget);
} else if (mode.is("Кружок")) {
cicle(currentTarget, renderEvent.getMatrixStack(), renderEvent.getDeltatick().getTickDelta(true));
} else if (mode.is("Кристаллы")) {
renderCrystals(currentTarget, renderEvent.getMatrixStack(), renderEvent.getDeltatick().getTickDelta(true));
} else {
render(currentTarget);
}
}
}
@Override
public void onDisable() {
super.onDisable();
}
private void renderCrystals(Entity target, MatrixStack matrices, float tickDelta) {
if (target == null) return;
Vec3d camPos = mc.gameRenderer.getCamera().getPos();
double x = MathHelper.lerp(tickDelta, target.prevX, target.getX()) - camPos.x;
double y = MathHelper.lerp(tickDelta, target.prevY, target.getY()) - camPos.y;
double z = MathHelper.lerp(tickDelta, target.prevZ, target.getZ()) - camPos.z;
float speed = crystalSpeed.get().floatValue();
float radius = crystalRadius.get().floatValue();
float size = crystalSize.get().floatValue();
float pulse = pulseSpeed.get().floatValue();
float anim = (float) animation.getOutput();
double time = (System.currentTimeMillis() - crystalStartTime) / 1000.0 * speed;
RenderSystem.disableCull();
RenderSystem.disableDepthTest();
RenderUtil.enableRender(
GlStateManager.SrcFactor.SRC_ALPHA,
GlStateManager.DstFactor.ONE
);
RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);
Matrix4f matrix = matrices.peek().getPositionMatrix();
BufferBuilder buffer = IMinecraft.tessellator()
.begin(VertexFormat.DrawMode.TRIANGLES, VertexFormats.POSITION_COLOR);
int baseColor = ColorUtil.getColorStyle(0);
float r = ((baseColor >> 16) & 255) / 255f;
float g = ((baseColor >> 8) & 255) / 255f;
float b = (baseColor & 255) / 255f;
int crystals = crystalCount.get().intValue();
float height = target.getHeight();
float pulseScale = 0.8f + (float) Math.sin(System.currentTimeMillis() / 200.0 * pulse) * 0.2f;
float finalSize = size * anim * pulseScale;
for (int i = 0; i < crystals; i++) {
float progress = (float) i / crystals;
double spiralOffset = progress * Math.PI * 4;
double angle1 = spiralOffset + time;
double angle2 = spiralOffset + time + Math.PI;
double yPos = y + progress * height;
double x1 = x + Math.cos(angle1) * radius * anim;
double z1 = z + Math.sin(angle1) * radius * anim;
double x2 = x + Math.cos(angle2) * radius * anim;
double z2 = z + Math.sin(angle2) * radius * anim;
float glow = 0.6f + (float) Math.sin(System.currentTimeMillis() / 250.0 + i) * 0.4f;
float rGlow = r * glow;
float gGlow = g * glow;
float bGlow = b * glow;
drawCrystalEnhanced(buffer, matrix, x1, yPos, z1, finalSize, rGlow, gGlow, bGlow);
drawCrystalEnhanced(buffer, matrix, x2, yPos, z2, finalSize, rGlow, gGlow, bGlow);
}
RenderUtil.render3D.endBuilding(buffer);
RenderSystem.enableDepthTest();
RenderSystem.enableCull();
RenderUtil.disableRender();
}
private void drawCrystalEnhanced(BufferBuilder buffer, Matrix4f matrix,
double x, double y, double z,
float size,
float r, float g, float b) {
float cx = (float) x;
float cy = (float) y;
float cz = (float) z;
// Вершины кристалла
float top = cy + size * 1.2f; // верхняя точка
float bottom = cy - size * 0.8f; // нижняя точка
float mid = cy; // середина
float right = cx + size; // правая грань
float left = cx - size; // левая грань
float front = cz + size; // передняя грань
float back = cz - size; // задняя грань
float rightMid = cx + size * 0.6f; // правая середина
float leftMid = cx - size * 0.6f; // левая середина
float frontMid = cz + size * 0.6f; // передняя середина
float backMid = cz - size * 0.6f; // задняя середина
// Основной цвет (яркий)
float alphaMain = 0.95f;
// Цвет для рёбер (более яркий)
float alphaEdge = 1.0f;
// ==================== ВЕРХНЯЯ ПИРАМИДА ====================
// Грань передняя-правая
tri(buffer, matrix, cx, top, cz, right, mid, front, cx, mid, front, r, g, b, alphaMain);
tri(buffer, matrix, cx, top, cz, cx, mid, front, right, mid, front, r, g, b, alphaMain);
// Грань передняя-левая
tri(buffer, matrix, cx, top, cz, left, mid, front, cx, mid, front, r, g, b, alphaMain);
tri(buffer, matrix, cx, top, cz, cx, mid, front, left, mid, front, r, g, b, alphaMain);
// Грань задняя-правая
tri(buffer, matrix, cx, top, cz, right, mid, back, cx, mid, back, r, g, b, alphaMain);
tri(buffer, matrix, cx, top, cz, cx, mid, back, right, mid, back, r, g, b, alphaMain);
// Грань задняя-левая
tri(buffer, matrix, cx, top, cz, left, mid, back, cx, mid, back, r, g, b, alphaMain);
tri(buffer, matrix, cx, top, cz, cx, mid, back, left, mid, back, r, g, b, alphaMain);
// ==================== НИЖНЯЯ ПИРАМИДА ====================
tri(buffer, matrix, cx, bottom, cz, right, mid, front, cx, mid, front, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, cx, mid, front, right, mid, front, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, left, mid, front, cx, mid, front, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, cx, mid, front, left, mid, front, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, right, mid, back, cx, mid, back, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, cx, mid, back, right, mid, back, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, left, mid, back, cx, mid, back, r, g, b, alphaMain * 0.8f);
tri(buffer, matrix, cx, bottom, cz, cx, mid, back, left, mid, back, r, g, b, alphaMain * 0.8f);
// ==================== ЦЕНТРАЛЬНОЕ КОЛЬЦО (для объёма) ====================
// Горизонтальные рёбра
drawEdge(buffer, matrix, right, mid, front, right, mid, back, r, g, b, alphaEdge);
drawEdge(buffer, matrix, left, mid, front, left, mid, back, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, front, left, mid, front, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, back, left, mid, back, r, g, b, alphaEdge);
// Вертикальные рёбра
drawEdge(buffer, matrix, right, mid, front, right, top, front, r, g, b, alphaEdge);
drawEdge(buffer, matrix, left, mid, front, left, top, front, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, back, right, top, back, r, g, b, alphaEdge);
drawEdge(buffer, matrix, left, mid, back, left, top, back, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, front, right, bottom, front, r, g, b, alphaEdge * 0.7f);
drawEdge(buffer, matrix, left, mid, front, left, bottom, front, r, g, b, alphaEdge * 0.7f);
drawEdge(buffer, matrix, right, mid, back, right, bottom, back, r, g, b, alphaEdge * 0.7f);
drawEdge(buffer, matrix, left, mid, back, left, bottom, back, r, g, b, alphaEdge * 0.7f);
// Диагональные рёбра (для красоты)
drawEdge(buffer, matrix, right, mid, front, cx, top, cz, r, g, b, alphaEdge);
drawEdge(buffer, matrix, left, mid, front, cx, top, cz, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, back, cx, top, cz, r, g, b, alphaEdge);
drawEdge(buffer, matrix, left, mid, back, cx, top, cz, r, g, b, alphaEdge);
drawEdge(buffer, matrix, right, mid, front, cx, bottom, cz, r, g, b, alphaEdge * 0.6f);
drawEdge(buffer, matrix, left, mid, front, cx, bottom, cz, r, g, b, alphaEdge * 0.6f);
drawEdge(buffer, matrix, right, mid, back, cx, bottom, cz, r, g, b, alphaEdge * 0.6f);
drawEdge(buffer, matrix, left, mid, back, cx, bottom, cz, r, g, b, alphaEdge * 0.6f);
}
private void drawEdge(BufferBuilder buffer, Matrix4f matrix,
float x1, float y1, float z1,
float x2, float y2, float z2,
float r, float g, float b, float alpha) {
// Рисуем линию как очень тонкий прямоугольник (имитация ребра)
float thickness = 0.03f;
// Основная линия
buffer.vertex(matrix, x1, y1, z1).color(r, g, b, alpha);
buffer.vertex(matrix, x2, y2, z2).color(r, g, b, alpha);
buffer.vertex(matrix, x2, y2, z2).color(r, g, b, alpha);
// Смещённая линия для объёма
buffer.vertex(matrix, x1 + thickness, y1 + thickness, z1 + thickness).color(r, g, b, alpha * 0.5f);
buffer.vertex(matrix, x2 + thickness, y2 + thickness, z2 + thickness).color(r, g, b, alpha * 0.5f);
buffer.vertex(matrix, x2 + thickness, y2 + thickness, z2 + thickness).color(r, g, b, alpha * 0.5f);
}
private void tri(BufferBuilder buffer, Matrix4f matrix,
float x1, float y1, float z1,
float x2, float y2, float z2,
float x3, float y3, float z3,
float r, float g, float b, float alpha) {
buffer.vertex(matrix, x1, y1, z1).color(r, g, b, alpha);
buffer.vertex(matrix, x2, y2, z2).color(r, g, b, alpha * 0.7f);
buffer.vertex(matrix, x3, y3, z3).color(r, g, b, alpha * 0.7f);
}
public void renderGhosts(int espLength, int factor, float shaking, float amplitude, Entity target) {
if (target == null) return;
Camera camera = mc.gameRenderer.getCamera();
if (camera == null) return;
float hitProgress = RayTraceUtil.getHitProgress(target);
float delta = mc.getRenderTickCounter().getTickDelta(true);
Vec3d camPos = camera.getPos();
double tX = interpolate(target.prevX, target.getX(), delta) - camPos.x;
double tY = interpolate(target.prevY, target.getY(), delta) - camPos.y;
double tZ = interpolate(target.prevZ, target.getZ(), delta) - camPos.z;
float age = interpolateFloat(target.age - 1, target.age, delta);
boolean canSee = mc.player.canSee(target);
RenderUtil.enableRender(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
RenderSystem.setShaderTexture(0, ResourceProvider.firefly);
RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);
if (canSee) {
RenderSystem.enableDepthTest();
RenderSystem.depthMask(false);
} else {
RenderSystem.disableDepthTest();
}
BufferBuilder buffer = IMinecraft.tessellator().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);
float pitch = camera.getPitch();
float yaw = camera.getYaw();
float ghostAlpha = (float) animation.getOutput();
for (int j = 0; j < 3; j++) {
for (int i = 0; i <= espLength; i++) {
float offset = (float) i / espLength;
double radians = Math.toRadians(((i / 1.5f + age) * factor + j * 120) % (factor * 360));
double sinQuad = Math.sin(Math.toRadians(age * 2.5f + i * (j + 1)) * amplitude) / shaking;
MatrixStack matrices = new MatrixStack();
matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(pitch));
matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(yaw + 180f));
matrices.translate(tX + Math.cos(radians) * target.getWidth(), tY + 1 + sinQuad, tZ + Math.sin(radians) * target.getWidth());
matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(-yaw));
matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(pitch));
Matrix4f matrix = matrices.peek().getPositionMatrix();
int baseColor;
if (hitProgress > 0) {
baseColor = Color.RED.getRGB();
} else {
baseColor = ColorUtil.getColorStyle((int) (180 * offset));
}
int color = applyOpacity(baseColor, offset * ghostAlpha);
float scale = SCALE_CACHE[Math.min((int)(offset * 100), 100)];
buffer.vertex(matrix, -scale, scale, 0).texture(0f, 1f).color(color);
buffer.vertex(matrix, scale, scale, 0).texture(1f, 1f).color(color);
buffer.vertex(matrix, scale, -scale, 0).texture(1f, 0).color(color);
buffer.vertex(matrix, -scale, -scale, 0).texture(0f, 0).color(color);
}
}
RenderUtil.render3D.endBuilding(buffer);
if (canSee) {
RenderSystem.depthMask(true);
RenderSystem.disableDepthTest();
} else {
RenderSystem.enableDepthTest();
}
RenderSystem.disableBlend();
}
private void cicle(Entity target, MatrixStack matrices, float tickDelta) {
Vec3d camPos = mc.gameRenderer.getCamera().getPos();
double x = MathHelper.lerp(tickDelta, target.lastRenderX, target.getX()) - camPos.x;
double z = MathHelper.lerp(tickDelta, target.lastRenderZ, target.getZ()) - camPos.z;
double y = MathHelper.lerp(tickDelta, target.lastRenderY, target.getY()) - camPos.y + Math.min(Math.sin(System.currentTimeMillis() / 400.0) + 0.95, target.getHeight());
disableDepth();
RenderUtil.enableRender(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);
Matrix4f matrix = matrices.peek().getPositionMatrix();
BufferBuilder buffer = IMinecraft.tessellator().begin(VertexFormat.DrawMode.TRIANGLE_STRIP, VertexFormats.POSITION_COLOR);
int baseColor = ColorUtil.getColorStyle(360);
float r = ((baseColor >> 16) & 0xFF) / 255f;
float g = ((baseColor >> 8) & 0xFF) / 255f;
float b = (baseColor & 0xFF) / 255f;
float alpha = (float) animation.getOutput();
float radius = target.getWidth() * 0.8f;
for (float i = 0; i <= Math.PI * 2 + (Math.PI * 5 / 100); i += Math.PI * 5 / 100) {
double vecX = x + radius * Math.cos(i);
double vecZ = z + radius * Math.sin(i);
buffer.vertex(matrix, (float) vecX, (float) (y - Math.cos(System.currentTimeMillis() / 400.0) / 2), (float) vecZ).color(r, g, b, 0.01f * alpha);
buffer.vertex(matrix, (float) vecX, (float) y, (float) vecZ).color(r, g, b, 1f * alpha);
}
RenderUtil.render3D.endBuilding(buffer);
endRender();
}
private static void disableDepth() {
RenderSystem.disableDepthTest();
RenderSystem.disableCull();
}
private static void endRender() {
RenderUtil.disableRender();
RenderSystem.enableDepthTest();
RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA);
RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
}
private void render(Entity target) {
Camera camera = mc.gameRenderer.getCamera();
if (camera == null) return;
double scale = animation.getOutput();
if (scale == 0.0) return;
float delta = mc.getRenderTickCounter().getTickDelta(true);
float hitProgress = RayTraceUtil.getHitProgress(target);
Vec3d camPos = camera.getPos();
double tX = interpolate(target.prevX, target.getX(), delta) - camPos.x;
double tY = interpolate(target.prevY, target.getY(), delta) - camPos.y;
double tZ = interpolate(target.prevZ, target.getZ(), delta) - camPos.z;
MatrixStack matrices = setupMatrices(camera, target, delta, tX, tY, tZ);
Matrix4f matrix = matrices.peek().getPositionMatrix();
disableDepth();
RenderUtil.enableRender(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
RenderSystem.bindTexture(0);
switch (mode.get()) {
case "Маркер" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker);
case "Маркер2" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker2);
case "Маркер3" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker3);
case "Маркер4" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker4);
case "Маркер5" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker5);
case "Маркер6" -> RenderSystem.setShaderTexture(0, ResourceProvider.marker6);
default -> RenderSystem.setShaderTexture(0, ResourceProvider.marker);
}
RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);
float alpha = (float) animation.getOutput();
int[] baseColors = hitProgress > 0 ?
new int[]{Color.RED.getRGB(), ColorUtil.getColorStyle(0), Color.RED.getRGB(), ColorUtil.getColorStyle(270)} :
new int[]{ColorUtil.getColorStyle(90), ColorUtil.getColorStyle(0), ColorUtil.getColorStyle(180), ColorUtil.getColorStyle(270)};
drawQuad(matrix, applyAlphaToColors(baseColors, alpha));
endRender();
}
private MatrixStack setupMatrices(Camera camera, Entity target, float delta, double tX, double tY, double tZ) {
MatrixStack matrices = new MatrixStack();
float pitch = camera.getPitch();
float yaw = camera.getYaw();
matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(pitch));
matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(yaw + 180f));
matrices.translate(tX, tY + target.getEyeHeight(target.getPose()) / 2f, tZ);
matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(-yaw));
matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(pitch));
float interpolatedAngle = interpolateFloat(1f, 1f, delta);
matrices.multiply(RotationAxis.POSITIVE_Z.rotationDegrees(interpolatedAngle));
float radians = (float) Math.toRadians(System.currentTimeMillis() % 3600 / 5f);
matrices.multiplyPositionMatrix(new Matrix4f().rotate(radians, 0, 0, 1));
matrices.translate(-0.75, -0.75, -0.01);
return matrices;
}
private int[] applyAlphaToColors(int[] colors, float alpha) {
int[] out = new int[colors.length];
for (int i = 0; i < colors.length; i++) {
Color color = new Color(colors[i]);
out[i] = new Color(color.getRed(), color.getGreen(), color.getBlue(), (int) (color.getAlpha() * alpha)).getRGB();
}
return out;
}
private void drawQuad(Matrix4f matrix, int[] colors) {
BufferBuilder buffer = IMinecraft.tessellator().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);
buffer.vertex(matrix,0,1.5f,0).texture(0f,1f).color(colors[0]);
buffer.vertex(matrix,1.5f,1.5f,0).texture(1f,1f).color(colors[1]);
buffer.vertex(matrix,1.5f,0,0).texture(1f,0).color(colors[2]);
buffer.vertex(matrix,0,0,0).texture(0f,0).color(colors[3]);
RenderUtil.render3D.endBuilding(buffer);
}
}
