```cpp
// main.cpp

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cmath>
#include <filesystem>
#include <stdexcept>

// Определение STBI_NO_WINDOWS_UTF8 предотвращает использование MultiByteToWideChar и WideCharToMultiByte
#define STBI_NO_WINDOWS_UTF8

// Подавление предупреждений для stb_image.h и stb_image_write.h
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 26819 6262 6001 6101 6385 6386) // Отключение специфичных предупреждений
#endif

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

#if defined(_MSC_VER)
#pragma warning(pop)
#endif

class VTF {
public:
    // Константы, связанные с форматом VTF
    static constexpr int HEADER_SIZE = 64;
    static constexpr double VERSION = 7.2;
    static constexpr int MAX_WIDTH = 4096;
    static constexpr int MAX_HEIGHT = 4096;
    static constexpr const char* VTF_SIGNATURE = "VTF\0";

    // Конструктор инициализирует ширину и высоту ближайшей степенью двойки
    VTF(int width, int height)
        : width_(nearest_power_of_two(width)), height_(nearest_power_of_two(height))
    {
        validate_dimensions();
    }

    // Добавляет данные изображения в объект VTF
    void addImageData(const std::vector<unsigned char>& image_data) {
        data_.insert(data_.end(), image_data.begin(), image_data.end());
    }

    // Сохраняет данные VTF в файл
    void save(const std::string& filename) const {
        validate_version();

        int major_version = static_cast<int>(VERSION);
        int minor_version = static_cast<int>((VERSION - major_version) * 10);

        std::ofstream file(filename, std::ios::binary);
        if (!file) {
            throw std::runtime_error("Не удалось открыть файл для записи: " + filename);
        }

        // Запись заголовка VTF
        file.write(VTF_SIGNATURE, 4);
        file.write(reinterpret_cast<const char*>(&major_version), sizeof(major_version));
        file.write(reinterpret_cast<const char*>(&minor_version), sizeof(minor_version));
        file.write(reinterpret_cast<const char*>(&width_), sizeof(width_));
        file.write(reinterpret_cast<const char*>(&height_), sizeof(height_));
        file.write(reinterpret_cast<const char*>(&HEADER_SIZE), sizeof(HEADER_SIZE));

        // Запись байтов заполнения для завершения заголовка
        size_t padding_size = static_cast<size_t>(HEADER_SIZE) - 4 - sizeof(major_version) - sizeof(minor_version)
            - sizeof(width_) - sizeof(height_) - sizeof(HEADER_SIZE);
        if (padding_size > 0) {
            std::vector<char> padding(padding_size, '\0');
            file.write(padding.data(), padding.size());
        }

        // Запись данных изображения
        file.write(reinterpret_cast<const char*>(data_.data()), data_.size());

        if (!file) {
            throw std::runtime_error("Не удалось записать данные в файл: " + filename);
        }

        printFileInfo(filename);
    }

    // Создаёт VMT (Valve Material Type) файл, связанный с VTF
    static void createVMT(const std::string& texture_name) {
        std::ofstream file(texture_name + ".vmt");
        if (!file) {
            throw std::runtime_error("Не удалось создать VMT файл: " + texture_name + ".vmt");
        }

        file << "\"LightmappedGeneric\"\n"
            "{\n"
            "\t\"$basetexture\" \"" << texture_name << "\"\n"
            "\t\"$surfaceprop\" \"metal\"\n"
            "\t\"$reflectivity\" \"1 1 1\"\n"
            "}\n";

        if (!file) {
            throw std::runtime_error("Не удалось записать в VMT файл: " + texture_name + ".vmt");
        }
    }

    // Обработка изображения: загрузка и изменение размера до ближайших степеней двойки
    static std::vector<unsigned char> processImage(const std::string& image_path, int target_width, int target_height) {
        int img_width, img_height, channels;
        unsigned char* img_data = stbi_load(image_path.c_str(), &img_width, &img_height, &channels, 3);
        if (!img_data) {
            throw std::runtime_error("Не удалось загрузить изображение: " + image_path);
        }

        // Вычисление коэффициентов масштабирования
        double scale_x = static_cast<double>(target_width) / img_width;
        double scale_y = static_cast<double>(target_height) / img_height;

        std::vector<unsigned char> resized_data(static_cast<size_t>(target_width) * static_cast<size_t>(target_height) * 3, 0);

        // Простое изменение размера с использованием ближайшего соседнего пикселя
        for (int y = 0; y < target_height; ++y) {
            for (int x = 0; x < target_width; ++x) {
                int src_x = std::min(static_cast<int>(x / scale_x), img_width - 1);
                int src_y = std::min(static_cast<int>(y / scale_y), img_height - 1);
                for (int c = 0; c < 3; ++c) {
                    size_t dst_index = static_cast<size_t>((static_cast<size_t>(y) * target_width + x) * 3 + c);
                    size_t src_index = static_cast<size_t>((static_cast<size_t>(src_y) * img_width + src_x) * channels + c);
                    resized_data[dst_index] = img_data[src_index];
                }
            }
        }

        stbi_image_free(img_data);
        return resized_data;
    }

    // Сделаем nearest_power_of_two публичной статической функцией
    static int nearest_power_of_two(int n) {
        if (n < 1) return 1;
        int power = 1;
        while (power < n) {
            power <<= 1;
        }
        return power;
    }

private:
    int width_;
    int height_;
    std::vector<unsigned char> data_;

    // Проверка, что размеры не превышают максимальные допустимые значения
    void validate_dimensions() const {
        if (width_ > MAX_WIDTH || height_ > MAX_HEIGHT) {
            throw std::runtime_error("Ширина или высота превышает максимальные допустимые значения.");
        }
    }

    // Проверка, что версия находится в допустимом диапазоне
    void validate_version() const {
        if (!(7.0 <= VERSION && VERSION <= 7.5)) {
            throw std::runtime_error("Версия должна быть между 7.0 и 7.5");
        }
    }

    // Вывод информации о созданном файле
    void printFileInfo(const std::string& filename) const {
        std::filesystem::path p(filename);
        auto file_size = std::filesystem::file_size(p);
        std::cout << "Файл '" << filename << "' успешно создан.\n"
            << "Размер файла: " << file_size << " байт\n"
            << "Ширина текстуры: " << width_ << " пикселей\n"
            << "Высота текстуры: " << height_ << " пикселей\n"
            << "Размер заголовка: " << HEADER_SIZE << " байт\n"
            << "Версия: " << VERSION << "\n";
    }
};

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Использование: " << argv[0] << " <путь_к_изображению> <имя_текстуры>\n";
        return EXIT_FAILURE;
    }

    std::string image_path = argv[1];
    std::string texture_name = argv[2];

    // Проверка существования файла изображения
    if (!std::filesystem::exists(image_path)) {
        std::cerr << "Ошибка: Файл '" << image_path << "' не существует.\n";
        return EXIT_FAILURE;
    }

    try {
        // Загрузка изображения для получения оригинальных размеров
        int img_width, img_height, channels;
        unsigned char* img_data = stbi_load(image_path.c_str(), &img_width, &img_height, &channels, 3);
        if (!img_data) {
            throw std::runtime_error("Не удалось загрузить изображение: " + image_path);
        }
        stbi_image_free(img_data);

        // Определение целевых размеров (ближайшие степени двойки)
        int target_width = VTF::nearest_power_of_two(img_width);
        int target_height = VTF::nearest_power_of_two(img_height);

        // Создание объекта VTF с целевыми размерами
        VTF vtf(target_width, target_height);

        // Обработка изображения и получение данных изменённого размера
        auto image_data = VTF::processImage(image_path, target_width, target_height);

        // Добавление данных изображения в объект VTF
        vtf.addImageData(image_data);

        // Сохранение VTF файла
        vtf.save(texture_name + ".vtf");

        // Создание связанного VMT файла
        VTF::createVMT(texture_name);

        std::cout << "Успешно создано " << texture_name << ".vtf и "
            << texture_name << ".vmt\n";
    }
    catch (const std::exception& e) {
        std::cerr << "Произошла ошибка: " << e.what() << "\n";
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}
```
Серьезность	Код	Описание	Проект	Файл	Строка	Состояние подавления	Подробности
Ошибка	C4996	'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.	VTFCreator	C:\Users\Admin\source\repos\VTFCreator\stb_image_write.h	776