Neler yeni

w2s

  • Konuyu Başlatan Konuyu Başlatan hitdelay
  • Başlangıç tarihi Başlangıç tarihi
hitdelay

hitdelay

Platinum Üye
Katılım
14 Eyl 2025
Mesajlar
139
Beğeniler
32
İletişim
yaptığım esp çalışıyor fakat boxlar kaymış durumda, nerede hata yapmış olabilirim

Linkleri görebilmek için kayıt olmanız gerekmektedir


namespace {
bool worldToScreen(glm::vec3 pointInWorld, glm::vec2& screen, float* modelView, float* projection, float* viewPort)
{
glm::vec4 clipSpacePos;
clipSpacePos.x = pointInWorld.x * modelView[0] + pointInWorld.y * modelView[4] + pointInWorld.z * modelView[8] + modelView[12];
clipSpacePos.y = pointInWorld.x * modelView[1] + pointInWorld.y * modelView[5] + pointInWorld.z * modelView[9] + modelView[13];
clipSpacePos.z = pointInWorld.x * modelView[2] + pointInWorld.y * modelView[6] + pointInWorld.z * modelView[10] + modelView[14];
clipSpacePos.w = pointInWorld.x * modelView[3] + pointInWorld.y * modelView[7] + pointInWorld.z * modelView[11] + modelView[15];

glm::vec4 projPos;
projPos.x = clipSpacePos.x * projection[0] + clipSpacePos.y * projection[4] + clipSpacePos.z * projection[8] + clipSpacePos.w * projection[12];
projPos.y = clipSpacePos.x * projection[1] + clipSpacePos.y * projection[5] + clipSpacePos.z * projection[9] + clipSpacePos.w * projection[13];
projPos.z = clipSpacePos.x * projection[2] + clipSpacePos.y * projection[6] + clipSpacePos.z * projection[10] + clipSpacePos.w * projection[14];
projPos.w = clipSpacePos.x * projection[3] + clipSpacePos.y * projection[7] + clipSpacePos.z * projection[11] + clipSpacePos.w * projection[15];

if (std::abs(projPos.w) < 0.0001f)
return false;

glm::vec3 ndcSpacePos = glm::vec3(projPos.x / projPos.w, projPos.y / projPos.w, projPos.z / projPos.w);

if (ndcSpacePos.z < -10.0f || ndcSpacePos.z > 10.0f)
return false;

if (ndcSpacePos.x < -10.0f || ndcSpacePos.x > 10.0f || ndcSpacePos.y < -10.0f || ndcSpacePos.y > 10.0f)
return false;

screen.x = ((ndcSpacePos.x + 1.0f) / 2.0f) * viewPort[2] + viewPort[0];
screen.y = ((1.0f - ndcSpacePos.y) / 2.0f) * viewPort[3] + viewPort[1];

return true;
}

void getViewport(float* viewport, ::cache& cache)
{
maps::Window window = cache.instance.getWindow();
if (window)
{
int width = window.getScaledWidth();
int height = window.getScaledHeight();
if (width > 0 && height > 0)
{
viewport[0] = 0.0f;
viewport[1] = 0.0f;
viewport[2] = (float)width;
viewport[3] = (float)height;
return;
}
}

try {
int viewportArray[4] = { 0, 0, 1920, 1080 };
glGetIntegerv(GL_VIEWPORT, viewportArray);
viewport[0] = (float)viewportArray[0];
viewport[1] = (float)viewportArray[1];
viewport[2] = (float)viewportArray[2];
viewport[3] = (float)viewportArray[3];
}
catch (...) {
viewport[0] = 0.0f;
viewport[1] = 0.0f;
viewport[2] = 1920.0f;
viewport[3] = 1080.0f;
}

if (viewport[2] <= 0 || viewport[3] <= 0 || viewport[2] > 10000 || viewport[3] > 10000)
{
viewport[0] = 0.0f;
viewport[1] = 0.0f;
viewport[2] = 1920.0f;
viewport[3] = 1080.0f;
}
}

void getMatrices(float* modelView, float* projection, float* viewport, ::cache& cache)
{
float yawRad, pitchRad;
maths::vector3d camPos;

maps::Camera cam{ nullptr };
try {
if (cache.entityRenderDispatcher) {
cam = cache.entityRenderDispatcher.camera.get();
}
}
catch (...) {
cam = maps::Camera{ nullptr };
}

if (cam)
{
float camPitch = cam.getPitch();
float camYaw = cam.getYaw();
maps::Vec3d camPosVec = cam.getPos();
camPos = camPosVec.to_vector3d();

yawRad = (camYaw + 180.0f) * 3.14159f / 180.0f;
pitchRad = camPitch * 3.14159f / 180.0f;
}
else
{
float tickDelta = 0.0f;

maths::angles playerRot = cache.player.get_prev_angles() +
(cache.player.get_angles() - cache.player.get_prev_angles()) * tickDelta;

camPos = cache.player.get_prev_position() +
(cache.player.get_position() - cache.player.get_prev_position()) * tickDelta;

float eyeHeight = cache.player.getEyeHeight(cache.player.getPose());
camPos.y += eyeHeight;

yawRad = playerRot.yaw * 3.14159f / 180.0f;
pitchRad = playerRot.pitch * 3.14159f / 180.0f;
}

float cosYaw = cosf(yawRad);
float sinYaw = sinf(yawRad);
float cosPitch = cosf(pitchRad);
float sinPitch = sinf(pitchRad);

float forwardX = -sinYaw * cosPitch;
float forwardY = -sinPitch;
float forwardZ = cosYaw * cosPitch;

float worldUpX = 0.0f;
float worldUpY = 1.0f;
float worldUpZ = 0.0f;

float rightX = forwardY * worldUpZ - forwardZ * worldUpY;
float rightY = forwardZ * worldUpX - forwardX * worldUpZ;
float rightZ = forwardX * worldUpY - forwardY * worldUpX;

rightX = -rightX;
rightY = -rightY;
rightZ = -rightZ;

float rightLen = sqrtf(rightX * rightX + rightY * rightY + rightZ * rightZ);
if (rightLen > 0.0001f) {
rightX /= rightLen;
rightY /= rightLen;
rightZ /= rightLen;
} else {
rightX = 1.0f;
rightY = 0.0f;
rightZ = 0.0f;
}

float upX = forwardY * rightZ - forwardZ * rightY;
float upY = forwardZ * rightX - forwardX * rightZ;
float upZ = forwardX * rightY - forwardY * rightX;

float upLen = sqrtf(upX * upX + upY * upY + upZ * upZ);
if (upLen > 0.0001f) {
upX /= upLen;
upY /= upLen;
upZ /= upLen;
} else {
upX = 0.0f;
upY = 1.0f;
upZ = 0.0f;
}

modelView[0] = rightX;
modelView[1] = rightY;
modelView[2] = rightZ;
modelView[3] = 0.0f;

modelView[4] = upX;
modelView[5] = upY;
modelView[6] = upZ;
modelView[7] = 0.0f;

modelView[8] = -forwardX;
modelView[9] = -forwardY;
modelView[10] = -forwardZ;
modelView[11] = 0.0f;

modelView[12] = -(camPos.x * rightX + camPos.y * rightY + camPos.z * rightZ);
modelView[13] = -(camPos.x * upX + camPos.y * upY + camPos.z * upZ);
modelView[14] = -(camPos.x * (-forwardX) + camPos.y * (-forwardY) + camPos.z * (-forwardZ));
modelView[15] = 1.0f;

float fov = 70.0f;
if (viewport[2] <= 0 || viewport[3] <= 0)
{
for (int i = 0; i < 16; i++)
projection = (i % 5 == 0) ? 1.0f : 0.0f;
return;
}

float aspect = viewport[2] / viewport[3];
float nearPlane = 0.1f;
float farPlane = 1000.0f;

float f = 1.0f / tanf(fov * 0.5f * 3.14159f / 180.0f);

for (int i = 0; i < 16; i++)
projection = 0.0f;

projection[0] = f / aspect;
projection[5] = f;
projection[10] = (farPlane + nearPlane) / (nearPlane - farPlane);
projection[11] = -1.0f;
projection[14] = (2.0f * farPlane * nearPlane) / (nearPlane - farPlane);
}
}
 
screenmode degıs belkı duzelır
 
Java: 
#include <glm/glm.hpp>
#include <cmath>
#include <algorithm>

namespace {
    bool worldToScreen(glm::vec3 pointInWorld, glm::vec2& screen, float* modelView, float* projection, float* viewPort)
    {
        glm::vec4 clipSpacePos;
        clipSpacePos.x = pointInWorld.x * modelView[0] + pointInWorld.y * modelView[4] + pointInWorld.z * modelView[8] + modelView[12];
        clipSpacePos.y = pointInWorld.x * modelView[1] + pointInWorld.y * modelView[5] + pointInWorld.z * modelView[9] + modelView[13];
        clipSpacePos.z = pointInWorld.x * modelView[2] + pointInWorld.y * modelView[6] + pointInWorld.z * modelView[10] + modelView[14];
        clipSpacePos.w = pointInWorld.x * modelView[3] + pointInWorld.y * modelView[7] + pointInWorld.z * modelView[11] + modelView[15];

        glm::vec4 projPos;
        projPos.x = clipSpacePos.x * projection[0] + clipSpacePos.y * projection[4] + clipSpacePos.z * projection[8] + clipSpacePos.w * projection[12];
        projPos.y = clipSpacePos.x * projection[1] + clipSpacePos.y * projection[5] + clipSpacePos.z * projection[9] + clipSpacePos.w * projection[13];
        projPos.z = clipSpacePos.x * projection[2] + clipSpacePos.y * projection[6] + clipSpacePos.z * projection[10] + clipSpacePos.w * projection[14];
        projPos.w = clipSpacePos.x * projection[3] + clipSpacePos.y * projection[7] + clipSpacePos.z * projection[11] + clipSpacePos.w * projection[15];

        if (projPos.w < 0.1f)
            return false;

        glm::vec3 ndcSpacePos = glm::vec3(projPos.x / projPos.w, projPos.y / projPos.w, projPos.z / projPos.w);

        if (ndcSpacePos.x < -1.0f || ndcSpacePos.x > 1.0f ||
            ndcSpacePos.y < -1.0f || ndcSpacePos.y > 1.0f ||
            ndcSpacePos.z < -1.0f || ndcSpacePos.z > 1.0f)
            return false;

        screen.x = ((ndcSpacePos.x + 1.0f) / 2.0f) * viewPort[2] + viewPort[0];
        screen.y = ((1.0f - ndcSpacePos.y) / 2.0f) * viewPort[3] + viewPort[1];

        return true;
    }

    void getMatrices(float* modelView, float* projection, float* viewport, ::cache& cache)
    {
        getViewport(viewport, cache);

        float yawRad, pitchRad;
        maths::vector3d camPos;
        float tickDelta = 1.0f;

        maps::Camera cam{ nullptr };
        try {
            if (cache.entityRenderDispatcher) cam = cache.entityRenderDispatcher.camera.get();
        } catch (...) { cam = maps::Camera{ nullptr }; }

        if (cam) {
            yawRad = (cam.getYaw() + 180.0f) * 3.14159265f / 180.0f;
            pitchRad = cam.getPitch() * 3.14159265f / 180.0f;
            maps::Vec3d cv = cam.getPos();
            camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
        } else {
            maths::angles rot = cache.player.get_prev_angles() + (cache.player.get_angles() - cache.player.get_prev_angles()) * tickDelta;
            camPos = cache.player.get_prev_position() + (cache.player.get_position() - cache.player.get_prev_position()) * tickDelta;
            camPos.y += cache.player.getEyeHeight(cache.player.getPose());

            yawRad = rot.yaw * 3.14159265f / 180.0f;
            pitchRad = rot.pitch * 3.14159265f / 180.0f;
        }

        float cosYaw = cosf(yawRad), sinYaw = sinf(yawRad);
        float cosPitch = cosf(pitchRad), sinPitch = sinf(pitchRad);

        glm::vec3 forward = { -sinYaw * cosPitch, -sinPitch, cosYaw * cosPitch };
        glm::vec3 right = glm::normalize(glm::cross(forward, glm::vec3(0, 1, 0)));
        glm::vec3 up = glm::cross(right, forward);

        modelView[0] = right.x;  modelView[4] = right.y;  modelView[8] = right.z;  modelView[12] = -glm::dot(right, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[1] = up.x;     modelView[5] = up.y;     modelView[9] = up.z;     modelView[13] = -glm::dot(up, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[2] = -forward.x; modelView[6] = -forward.y; modelView[10] = -forward.z; modelView[14] = glm::dot(forward, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[3] = 0.0f;     modelView[7] = 0.0f;     modelView[11] = 0.0f;    modelView[15] = 1.0f;

        float fov = 70.0f;
        float aspect = viewport[2] / viewport[3];
        float nearP = 0.05f;
        float farP = 1000.0f;
        float f = 1.0f / tanf(fov * 0.5f * 3.14159265f / 180.0f);

        for(int i=0; i<16; i++) projection[i] = 0.0f;

        projection[0] = f / aspect;
        projection[5] = f;
        projection[10] = (farP + nearP) / (nearP - farP);
        projection[11] = -1.0f;
        projection[14] = (2.0f * farP * nearP) / (nearP - farP);
    }
}


bunu dene
 
DeccxL' Alıntı:
Java: 
#include <glm/glm.hpp>
#include <cmath>
#include <algorithm>

namespace {
    bool worldToScreen(glm::vec3 pointInWorld, glm::vec2& screen, float* modelView, float* projection, float* viewPort)
    {
        glm::vec4 clipSpacePos;
        clipSpacePos.x = pointInWorld.x * modelView[0] + pointInWorld.y * modelView[4] + pointInWorld.z * modelView[8] + modelView[12];
        clipSpacePos.y = pointInWorld.x * modelView[1] + pointInWorld.y * modelView[5] + pointInWorld.z * modelView[9] + modelView[13];
        clipSpacePos.z = pointInWorld.x * modelView[2] + pointInWorld.y * modelView[6] + pointInWorld.z * modelView[10] + modelView[14];
        clipSpacePos.w = pointInWorld.x * modelView[3] + pointInWorld.y * modelView[7] + pointInWorld.z * modelView[11] + modelView[15];

        glm::vec4 projPos;
        projPos.x = clipSpacePos.x * projection[0] + clipSpacePos.y * projection[4] + clipSpacePos.z * projection[8] + clipSpacePos.w * projection[12];
        projPos.y = clipSpacePos.x * projection[1] + clipSpacePos.y * projection[5] + clipSpacePos.z * projection[9] + clipSpacePos.w * projection[13];
        projPos.z = clipSpacePos.x * projection[2] + clipSpacePos.y * projection[6] + clipSpacePos.z * projection[10] + clipSpacePos.w * projection[14];
        projPos.w = clipSpacePos.x * projection[3] + clipSpacePos.y * projection[7] + clipSpacePos.z * projection[11] + clipSpacePos.w * projection[15];

        if (projPos.w < 0.1f)
            return false;

        glm::vec3 ndcSpacePos = glm::vec3(projPos.x / projPos.w, projPos.y / projPos.w, projPos.z / projPos.w);

        if (ndcSpacePos.x < -1.0f || ndcSpacePos.x > 1.0f ||
            ndcSpacePos.y < -1.0f || ndcSpacePos.y > 1.0f ||
            ndcSpacePos.z < -1.0f || ndcSpacePos.z > 1.0f)
            return false;

        screen.x = ((ndcSpacePos.x + 1.0f) / 2.0f) * viewPort[2] + viewPort[0];
        screen.y = ((1.0f - ndcSpacePos.y) / 2.0f) * viewPort[3] + viewPort[1];

        return true;
    }

    void getMatrices(float* modelView, float* projection, float* viewport, ::cache& cache)
    {
        getViewport(viewport, cache);

        float yawRad, pitchRad;
        maths::vector3d camPos;
        float tickDelta = 1.0f;

        maps::Camera cam{ nullptr };
        try {
            if (cache.entityRenderDispatcher) cam = cache.entityRenderDispatcher.camera.get();
        } catch (...) { cam = maps::Camera{ nullptr }; }

        if (cam) {
            yawRad = (cam.getYaw() + 180.0f) * 3.14159265f / 180.0f;
            pitchRad = cam.getPitch() * 3.14159265f / 180.0f;
            maps::Vec3d cv = cam.getPos();
            camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
        } else {
            maths::angles rot = cache.player.get_prev_angles() + (cache.player.get_angles() - cache.player.get_prev_angles()) * tickDelta;
            camPos = cache.player.get_prev_position() + (cache.player.get_position() - cache.player.get_prev_position()) * tickDelta;
            camPos.y += cache.player.getEyeHeight(cache.player.getPose());

            yawRad = rot.yaw * 3.14159265f / 180.0f;
            pitchRad = rot.pitch * 3.14159265f / 180.0f;
        }

        float cosYaw = cosf(yawRad), sinYaw = sinf(yawRad);
        float cosPitch = cosf(pitchRad), sinPitch = sinf(pitchRad);

        glm::vec3 forward = { -sinYaw * cosPitch, -sinPitch, cosYaw * cosPitch };
        glm::vec3 right = glm::normalize(glm::cross(forward, glm::vec3(0, 1, 0)));
        glm::vec3 up = glm::cross(right, forward);

        modelView[0] = right.x;  modelView[4] = right.y;  modelView[8] = right.z;  modelView[12] = -glm::dot(right, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[1] = up.x;     modelView[5] = up.y;     modelView[9] = up.z;     modelView[13] = -glm::dot(up, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[2] = -forward.x; modelView[6] = -forward.y; modelView[10] = -forward.z; modelView[14] = glm::dot(forward, glm::vec3(camPos.x, camPos.y, camPos.z));
        modelView[3] = 0.0f;     modelView[7] = 0.0f;     modelView[11] = 0.0f;    modelView[15] = 1.0f;

        float fov = 70.0f;
        float aspect = viewport[2] / viewport[3];
        float nearP = 0.05f;
        float farP = 1000.0f;
        float f = 1.0f / tanf(fov * 0.5f * 3.14159265f / 180.0f);

        for(int i=0; i<16; i++) projection[i] = 0.0f;

        projection[0] = f / aspect;
        projection[5] = f;
        projection[10] = (farP + nearP) / (nearP - farP);
        projection[11] = -1.0f;
        projection[14] = (2.0f * farP * nearP) / (nearP - farP);
    }
}


bunu dene
Genişletmek için tıkla ...
Linkleri görebilmek için kayıt olmanız gerekmektedir


biraz daha stable oldu

Linkleri görebilmek için kayıt olmanız gerekmektedir
full esp kodu burada buna bakıp tekrar yapmayı denermisin
 
hitdelay' Alıntı:
Linkleri görebilmek için kayıt olmanız gerekmektedir


biraz daha stable oldu

Linkleri görebilmek için kayıt olmanız gerekmektedir
full esp kodu burada buna bakıp tekrar yapmayı denermisin
Genişletmek için tıkla ...
Java: 
#include <imgui/imgui.h>
#include "../modules.hpp"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/ext/matrix_projection.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "../imgui/imgui_impl_opengl3_loader.h"
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <cmath>
#include "../../mappings/mappings.hpp"
#include "../../cache/cache.hpp"
#include "../../utils/maths/math.hpp"
#include "../../utils/encryption/xor.h"

using namespace glm;

namespace {
    bool worldToScreen(glm::vec3 pointInWorld, glm::vec2& screen, const glm::mat4& modelView, const glm::mat4& projection, float* viewPort)
    {
        glm::vec4 clipSpacePos = projection * modelView * glm::vec4(pointInWorld, 1.0f);

        if (clipSpacePos.w < 0.1f)
            return false;

        glm::vec3 ndcSpacePos = glm::vec3(clipSpacePos) / clipSpacePos.w;

        screen.x = ((ndcSpacePos.x + 1.0f) / 2.0f) * viewPort[2] + viewPort[0];
        screen.y = ((1.0f - ndcSpacePos.y) / 2.0f) * viewPort[3] + viewPort[1];

        return true;
    }

    void getViewport(float* viewport, ::cache& cache)
    {
        maps::Window window = cache.instance.getWindow();
        if (window)
        {
            int width = window.getScaledWidth();
            int height = window.getScaledHeight();
            if (width > 0 && height > 0)
            {
                viewport[0] = 0.0f;
                viewport[1] = 0.0f;
                viewport[2] = (float)width;
                viewport[3] = (float)height;
                return;
            }
        }
        viewport[0] = 0.0f;
        viewport[1] = 0.0f;
        viewport[2] = 2560.0f;
        viewport[3] = 1440.0f;
    }

    void getMatrices(glm::mat4& modelView, glm::mat4& projection, float* viewport, ::cache& cache)
    {
        getViewport(viewport, cache);

        float yaw, pitch;
        maths::vector3d camPos;

        maps::Camera cam{ nullptr };
        if (cache.entityRenderDispatcher) cam = cache.entityRenderDispatcher.camera.get();

        if (cam) {
            yaw = cam.getYaw();
            pitch = cam.getPitch();
            maps::Vec3d cv = cam.getPos();
            camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
        }
        else {
            maths::angles rot = cache.player.get_angles();
            camPos = cache.player.get_position();
            camPos.y += cache.player.getEyeHeight(cache.player.getPose());
            yaw = rot.yaw;
            pitch = rot.pitch;
        }

        glm::vec3 eye = glm::vec3(camPos.x, camPos.y, camPos.z);
        float yawRad = glm::radians(yaw + 90.0f);
        float pitchRad = glm::radians(-pitch);

        glm::vec3 front;
        front.x = cos(pitchRad) * cos(yawRad);
        front.y = sin(pitchRad);
        front.z = cos(pitchRad) * sin(yawRad);
        front.z *= -1.0f;

        modelView = glm::lookAt(eye, eye + front, glm::vec3(0, 1, 0));
        
        float aspect = viewport[2] / viewport[3];
        projection = glm::perspective(glm::radians(70.0f), aspect, 0.05f, 1000.0f);
    }
}

void modules::esp::run(::cache& cache)
{
    entities.clear();

    if (!cache.is_valid()) return;

    float viewport[4];
    glm::mat4 modelView, projection;
    getMatrices(modelView, projection, viewport, cache);

    auto players_array = cache.players.toArray();
    if (!players_array) return;

    auto players_vector = jni::array<maps::AbstractClientPlayerEntity>(players_array).to_vector();

    for (maps::AbstractClientPlayerEntity& target : players_vector)
    {
        if (!target || target.is_same_object(cache.player)) continue;

        maps::Vec3d lerpedPosVec = target.getLerpedPos(0.0f);
        if (!lerpedPosVec) continue;

        glm::vec3 targetPos = {(float)lerpedPosVec.x, (float)lerpedPosVec.y, (float)lerpedPosVec.z};
        float pW = target.getWidth() / 2.0f;
        float pH = target.getHeight();

        glm::vec3 corners[8] = {
            {targetPos.x - pW, targetPos.y, targetPos.z - pW},
            {targetPos.x + pW, targetPos.y, targetPos.z - pW},
            {targetPos.x - pW, targetPos.y, targetPos.z + pW},
            {targetPos.x + pW, targetPos.y, targetPos.z + pW},
            {targetPos.x - pW, targetPos.y + pH, targetPos.z - pW},
            {targetPos.x + pW, targetPos.y + pH, targetPos.z - pW},
            {targetPos.x - pW, targetPos.y + pH, targetPos.z + pW},
            {targetPos.x + pW, targetPos.y + pH, targetPos.z + pW}
        };

        float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX;
        int visibleCount = 0;

        for (int i = 0; i < 8; i++) {
            glm::vec2 screenPt;
            if (worldToScreen(corners[i], screenPt, modelView, projection, viewport)) {
                minX = (std::min)(minX, screenPt.x);
                minY = (std::min)(minY, screenPt.y);
                maxX = (std::max)(maxX, screenPt.x);
                maxY = (std::max)(maxY, screenPt.y);
                visibleCount++;
            }
        }

        if (visibleCount > 0)
        {
            ESPEntity entity;
            entity.screenBox = vec4(minX, minY, maxX, maxY);
            entity.isValid = true;

            maps::String nameStr = target.getEntityName();
            entity.name = nameStr ? nameStr.to_string() : XOR_STR("Player");
            
            entity.health = 20.0f;
            entity.maxHealth = 20.0f;

            entities.push_back(entity);
        }
    }
}

elimden geldiğince duzelttım
 
DeccxL' Alıntı:
Java: 
#include <imgui/imgui.h>
#include "../modules.hpp"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/ext/matrix_projection.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "../imgui/imgui_impl_opengl3_loader.h"
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <cmath>
#include "../../mappings/mappings.hpp"
#include "../../cache/cache.hpp"
#include "../../utils/maths/math.hpp"
#include "../../utils/encryption/xor.h"

using namespace glm;

namespace {
    bool worldToScreen(glm::vec3 pointInWorld, glm::vec2& screen, const glm::mat4& modelView, const glm::mat4& projection, float* viewPort)
    {
        glm::vec4 clipSpacePos = projection * modelView * glm::vec4(pointInWorld, 1.0f);

        if (clipSpacePos.w < 0.1f)
            return false;

        glm::vec3 ndcSpacePos = glm::vec3(clipSpacePos) / clipSpacePos.w;

        screen.x = ((ndcSpacePos.x + 1.0f) / 2.0f) * viewPort[2] + viewPort[0];
        screen.y = ((1.0f - ndcSpacePos.y) / 2.0f) * viewPort[3] + viewPort[1];

        return true;
    }

    void getViewport(float* viewport, ::cache& cache)
    {
        maps::Window window = cache.instance.getWindow();
        if (window)
        {
            int width = window.getScaledWidth();
            int height = window.getScaledHeight();
            if (width > 0 && height > 0)
            {
                viewport[0] = 0.0f;
                viewport[1] = 0.0f;
                viewport[2] = (float)width;
                viewport[3] = (float)height;
                return;
            }
        }
        viewport[0] = 0.0f;
        viewport[1] = 0.0f;
        viewport[2] = 2560.0f;
        viewport[3] = 1440.0f;
    }

    void getMatrices(glm::mat4& modelView, glm::mat4& projection, float* viewport, ::cache& cache)
    {
        getViewport(viewport, cache);

        float yaw, pitch;
        maths::vector3d camPos;

        maps::Camera cam{ nullptr };
        if (cache.entityRenderDispatcher) cam = cache.entityRenderDispatcher.camera.get();

        if (cam) {
            yaw = cam.getYaw();
            pitch = cam.getPitch();
            maps::Vec3d cv = cam.getPos();
            camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
        }
        else {
            maths::angles rot = cache.player.get_angles();
            camPos = cache.player.get_position();
            camPos.y += cache.player.getEyeHeight(cache.player.getPose());
            yaw = rot.yaw;
            pitch = rot.pitch;
        }

        glm::vec3 eye = glm::vec3(camPos.x, camPos.y, camPos.z);
        float yawRad = glm::radians(yaw + 90.0f);
        float pitchRad = glm::radians(-pitch);

        glm::vec3 front;
        front.x = cos(pitchRad) * cos(yawRad);
        front.y = sin(pitchRad);
        front.z = cos(pitchRad) * sin(yawRad);
        front.z *= -1.0f;

        modelView = glm::lookAt(eye, eye + front, glm::vec3(0, 1, 0));
       
        float aspect = viewport[2] / viewport[3];
        projection = glm::perspective(glm::radians(70.0f), aspect, 0.05f, 1000.0f);
    }
}

void modules::esp::run(::cache& cache)
{
    entities.clear();

    if (!cache.is_valid()) return;

    float viewport[4];
    glm::mat4 modelView, projection;
    getMatrices(modelView, projection, viewport, cache);

    auto players_array = cache.players.toArray();
    if (!players_array) return;

    auto players_vector = jni::array<maps::AbstractClientPlayerEntity>(players_array).to_vector();

    for (maps::AbstractClientPlayerEntity& target : players_vector)
    {
        if (!target || target.is_same_object(cache.player)) continue;

        maps::Vec3d lerpedPosVec = target.getLerpedPos(0.0f);
        if (!lerpedPosVec) continue;

        glm::vec3 targetPos = {(float)lerpedPosVec.x, (float)lerpedPosVec.y, (float)lerpedPosVec.z};
        float pW = target.getWidth() / 2.0f;
        float pH = target.getHeight();

        glm::vec3 corners[8] = {
            {targetPos.x - pW, targetPos.y, targetPos.z - pW},
            {targetPos.x + pW, targetPos.y, targetPos.z - pW},
            {targetPos.x - pW, targetPos.y, targetPos.z + pW},
            {targetPos.x + pW, targetPos.y, targetPos.z + pW},
            {targetPos.x - pW, targetPos.y + pH, targetPos.z - pW},
            {targetPos.x + pW, targetPos.y + pH, targetPos.z - pW},
            {targetPos.x - pW, targetPos.y + pH, targetPos.z + pW},
            {targetPos.x + pW, targetPos.y + pH, targetPos.z + pW}
        };

        float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX;
        int visibleCount = 0;

        for (int i = 0; i < 8; i++) {
            glm::vec2 screenPt;
            if (worldToScreen(corners[i], screenPt, modelView, projection, viewport)) {
                minX = (std::min)(minX, screenPt.x);
                minY = (std::min)(minY, screenPt.y);
                maxX = (std::max)(maxX, screenPt.x);
                maxY = (std::max)(maxY, screenPt.y);
                visibleCount++;
            }
        }

        if (visibleCount > 0)
        {
            ESPEntity entity;
            entity.screenBox = vec4(minX, minY, maxX, maxY);
            entity.isValid = true;

            maps::String nameStr = target.getEntityName();
            entity.name = nameStr ? nameStr.to_string() : XOR_STR("Player");
           
            entity.health = 20.0f;
            entity.maxHealth = 20.0f;

            entities.push_back(entity);
        }
    }
}

elimden geldiğince duzelttım
Genişletmek için tıkla ...
teşekkürler , eskisinden iyidir sonuçta
birde ben mouse çevirince falan boxlar yön değiştiriyorya onu nasıl sabit tutabilirim , eski versiyonlada rendermanager gibi birşey kullanıp playerların üstüne box çizdiriyorlardı onun yeni versiyon mappinglerinde adı falan nedir veya hala öyle birşey varmı biliyormusun?
 
hitdelay' Alıntı:
teşekkürler , eskisinden iyidir sonuçta
birde ben mouse çevirince falan boxlar yön değiştiriyorya onu nasıl sabit tutabilirim , eski versiyonlada rendermanager gibi birşey kullanıp playerların üstüne box çizdiriyorlardı onun yeni versiyon mappinglerinde adı falan nedir veya hala öyle birşey varmı biliyormusun?
Genişletmek için tıkla ...

kankam son sunu denesene çalışır hatasız bence


C++: 
#include <imgui/imgui.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <vector>
#include "../modules.hpp"
#include "../../cache/cache.hpp"
#include "../../utils/maths/math.hpp"
#include "../../utils/encryption/xor.h"

using namespace glm;

namespace {
    bool worldToScreen(const glm::vec3& worldPos, glm::vec2& screen, const glm::mat4& viewProj, const float* viewport) {
        glm::vec4 clipSpacePos = viewProj * glm::vec4(worldPos, 1.0f);

        if (clipSpacePos.w < 0.1f)
            return false;

        glm::vec3 ndc = glm::vec3(clipSpacePos) / clipSpacePos.w;

        screen.x = ((ndc.x + 1.0f) * 0.5f) * viewport[2] + viewport[0];
        screen.y = ((1.0f - ndc.y) * 0.5f) * viewport[3] + viewport[1];

        return true;
    }

    void updateViewport(float* viewport, ::cache& cache) {
        auto window = cache.instance.getWindow();
        if (window) {
            viewport[2] = static_cast<float>(window.getScaledWidth());
            viewport[3] = static_cast<float>(window.getScaledHeight());
        } else {
            viewport[2] = 1920.0f;
            viewport[3] = 1080.0f;
        }
        viewport[0] = 0.0f;
        viewport[1] = 0.0f;
    }
}

void modules::esp::run(::cache& cache) {
    entities.clear();

    if (!cache.is_valid() || !cache.player) return;

    float viewport[4];
    updateViewport(viewport, cache);

    float yaw, pitch;
    glm::vec3 camPos;

    auto cam = cache.entityRenderDispatcher ? cache.entityRenderDispatcher.camera.get() : maps::Camera{nullptr};

    if (cam) {
        yaw = cam.getYaw();
        pitch = cam.getPitch();
        auto cv = cam.getPos();
        camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
    } else {
        auto rot = cache.player.get_angles();
        auto pPos = cache.player.get_position();
        camPos = { pPos.x, pPos.y + (float)cache.player.getEyeHeight(cache.player.getPose()), pPos.z };
        yaw = rot.yaw;
        pitch = rot.pitch;
    }

    float yawRad = glm::radians(yaw + 90.0f);
    float pitchRad = glm::radians(-pitch);

    glm::vec3 front;
    front.x = cos(pitchRad) * cos(yawRad);
    front.y = sin(pitchRad);
    front.z = cos(pitchRad) * sin(yawRad);
    front.z *= -1.0f;

    glm::mat4 modelView = glm::lookAt(camPos, camPos + front, glm::vec3(0, 1, 0));
    glm::mat4 projection = glm::perspective(glm::radians(70.0f), viewport[2] / viewport[3], 0.05f, 1000.0f);
    glm::mat4 viewProj = projection * modelView;

    auto players_array = cache.players.toArray();
    if (!players_array) return;

    auto players_vector = jni::array<maps::AbstractClientPlayerEntity>(players_array).to_vector();

    for (auto& target : players_vector) {
        if (!target || target.is_same_object(cache.player)) continue;

        auto lerp = target.getLerpedPos(0.0f);
        if (!lerp) continue;

        glm::vec3 tPos = {(float)lerp.x, (float)lerp.y, (float)lerp.z};
        float w = target.getWidth() / 2.0f;
        float h = target.getHeight();

        glm::vec3 corners[8] = {
            {tPos.x - w, tPos.y,     tPos.z - w}, {tPos.x + w, tPos.y,     tPos.z - w},
            {tPos.x - w, tPos.y,     tPos.z + w}, {tPos.x + w, tPos.y,     tPos.z + w},
            {tPos.x - w, tPos.y + h, tPos.z - w}, {tPos.x + w, tPos.y + h, tPos.z - w},
            {tPos.x - w, tPos.y + h, tPos.z + w}, {tPos.x + w, tPos.y + h, tPos.z + w}
        };

        float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX;
        bool anyVisible = false;

        for (const auto& corner : corners) {
            glm::vec2 screenPt;
            if (worldToScreen(corner, screenPt, viewProj, viewport)) {
                minX = (std::min)(minX, screenPt.x);
                minY = (std::min)(minY, screenPt.y);
                maxX = (std::max)(maxX, screenPt.x);
                maxY = (std::max)(maxY, screenPt.y);
                anyVisible = true;
            }
        }

        if (anyVisible) {
            ESPEntity entity;
            entity.screenBox = glm::vec4(minX, minY, maxX, maxY);
            entity.isValid = true;

            auto nameStr = target.getEntityName();
            entity.name = nameStr ? nameStr.to_string() : XOR_STR("Player");
            
            entity.health = 20.0f;
            entity.maxHealth = 20.0f;

            entities.push_back(entity);
        }
    }
}

ayrıca hileyi test ettiğin serverin ipsi ne bide Crâck giriliyormu
 
DeccxL' Alıntı:
kankam son sunu denesene çalışır hatasız bence


C++: 
#include <imgui/imgui.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <vector>
#include "../modules.hpp"
#include "../../cache/cache.hpp"
#include "../../utils/maths/math.hpp"
#include "../../utils/encryption/xor.h"

using namespace glm;

namespace {
    bool worldToScreen(const glm::vec3& worldPos, glm::vec2& screen, const glm::mat4& viewProj, const float* viewport) {
        glm::vec4 clipSpacePos = viewProj * glm::vec4(worldPos, 1.0f);

        if (clipSpacePos.w < 0.1f)
            return false;

        glm::vec3 ndc = glm::vec3(clipSpacePos) / clipSpacePos.w;

        screen.x = ((ndc.x + 1.0f) * 0.5f) * viewport[2] + viewport[0];
        screen.y = ((1.0f - ndc.y) * 0.5f) * viewport[3] + viewport[1];

        return true;
    }

    void updateViewport(float* viewport, ::cache& cache) {
        auto window = cache.instance.getWindow();
        if (window) {
            viewport[2] = static_cast<float>(window.getScaledWidth());
            viewport[3] = static_cast<float>(window.getScaledHeight());
        } else {
            viewport[2] = 1920.0f;
            viewport[3] = 1080.0f;
        }
        viewport[0] = 0.0f;
        viewport[1] = 0.0f;
    }
}

void modules::esp::run(::cache& cache) {
    entities.clear();

    if (!cache.is_valid() || !cache.player) return;

    float viewport[4];
    updateViewport(viewport, cache);

    float yaw, pitch;
    glm::vec3 camPos;

    auto cam = cache.entityRenderDispatcher ? cache.entityRenderDispatcher.camera.get() : maps::Camera{nullptr};

    if (cam) {
        yaw = cam.getYaw();
        pitch = cam.getPitch();
        auto cv = cam.getPos();
        camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
    } else {
        auto rot = cache.player.get_angles();
        auto pPos = cache.player.get_position();
        camPos = { pPos.x, pPos.y + (float)cache.player.getEyeHeight(cache.player.getPose()), pPos.z };
        yaw = rot.yaw;
        pitch = rot.pitch;
    }

    float yawRad = glm::radians(yaw + 90.0f);
    float pitchRad = glm::radians(-pitch);

    glm::vec3 front;
    front.x = cos(pitchRad) * cos(yawRad);
    front.y = sin(pitchRad);
    front.z = cos(pitchRad) * sin(yawRad);
    front.z *= -1.0f;

    glm::mat4 modelView = glm::lookAt(camPos, camPos + front, glm::vec3(0, 1, 0));
    glm::mat4 projection = glm::perspective(glm::radians(70.0f), viewport[2] / viewport[3], 0.05f, 1000.0f);
    glm::mat4 viewProj = projection * modelView;

    auto players_array = cache.players.toArray();
    if (!players_array) return;

    auto players_vector = jni::array<maps::AbstractClientPlayerEntity>(players_array).to_vector();

    for (auto& target : players_vector) {
        if (!target || target.is_same_object(cache.player)) continue;

        auto lerp = target.getLerpedPos(0.0f);
        if (!lerp) continue;

        glm::vec3 tPos = {(float)lerp.x, (float)lerp.y, (float)lerp.z};
        float w = target.getWidth() / 2.0f;
        float h = target.getHeight();

        glm::vec3 corners[8] = {
            {tPos.x - w, tPos.y,     tPos.z - w}, {tPos.x + w, tPos.y,     tPos.z - w},
            {tPos.x - w, tPos.y,     tPos.z + w}, {tPos.x + w, tPos.y,     tPos.z + w},
            {tPos.x - w, tPos.y + h, tPos.z - w}, {tPos.x + w, tPos.y + h, tPos.z - w},
            {tPos.x - w, tPos.y + h, tPos.z + w}, {tPos.x + w, tPos.y + h, tPos.z + w}
        };

        float minX = FLT_MAX, minY = FLT_MAX, maxX = -FLT_MAX, maxY = -FLT_MAX;
        bool anyVisible = false;

        for (const auto& corner : corners) {
            glm::vec2 screenPt;
            if (worldToScreen(corner, screenPt, viewProj, viewport)) {
                minX = (std::min)(minX, screenPt.x);
                minY = (std::min)(minY, screenPt.y);
                maxX = (std::max)(maxX, screenPt.x);
                maxY = (std::max)(maxY, screenPt.y);
                anyVisible = true;
            }
        }

        if (anyVisible) {
            ESPEntity entity;
            entity.screenBox = glm::vec4(minX, minY, maxX, maxY);
            entity.isValid = true;

            auto nameStr = target.getEntityName();
            entity.name = nameStr ? nameStr.to_string() : XOR_STR("Player");
           
            entity.health = 20.0f;
            entity.maxHealth = 20.0f;

            entities.push_back(entity);
        }
    }
}

ayrıca hileyi test ettiğin serverin ipsi ne bide Crâck giriliyormu
Genişletmek için tıkla ...
eskisi ile aynıı
latest-test.ccbluex.net ip bu crackli girmiyor sanırım birde girersede /server latest çek yeni sunucularda olmak için
 
C++: 
#include <imgui/imgui.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <algorithm>
#include <vector>
#include "../modules.hpp"
#include "../../cache/cache.hpp"
#include "../../utils/maths/math.hpp"
#include "../../utils/encryption/xor.h"

using namespace glm;

namespace {
    bool worldToScreen(const glm::vec3& worldPos, glm::vec2& screen, const glm::mat4& projection, const glm::mat4& modelView, const float* viewport) {
        glm::vec4 clipSpacePos = projection * modelView * glm::vec4(worldPos, 1.0f);

        if (clipSpacePos.w < 0.1f)
            return false;

        glm::vec3 ndc = glm::vec3(clipSpacePos) / clipSpacePos.w;

        screen.x = ((ndc.x + 1.0f) * 0.5f) * viewport[2] + viewport[0];
        screen.y = ((1.0f - ndc.y) * 0.5f) * viewport[3] + viewport[1];

        return true;
    }

    void updateViewport(float* viewport, ::cache& cache) {
        auto window = cache.instance.getWindow();
        if (window) {
            viewport[2] = (float)window.getScaledWidth();
            viewport[3] = (float)window.getScaledHeight();
        } else {
            viewport[2] = 1920.0f;
            viewport[3] = 1080.0f;
        }
        viewport[0] = 0.0f;
        viewport[1] = 0.0f;
    }
}

void modules::esp::run(::cache& cache) {
    entities.clear();

    if (!cache.is_valid() || !cache.player) return;

    float viewport[4];
    updateViewport(viewport, cache);

    float yaw, pitch;
    glm::vec3 camPos;

    auto cam = cache.entityRenderDispatcher ? cache.entityRenderDispatcher.camera.get() : maps::Camera{nullptr};

    if (cam) {
        yaw = cam.getYaw();
        pitch = cam.getPitch();
        auto cv = cam.getPos();
        camPos = { (float)cv.x, (float)cv.y, (float)cv.z };
    } else {
        auto rot = cache.player.get_angles();
        auto pPos = cache.player.get_position();
        camPos = { (float)pPos.x, (float)(pPos.y + cache.player.getEyeHeight(cache.player.getPose())), (float)pPos.z };
        yaw = rot.yaw;
        pitch = rot.pitch;
    }

    float yawRad = glm::radians(yaw + 90.0f);
    float pitchRad = glm::radians(-pitch);

    glm::vec3 front;
    front.x = cos(pitchRad) * cos(yawRad);
    front.y = sin(pitchRad);
    front.z = cos(pitchRad) * sin(yawRad);
    front.z *= -1.0f;

    glm::mat4 modelView = glm::lookAt(camPos, camPos + front, glm::vec3(0, 1, 0));
    glm::mat4 projection = glm::perspective(glm::radians(70.0f), viewport[2] / viewport[3], 0.05f, 1000.0f);

    auto players_array = cache.players.toArray();
    if (!players_array) return;

    auto players_vector = jni::array<maps::AbstractClientPlayerEntity>(players_array).to_vector();

    for (auto& target : players_vector) {
        if (!target || target.is_same_object(cache.player)) continue;

        auto lerp = target.getLerpedPos(0.0f);
        if (!lerp) continue;

        glm::vec3 tPos = {(float)lerp.x, (float)lerp.y, (float)lerp.z};
        float w = target.getWidth() * 0.5f;
        float h = target.getHeight();

        glm::vec3 corners[8] = {
            {tPos.x - w, tPos.y,     tPos.z - w}, {tPos.x + w, tPos.y,     tPos.z - w},
            {tPos.x - w, tPos.y,     tPos.z + w}, {tPos.x + w, tPos.y,     tPos.z + w},
            {tPos.x - w, tPos.y + h, tPos.z - w}, {tPos.x + w, tPos.y + h, tPos.z - w},
            {tPos.x - w, tPos.y + h, tPos.z + w}, {tPos.x + w, tPos.y + h, tPos.z + w}
        };

        float minX = 10000.0f, minY = 10000.0f, maxX = -10000.0f, maxY = -10000.0f;
        bool anyVisible = false;

        for (const auto& corner : corners) {
            glm::vec2 screenPt;
            if (worldToScreen(corner, screenPt, projection, modelView, viewport)) {
                minX = (std::min)(minX, screenPt.x);
                minY = (std::min)(minY, screenPt.y);
                maxX = (std::max)(maxX, screenPt.x);
                maxY = (std::max)(maxY, screenPt.y);
                anyVisible = true;
            }
        }

        if (anyVisible) {
            ESPEntity entity;
            entity.screenBox = glm::vec4(minX, minY, maxX, maxY);
            entity.isValid = true;

            auto nameStr = target.getEntityName();
            entity.name = nameStr ? nameStr.to_string() : XOR_STR("Player");
            
            entity.health = 20.0f;
            entity.maxHealth = 20.0f;

            entities.push_back(entity);
        }
    }
}

buda olmazsa aiye sormak lazım hocam
 
Cevap yazmak için giriş yap yada kayıt ol.

Şuanda konuyu görüntüleyen kullanıcılar

Toplam: 1 (Kullanıcı: 0, ziyaretçi: 1)
Community platform by XenForo® © 2010-2026 XenForo Ltd.
Cheatglobal.com 2019 yılında kurulmuş yazılımcı topluluğudur. Bünyesinde bir çok profesyonel yazılımcı bulundurmaktadır. Paylaşılan yazılımların cheatglobal.com ile bir alakası olmayıp, cheatglobal.com yasalara göre sadece "yer sağlayıcı" olarak hizmet etmektedir. 5651 kanunda belirtildiği gibi "Yer sağlayıcının yer sağladığı içeriği kontrol etme veya hukuka aykırı bir faaliyetin söz konusu olup olmadığını araştırmakla yükümlü değildir." Ayriyetten aynı maddenin devamında “yer sağlayıcının, yer sağladığı hukuka aykırı içeriğin kanunen belirli suçları içermesi halinde yer sağlayıcının haberdar edilmesi hâlinde bu içeriği yayından çıkarmakla yükümlüdür.” sözleri yer almaktadır. Eğer ürününüzün yada programınızın sitemiz aracılığıyla kötüye kullanıldığını düşünüyorsanız lütfen "İletişim" sekmesinden şirketinizin resmi elektronik adresinden veya avukatınız aracılığı ile gerekli müracaatı yapınız. Yapmış olduğunuz istekler yoğunluğa göre 3 iş günü içerisinde incelenip haklı bulunmanız neticesinde hak sahibinin belirttiği kötüye kullanım olan konu 7 iş günü içerisinde sitemizden kaldırılacaktır. Sitede bir çok oyun için yazılmış hile ve yardımcı araçlar bulabilir, programlama dersleri izleyebilir, ilginizi çeken içerikleri paylaşabilir ya da bilgisayar ile ilgili, hayatınızdaki herhangi bir olayla ilgili görüş yada yardım talep edebilirsiniz. Cheatglobal.com kökleri Dreamfancy ile beraber çok uzun yıllara dayanmaktadır. Cheatglobal.com oyunlardaki zengin yada fakir ayrımcılığını kaldırmak için uzun yıllar hizmet vermekte ve vermeye de devam edicektir.
Geri
Üst Alt