Jump to content
  • Treść wyszukiwania
    Search In
    • More options...
    Find results that contain...
    Find results in...
  • Sign Up
Password for all archives on our forum: 123

source onetap.su v1 watermark, binds, spectators list

Source code

Recommended Posts

L9o89td.gif.96d43a61175b5aaf10df213d6b9bddf7.gifxs6mT6i.png.8624144917b0e2a2d4cf8264125fc9fc.pngB4psZgy.gif.32edcf0c3ade70f427a6eaa2768961c8.gif

source by sove

setting up the font

create_font(font::tahoma_8, XOR("Tahoma"), 12, 100, NONE);

hud.cpp

#include "hud.h"

void c_hud::update_accent_color() {
    const auto freq = 1.f; /// Gradient speed (curr: 100%)

    const auto real_time = interfaces::globals->m_real_time * freq;

    switch (m_style.m_col_mode) {
        case STATIC: {
            m_style.m_col_accent[0] = m_style.m_col_fallback;
            m_style.m_col_accent[1] = m_style.m_col_fallback;

            break;
        }
        case RAINBOW: {
            /// Looks like pasted from fatality lua, but it isn't (no lie)
            const auto r = math::floor(math::sin(real_time + 0.f) * 127.f + 128.f);
            const auto g = math::floor(math::sin(real_time + 2.f) * 127.f + 128.f);
            const auto b = math::floor(math::sin(real_time + 4.f) * 127.f + 128.f);

            m_style.m_col_accent[0] = color(r, g, b, 200);
            m_style.m_col_accent[1] = color(r, g, b, 200);
            break;
        }
        case GRADIENT: {
            /// Looks like pasted from fatality lua, but it isn't (no lie)
            const auto r = math::floor(math::sin(real_time + 0.f) * 127.f + 128.f);
            const auto g = math::floor(math::sin(real_time + 2.f) * 127.f + 128.f);
            const auto b = math::floor(math::sin(real_time + 4.f) * 127.f + 128.f);

            m_style.m_col_accent[0] = color(b, g, r, 200);
            m_style.m_col_accent[1] = color(r, g, b, 200);
            break;
        }
    };
}

void c_hud::draw_watermark(uint8_t options) {
    /// Watermark text string stuff.
    auto text = string("figma.com");

    if (options & USER) {
        text += " | sove";
    }

    const auto net_channel = interfaces::engine->get_net_channel_info();

    /// Are net channel ptr is valid and we in game.
    if (net_channel && interfaces::engine->is_in_game()) {
        if (options & INCOMING) {
            /// Get incoming latency in milliseconds.
            const auto incoming_latency = std::max(0, static_cast<int>(std::round(net_channel->get_avg_latency(FLOW_INCOMING) * 1000.f)));

            text += " | incoming: " + std::to_string(incoming_latency) + "ms";
        }
        if (options & OUTGOING) {
            /// Get outgoing latency in milliseconds.
            const auto outgoing_latency = std::max(0, static_cast<int>(std::round(net_channel->get_avg_latency(FLOW_OUTGOING) * 1000.f)));

            text += " | outgoing: " + std::to_string(outgoing_latency) + "ms";
        }
    }
    if (options & TIME) {
        /// Get time.
        auto time = std::time(nullptr);   
        std::ostringstream time_ss;
        /// Format: 12:59:09.
        time_ss << std::put_time(std::localtime(&time), " | %H:%M:%S");

        text += time_ss.str().data();
    }

    /// Render stuff.

    /// Measures of string, that's will be rendered.
    const auto text_size = render::measure_text(font::tahoma_8, text);

    /// We ain't about this white text on yellow bg life.
    auto text_color = color(255, 255, 255);
    auto text_color_inverted = false; /// Useful for text shadow render.
    {
        const auto hue = m_style.m_col_accent[0].hue();

        if ((hue >= 0.2f) && (hue <= 0.6f)) {
            text_color = color(0, 0, 0);
            text_color_inverted = true;
        }
    }

    /// Background measures.
    const auto pos = vec2(render::m_screen_size.x - m_style.m_watermark_margins.x - (m_style.m_watermark_paddings.x * 2) - text_size.x, m_style.m_watermark_margins.y);
    const auto size = text_size + m_style.m_watermark_paddings * 2;

    const auto text_pos = pos + m_style.m_watermark_paddings;

    render::gradient(pos.x, pos.y, size.x, size.y, m_style.m_col_accent[0], m_style.m_col_accent[1]);

    /// Text shadow (if text isn't black).
    if (!text_color_inverted)
        render::text(text_pos.x + 1, text_pos.y + 1, font::tahoma_8, text, color(0, 0, 0, 200));
        /// 1 - shadow offset.

    render::text(text_pos.x, text_pos.y, font::tahoma_8, text, text_color);
}

void c_hud::draw_frame(const vec2& pos, const wstring& name, const std::vector<wstring>& first_column, const std::vector<wstring>& second_column) {
    /// Header label.
    auto text = name + L" (" + std::to_wstring(first_column.size()) + L")";

    /// Aayyaya initialization of variable, y value will be adjusted to all elements size.
            auto size = vec2(220, 0);

            auto line_pos = vec2(pos.x + m_style.m_pad_header_sides, pos.y + m_style.m_pad_header_top);
    const auto line_size = vec2(size.x - (m_style.m_pad_header_sides * 2), 4);

    const auto text_pos = vec2(line_pos.x + (line_size.x * 0.5f), line_pos.y);
    const auto text_size = render::measure_text(font::tahoma_8, text.c_str());

    const auto pad_text_line = text_size.y + 2;

    /// Adding little bit padding.
    line_pos.y += pad_text_line;

            auto base_pos = vec2(line_pos.x, line_pos.y + line_size.y + m_style.m_pad_header_bottom);
            auto base_size = vec2(line_size.x, (m_style.m_line_height * first_column.size()) + (m_style.m_pad_base * 2));

    /// Adjusted height of our crap.
    size.y += text_size.y + pad_text_line + line_size.y + m_style.m_pad_header_bottom + base_size.y;

    /// Outline measures.
    const auto outline_pos = pos - m_style.m_outline_size;
    const auto outline_size = size + (m_style.m_outline_size * 2);

    /// Outline.
    render::rect(outline_pos.x, outline_pos.y, outline_size.x, outline_size.y, m_style.m_col_outline);

    /// Beside outline.
    {
        /// Outer.
        render::outline(outline_pos.x - 1, outline_pos.y - 1, outline_size.x + 2, outline_size.y + 2, m_style.m_col_outer_outline);

        /// Inner.
        render::outline(outline_pos.x, outline_pos.y, outline_size.x, outline_size.y, m_style.m_col_inner_outline);
    }

    /// Inside outline.
    {
        const auto this_pos = outline_pos + m_style.m_outline_size;
        const auto this_size = outline_size - (m_style.m_outline_size * 2);

        /// Outer (also closet to base background, so render like it is).
        render::rect(this_pos.x, this_pos.y, this_size.x, this_size.y, m_style.m_col_outer_outline);

        /// Inner.
        render::outline(this_pos.x + 1, this_pos.y + 1, this_size.x - 2, this_size.y - 2, m_style.m_col_inner_outline);
    }

    /// Header.
    {
        /// Label shadow.
        render::text(text_pos.x + 1, text_pos.y + 1, font::tahoma_8, text.c_str(), color(0, 0, 0, 200), ALIGN_CENTER_X);

        /// Label.
        render::text(text_pos.x, text_pos.y, font::tahoma_8, text.c_str(), color(255, 255, 255, 200), ALIGN_CENTER_X);

        /// Base accent line.
        render::gradient(line_pos.x, line_pos.y, line_size.x, line_size.y, m_style.m_col_accent[0], m_style.m_col_accent[1]);

        /// Line shade.
        render::rect(line_pos.x, line_pos.y, line_size.x, line_size.y * 0.5f, color(255, 255, 255, 20));
    }

    /// Base.
    {
        /// Background.
        render::rect(base_pos.x, base_pos.y, base_size.x, base_size.y, m_style.m_col_base);

        /// Outer outline.
        render::outline(base_pos.x, base_pos.y, base_size.x, base_size.y, m_style.m_col_base_outer_outline);

        /// Inner outline.
        render::outline(base_pos.x + 1, base_pos.y + 1, base_size.x - 2, base_size.y - 2, m_style.m_col_base_inner_outline);

        /// Left column.
        if (!first_column.empty()) {
            /// C'mon, let's go.
            auto builder_pos = base_pos + m_style.m_pad_base;

            /// Ampersand imeni Platina300.
            for (const auto& item : first_column) {
                render::text(builder_pos.x, builder_pos.y, font::tahoma_8, item.c_str(), color(255, 255, 255, 200));

                builder_pos.y += m_style.m_line_height;
            }
        }

        /// Right column.
        if (!second_column.empty()) {
            /// C'mon, let's go.
            auto builder_pos = base_pos + m_style.m_pad_base;

            /// Right aligning text.
            builder_pos.x += base_size.x - (m_style.m_pad_base * 2);

            /// Ampersand imeni Platina300.
            for (const auto& item : second_column) {
                const auto text_size = render::measure_text(font::tahoma_8, item.c_str());

                /// Right aligning text.
                render::text(builder_pos.x - text_size.x, builder_pos.y, font::tahoma_8, item.c_str(), color(255, 255, 255, 200));

                builder_pos.y += m_style.m_line_height;
            }
        }
    }
}

void c_hud::draw_binds(const vec2& pos) {
    std::vector<wstring> binds_name;
    std::vector<wstring> binds_mode;

    if (true) {
        binds_name.emplace_back(L"а я еду suck");
        binds_mode.emplace_back(L"toggled");
    }
    if (true) {
        binds_name.emplace_back(L"suck some dick");
        binds_mode.emplace_back(L"disabled");
    }
    if (true) {
        binds_name.emplace_back(L"вокруг fucking slaves");
        binds_mode.emplace_back(L"fisting");
    }

    draw_frame(pos, L"binds", binds_name, binds_mode);
}

/// Simple spectators list.
void c_hud::draw_spectators(const vec2& pos) {
    if (!globals::local_player->is_alive())
        return;

    std::vector<wstring> spectators_name;

    for (auto i = 1u; i <= interfaces::globals->m_max_players; i++) {
        auto player = static_cast<c_cs_player*>(interfaces::entity_list->get_client_entity(i));
        if (!player)
            continue;

        if (player->m_spectating_target() != globals::local_player)
            continue;

        const auto info = player->get_info();

        //if (info.m_hltv || info.m_fake_player)
        //    continue;

        auto name = convert::to_unicode(info.m_name);

        std::transform(name.begin(), name.end(), name.begin(), towlower);

        spectators_name.emplace_back(name);
    }

    draw_frame(pos, L"spectators", spectators_name);
}

void c_hud::render() {
    /// Updating our accent color.
    update_accent_color();

    /// Change watermark options here.
    draw_watermark(USER | INCOMING | OUTGOING | TIME);

    draw_binds(vec2(1685, 60));

    draw_spectators(vec2(1685, 180));
}

hud.h

#pragma once
#include "../../globals.h"

class c_hud : public singleton<c_hud> {
private:
    /// Elements accent color mode.
    enum e_color_mode {
        STATIC = 1, /// Just accent color
        RAINBOW,        /// Dynamic color
        GRADIENT    /// Gradient dynamic color
    };

    /// Watermark options to draw.
    enum e_watermark_options {
        NONE        = 0, /// Default argument, only logo will be drawn.
        USER        = (1 << 0), /// User name
        INCOMING = (1 << 1), /// Incoming latency (only in-game)
        OUTGOING = (1 << 2), /// Outgoing latency (only in-game)
        TIME        = (1 << 3)  /// Current Windows time
    };

    /// Color stuff.

    /// <summary> Returns color, based on current style. </summary>
    void update_accent_color();

    struct style_t {
        e_color_mode    m_col_mode = RAINBOW; /// Elements accent color mode.
        color                m_col_fallback = color(210, 150, 20, 200); /// Change your accent color here.
        color                m_col_accent[2]; /// Final color, will be used in elements rendering.

        /// Watermark stuff.
        vec2                m_watermark_paddings = vec2(5, 3);
        vec2                m_watermark_margins  = vec2(10, 10);

        /// Default elements stuff.
        size_t            m_outline_size            = 4; /// Main outline size (in pixels).
        size_t            m_line_height            = render::measure_text(font::tahoma_8, "A").y;

        size_t            m_pad_base                = 5;
        size_t            m_pad_header_top        = 6;
        size_t            m_pad_header_sides    = 6;
        size_t            m_pad_header_bottom    = 7;

        color                m_col_base                        = color(0, 0, 0);
        color                m_col_base_outer_outline    = color(0, 0, 0, 220);
        color                m_col_base_inner_outline    = color(255, 255, 255, 4);

        color                m_col_outline            = color(0, 0, 0, 200);
        color                m_col_outer_outline    = color(0, 0, 0, 220);
        color                m_col_inner_outline    = color(255, 255, 255, 8);
    } m_style;

    /// Elements rendering.

    /// <summary> Usage: draw_watermark(USER | OUTGOING | TIME) for user name, outgoing latency and time rendering. </summary>
    void draw_watermark    (uint8_t options = NONE);

    void draw_frame        (const vec2& pos, const wstring& name, const std::vector<wstring>& first_column, const std::vector<wstring>& second_column = {});
    void draw_binds        (const vec2& pos);
    void draw_spectators    (const vec2& pos);

public:
    /// <summary> Entry function. Should be called in d3dx9 or paint hook. </summary>
    void render();
};

 

  • Like 3
Link to post
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
×
×
  • Create New...