Подписывайтесь на наш Telegram и не пропускайте важные новости! Перейти
Что нового?

Визуальная часть Cube3d RockStar skid World

Snegopad
Начинающий
Snegopad
Начинающий
Статус
Оффлайн
Регистрация
30 Ноя 2025
Сообщения
11
Реакции
0
Выберите загрузчик игры
  1. Fabric
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
 

Вложения

  • bloom.png
    bloom.png
    272.3 KB · Просмотры: 104
Snegopad написал(а):
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
Нажмите для раскрытия...
+rep da
 
нахуй ты продублировал пнг? она есть уже в
particles/glow
Snegopad написал(а):
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
Нажмите для раскрытия...
Snegopad написал(а):
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
Нажмите для раскрытия...
+я один отличий не вижу???
 
Snegopad написал(а):
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
Нажмите для раскрытия...
1768671274293.png
сгладить лесенки и норм
 
Snegopad написал(а):
База EvaWare 1.21.4
ss -
Сори за качество просто лень было качать капкут


Java:
Expand Collapse Copy 
package sweetie.evaware.client.features.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.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;
import org.joml.Quaternionf;
import sweetie.evaware.api.event.Listener;
import sweetie.evaware.api.event.EventListener;
import sweetie.evaware.api.event.events.player.other.UpdateEvent;
import sweetie.evaware.api.event.events.render.Render3DEvent;
import sweetie.evaware.api.module.Category;
import sweetie.evaware.api.module.Module;
import sweetie.evaware.api.module.ModuleRegister;
import sweetie.evaware.api.module.setting.ColorSetting;
import sweetie.evaware.api.utils.math.MathUtil;
import sweetie.evaware.api.utils.math.TimerUtil;
import sweetie.evaware.api.system.files.FileUtil;

import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

@ModuleRegister(name = "World", category = Category.RENDER)
public class WorldModule extends Module {
private static final WorldModule instance = new WorldModule();
    public static WorldModule getInstance() { return instance; }

private final List<Particle> particles = new ArrayList<>();
    private final ColorSetting color = new ColorSetting("Color").value(new Color(255, 255, 255));

    public WorldModule() {
addSettings(color);
    }

@Override
    public void onEvent() {
EventListener updateEvent = UpdateEvent.getInstance().subscribe(new Listener<>(event -> {
onTick();
        }));

        EventListener render3DEvent = Render3DEvent.getInstance().subscribe(new Listener<>(event -> {
onRender(event);
        }));

        addEvents(updateEvent, render3DEvent);
    }

private void onRender(Render3DEvent.Render3DEventData event) {
if (mc.player == null || mc.world == null) return;

        MatrixStack ms = event.matrixStack();
        Camera camera = mc.gameRenderer.getCamera();
        Vec3d cameraPos = camera.getPos();

        ms.push();
        RenderSystem.enableBlend();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);

        RenderSystem.setShaderTexture(0, FileUtil.getImage("target/bloom"));
        RenderSystem.setShader(ShaderProgramKeys.POSITION_TEX_COLOR);

        BufferBuilder builder = Tessellator.getInstance().begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE_COLOR);

        for (Particle particle : particles) {
Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            float bigSize = 4.0f * particle.size;

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(camera.getRotation());

            int bloomColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            drawImage(ms, builder, -bigSize / 2.0f, -bigSize / 2.0f, bigSize, bigSize, bloomColor);

            ms.pop();
        }

BuiltBuffer builtBloom = builder.endNullable();
        if (builtBloom != null) {
BufferRenderer.drawWithGlobalProgram(builtBloom);
        }

RenderSystem.depthMask(true);
        RenderSystem.setShaderTexture(0, 0);
        RenderSystem.disableBlend();
        RenderSystem.enableCull();
        RenderSystem.disableDepthTest();
        ms.pop();

        RenderSystem.enableBlend();
        RenderSystem.disableDepthTest();
        RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE);
        RenderSystem.enableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.depthMask(false);
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);

        BufferBuilder linesBuffer = Tessellator.getInstance().begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);

        for (Particle particle : particles) {
particle.updateAlpha();

            Vec3d pos = getInterpolatedPos(particle.prev, particle.pos, event.partialTicks());
            Vec3d rot = getInterpolatedPos(particle.prevRot, particle.rotate, event.partialTicks());

            ms.push();
            ms.translate(pos.x - cameraPos.x, pos.y - cameraPos.y, pos.z - cameraPos.z);
            ms.multiply(new Quaternionf().rotationXYZ((float) rot.x, (float) rot.y, (float) rot.z));
            ms.scale(particle.size, particle.size, particle.size);

            int diagonalColor = withAlpha(color.getValue(), particle.alpha * 0.4f);
            int outlineColor = withAlpha(color.getValue(), particle.alpha * 0.8f);

            renderBoxInternalDiagonals(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), diagonalColor);
            renderOutlinedBox(ms, linesBuffer, new Box(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5), outlineColor);

            ms.pop();
        }

BuiltBuffer builtLinesBuffer = linesBuffer.endNullable();
        if (builtLinesBuffer != null) {
BufferRenderer.drawWithGlobalProgram(builtLinesBuffer);
        }

RenderSystem.depthMask(true);
        RenderSystem.defaultBlendFunc();
        RenderSystem.enableCull();
        RenderSystem.enableDepthTest();
        RenderSystem.disableBlend();
    }

private void onTick() {
if (mc.player == null || mc.world == null) return;

        particles.removeIf(particle -> particle.alpha <= 0.0f && particle.timer.getElapsedTime() >= particle.liveTicks);

        for (Particle particle : particles) {
particle.tick();
        }

if (particles.size() < 100) {
particles.add(new Particle(
mc.player.getPos().add(
MathUtil.randomInRange(-20.0, 20.0),
                            MathUtil.randomInRange(0.0, 5.0),
                            MathUtil.randomInRange(-20.0, 20.0)
),
                    Vec3d.ZERO,
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(0.0, 2.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    new Vec3d(
MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0),
                            MathUtil.randomInRange(-1.0, 1.0)
),
                    (long) MathUtil.randomInRange(1500.0, 4500.0),
                    MathUtil.randomInRange(0.1f, 0.3f)
));
        }
    }

private Vec3d getInterpolatedPos(Vec3d prev, Vec3d current, float delta) {
 return new Vec3d(
prev.x + (current.x - prev.x) * delta,
                prev.y + (current.y - prev.y) * delta,
                prev.z + (current.z - prev.z) * delta
);
    }

private void drawImage(MatrixStack ms, BufferBuilder builder, float x, float y, float w, float h, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, x, y + h, 0).texture(0, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y + h, 0).texture(1, 1).color(r, g, b, a);
        builder.vertex(m, x + w, y, 0).texture(1, 0).color(r, g, b, a);
        builder.vertex(m, x, y, 0).texture(0, 0).color(r, g, b, a);
    }

private void renderBoxInternalDiagonals(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
        builder.vertex(m, (float) box.maxX, (float) box.minY, (float) box.maxZ).color(r, g, b, a);
        builder.vertex(m, (float) box.minX, (float) box.maxY, (float) box.minZ).color(r, g, b, a);
    }

private void renderOutlinedBox(MatrixStack ms, BufferBuilder builder, Box box, int color) {
float r = ((color >> 16) & 0xFF) / 255f;
        float g = ((color >> 8) & 0xFF) / 255f;
        float b = (color & 0xFF) / 255f;
        float a = ((color >> 24) & 0xFF) / 255f;
        Matrix4f m = ms.peek().getPositionMatrix();

        float x1 = (float) box.minX, y1 = (float) box.minY, z1 = (float) box.minZ;
        float x2 = (float) box.maxX, y2 = (float) box.maxY, z2 = (float) box.maxZ;

        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x1, y1, z1).color(r, g, b, a);
        builder.vertex(m, x1, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z1).color(r, g, b, a);
        builder.vertex(m, x2, y2, z1).color(r, g, b, a);
        builder.vertex(m, x2, y1, z2).color(r, g, b, a);
        builder.vertex(m, x2, y2, z2).color(r, g, b, a);
        builder.vertex(m, x1, y1, z2).color(r, g, b, a);
        builder.vertex(m, x1, y2, z2).color(r, g, b, a);
    }

private int withAlpha(Color baseColor, float alpha) {
int a = Math.max(0, Math.min(255, (int) (alpha * 255)));
        return (a << 24) | (baseColor.getRed() << 16) | (baseColor.getGreen() << 8) | baseColor.getBlue();
    }

private static class Particle {
Vec3d prev;
        Vec3d prevRot;
        Vec3d pos;
        Vec3d rotate;
        Vec3d motion;
        Vec3d rotateMotion;
        final long liveTicks;
        final long fadeInTime = 500;
        final long fadeOutTime = 500;
        float size;
        final TimerUtil timer = new TimerUtil();
        float alpha = 0.0f;

        Particle(Vec3d pos, Vec3d rotate, Vec3d motion, Vec3d rotateMotion, long liveTicks, float size) {
this.pos = pos;
            this.rotate = rotate;
            this.motion = motion.multiply(0.04);
            this.rotateMotion = rotateMotion.multiply(0.04);
            this.liveTicks = liveTicks;
            this.size = size;
            this.prevRot = rotate;
            this.prev = pos;
            this.timer.reset();
        }

void tick() {
this.prev = this.pos;
            this.prevRot = this.rotate;
            this.pos = this.pos.add(this.motion);
            this.rotate = this.rotate.add(this.rotateMotion);
            this.motion = this.motion.multiply(0.98);
            this.rotateMotion = this.rotateMotion.multiply(0.98);
        }

void updateAlpha() {
long elapsed = timer.getElapsedTime();

            if (elapsed < fadeInTime) {
alpha = Math.min(1.0f, elapsed / (float) fadeInTime);
            } else if (elapsed > liveTicks - fadeOutTime) {
long timeLeft = liveTicks - elapsed;
                alpha = Math.max(0, timeLeft / (float) fadeOutTime);
            } else {
alpha = 1.0f;
            }
        }
    }
}
Нажмите для раскрытия...
мясо +rep
 

Похожие темы

mazelock
Визуальная часть 3д партиклы как в рокстаре base evaware v3
2 3
Ответы
42
Просмотры
2K
egorgumosiegorgumosi
E
Sanch3zs
Визуальная часть Zenith Recode | Кристаллы, скид рокстара
2 3
Ответы
42
Просмотры
3K
PolniyPed
P
sexycat
Прочее Liquid Glass Renderer | Zenith Recode
2
Ответы
20
Просмотры
4K
forteo
forteo
Yung Treezy Crazy
Визуальная часть Target esp zenith recod
2
Ответы
20
Просмотры
3K
Anabiozqqe
Anabiozqqe
FR1ZIT
Визуальная часть Zenith Recode | Target Esp Гирлянда 3D
2
Ответы
37
Просмотры
2K
qobu
Q
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Назад
Сверху Снизу