ModdingRX/YimMenu
Archived
1
0
Fork 0
Code Actions Releases Activity

Added ped model preview. (#375)

Browse Source
This commit is contained in:
aa15032261 2022-07-31 01:47:48 +08:00 committed by GitHub
parent 136efc3af8
commit 9d48b02d63
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 355 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BigBaseV2/src/core/globals.hpp
View File

@ -140,7 +140,7 @@ namespace big
bool off_radar = false;
bool super_run = false;
int wanted_level = 0;
bool preview_ped = false;
bool god_mode = false;
bool proof_bullet = false;
bool proof_fire = false;
@ -520,6 +520,7 @@ namespace big
this->self.no_ragdoll = j["self"]["no_ragdoll"];
this->self.off_radar = j["self"]["off_radar"];
this->self.super_run = j["self"]["super_run"];
this->self.preview_ped = j["self"]["preview_ped"];
this->settings.hotkeys.menu_toggle = j["settings"]["hotkeys"]["menu_toggle"];
@ -772,6 +773,7 @@ namespace big
{ "no_ragdoll", this->self.no_ragdoll },
{ "off_radar", this->self.off_radar },
{ "super_run", this->self.super_run },
{ "preview_ped", this->self.preview_ped }
}
},
{

8
BigBaseV2/src/main.cpp
View File

@ -20,7 +20,7 @@
#include "services/pickups/pickup_service.hpp"
#include "services/players/player_service.hpp"
#include "services/notifications/notification_service.hpp"
#include "services/vehicle_preview/vehicle_preview_service.hpp"
#include "services/model_preview/model_preview_service.hpp"
#include "services/vehicle/vehicle_service.hpp"
BOOL APIENTRY DllMain(HMODULE hmod, DWORD reason, PVOID)
@ -80,7 +80,7 @@ BOOL APIENTRY DllMain(HMODULE hmod, DWORD reason, PVOID)
auto pickup_service_instance = std::make_unique<pickup_service>();
auto player_service_instance = std::make_unique<player_service>();
auto gta_data_service_instance = std::make_unique<gta_data_service>();
auto vehicle_preview_service_instance = std::make_unique<vehicle_preview_service>();
auto model_preview_service_instance = std::make_unique<model_preview_service>();
auto vehicle_service_instance = std::make_unique<vehicle_service>();
auto gui_service_instance = std::make_unique<gui_service>();
LOG(INFO) << "Registered service instances...";
@ -128,8 +128,8 @@ BOOL APIENTRY DllMain(HMODULE hmod, DWORD reason, PVOID)
LOG(INFO) << "GTA Data Service reset.";
vehicle_service_instance.reset();
LOG(INFO) << "Vehicle Service reset.";
vehicle_preview_service_instance.reset();
LOG(INFO) << "Vehicle Preview Service reset.";
model_preview_service_instance.reset();
LOG(INFO) << "Model Preview Service reset.";
mobile_service_instance.reset();
LOG(INFO) << "Mobile Service reset.";
player_service_instance.reset();

190
BigBaseV2/src/services/model_preview/model_preview_service.cpp Normal file
View File

@ -0,0 +1,190 @@
#include "fiber_pool.hpp"
#include "gui.hpp"
#include "thread_pool.hpp"
#include "util/ped.hpp"
#include "util/vehicle.hpp"
#include "model_preview_service.hpp"
namespace big
{
model_preview_service::model_preview_service()
{
g_model_preview_service = this;
}
model_preview_service::~model_preview_service()
{
g_model_preview_service = nullptr;
}
void model_preview_service::show_ped(Hash hash)
{
m_veh_model_hash = 0;
m_veh_owned_mods.clear();
if (m_ped_model_hash != hash)
{
m_ped_model_hash = hash;
if (m_ped_model_hash != 0)
{
m_new_model = true;
preview_loop();
}
}
}
void model_preview_service::show_vehicle(Hash hash, bool spawn_max)
{
m_ped_model_hash = 0;
m_veh_owned_mods.clear();
if (m_veh_model_hash != hash || m_veh_spawn_max != spawn_max)
{
m_veh_model_hash = hash;
if (m_veh_model_hash != 0)
{
m_veh_spawn_max = spawn_max;
m_new_model = true;
preview_loop();
}
}
}
void model_preview_service::show_vehicle(const std::map<int, int32_t>& owned_mods, bool spawn_max)
{
m_ped_model_hash = 0;
if (
m_veh_spawn_max != spawn_max ||
m_veh_owned_mods.size() != owned_mods.size() ||
!std::equal(m_veh_owned_mods.begin(), m_veh_owned_mods.end(), owned_mods.begin())
) {
m_veh_owned_mods.clear();
auto hash_item = owned_mods.find(MOD_MODEL_HASH);
m_veh_model_hash = hash_item->second;
if (m_veh_model_hash != 0)
{
m_veh_owned_mods.insert(owned_mods.begin(), owned_mods.end());
m_veh_spawn_max = spawn_max;
m_new_model = true;
preview_loop();
}
}
}
void model_preview_service::preview_loop()
{
if (m_running || m_loop_running)
{
return;
}
m_running = true;
g_fiber_pool->queue_job([this] {
m_loop_running = true;
while (
g_running && m_running && g_gui.m_opened &&
(m_ped_model_hash|| m_veh_model_hash)
) {
Vector3 location;
if (m_ped_model_hash)
{
location = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(self::ped, 0.f, 5.f, -.5f);
}
else if (m_veh_model_hash)
{
location = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(self::ped, 0.f, 10.f, .5f);
}
if (m_current_ent == 0)
{
m_new_model = false;
location.z = -10.f;
if (m_ped_model_hash)
{
m_current_ent = ped::spawn(ePedType::PED_TYPE_ARMY, m_ped_model_hash, location, 0.f, false);
ENTITY::SET_ENTITY_HEALTH(m_current_ent, 0, 0);
script::get_current()->yield(20ms);
PED::RESURRECT_PED(m_current_ent);
TASK::CLEAR_PED_TASKS(m_current_ent);
}
else if (m_veh_model_hash)
{
if (m_veh_owned_mods.empty())
{
m_current_ent = vehicle::spawn(m_veh_model_hash, location, 0.f, false);
}
else
{
m_current_ent = vehicle::clone_from_owned_mods(m_veh_owned_mods, location, 0.f, false);
}
}
if (m_current_ent)
{
if (m_veh_model_hash && m_veh_spawn_max)
{
vehicle::max_vehicle(m_current_ent);
}
ENTITY::FREEZE_ENTITY_POSITION(m_current_ent, true);
ENTITY::SET_ENTITY_ALPHA(m_current_ent, 0, false);
ENTITY::SET_ENTITY_COLLISION(m_current_ent, false, false);
ENTITY::SET_CAN_CLIMB_ON_ENTITY(m_current_ent, false);
OBJECT::SET_OBJECT_ALLOW_LOW_LOD_BUOYANCY(m_current_ent, false);
}
}
else if (m_new_model)
{
ENTITY::DETACH_ENTITY(m_current_ent, 1, 1);
ENTITY::DELETE_ENTITY(&m_current_ent);
}
else
{
if (const int alpha = ENTITY::GET_ENTITY_ALPHA(m_current_ent); alpha < 255)
{
ENTITY::SET_ENTITY_ALPHA(m_current_ent, std::min<int>(255, alpha + 20), false);
}
ENTITY::SET_ENTITY_HEADING(m_current_ent, m_heading);
ENTITY::SET_ENTITY_COORDS(m_current_ent, location.x, location.y, location.z, 0, 0, 0, 0);
}
if (m_heading += 0.5f; m_heading > 359)
{
m_heading = 0;
}
script::get_current()->yield(15ms);
}
ENTITY::DETACH_ENTITY(m_current_ent, 1, 1);
ENTITY::DELETE_ENTITY(&m_current_ent);
m_current_ent = 0;
m_ped_model_hash = 0;
m_veh_model_hash = 0;
m_veh_owned_mods.clear();
m_running = false;
m_loop_running = false;
});
}
void model_preview_service::stop_preview()
{
m_veh_owned_mods.clear();
m_running = false;
}
}

37
BigBaseV2/src/services/model_preview/model_preview_service.hpp Normal file
View File

@ -0,0 +1,37 @@
#pragma once
#include "file_manager/file.hpp"
namespace big
{
class model_preview_service
{
std::condition_variable m_cond;
std::mutex m_mutex;
Entity m_current_ent = 0;
Hash m_veh_model_hash = 0;
std::map<int, int32_t> m_veh_owned_mods;
bool m_veh_spawn_max = false;
Hash m_ped_model_hash = 0;
bool m_new_model = false;
float m_heading = 0.f;
bool m_loop_running = false;
bool m_running = false;
public:
model_preview_service();
~model_preview_service();
void show_ped(Hash hash);
void show_vehicle(Hash hash, bool spawn_max);
void show_vehicle(const std::map<int, int32_t>& owned_mods, bool spawn_max);
void preview_loop();
void stop_preview();
};
inline model_preview_service* g_model_preview_service{};
}

142
BigBaseV2/src/services/vehicle_preview/vehicle_preview_service.cpp
View File

@ -1,142 +0,0 @@
#include "fiber_pool.hpp"
#include "gui.hpp"
#include "thread_pool.hpp"
#include "util/entity.hpp"
#include "util/vehicle.hpp"
#include "vehicle_preview_service.hpp"
namespace big
{
vehicle_preview_service::vehicle_preview_service()
{
g_vehicle_preview_service = this;
}
vehicle_preview_service::~vehicle_preview_service()
{
g_vehicle_preview_service = nullptr;
}
void vehicle_preview_service::set_preview_vehicle(const vehicle_item& item, bool spawn_max)
{
if (item.hash != 0)
{
m_owned_mods.clear();
if (m_model_hash != item.hash || m_spawn_max != spawn_max)
{
m_spawn_max = spawn_max;
m_model_hash = item.hash;
m_new_model = true;
}
preview_loop();
}
}
void vehicle_preview_service::set_preview_vehicle(const std::map<int, int32_t>& owned_mods, bool spawn_max)
{
auto hash_item = owned_mods.find(MOD_MODEL_HASH);
if (
m_spawn_max != spawn_max ||
m_owned_mods.size() != owned_mods.size() ||
!std::equal(m_owned_mods.begin(), m_owned_mods.end(), owned_mods.begin())
) {
m_owned_mods.clear();
m_owned_mods.insert(owned_mods.begin(), owned_mods.end());
auto hash_item = owned_mods.find(MOD_MODEL_HASH);
m_spawn_max = spawn_max;
m_model_hash = hash_item->second;
m_new_model = true;
preview_loop();
}
}
void vehicle_preview_service::preview_loop()
{
if (m_running || m_loop_running)
{
return;
}
m_running = true;
g_fiber_pool->queue_job([this] {
m_loop_running = true;
while (
g_running && m_running && g_gui.m_opened &&
(g->spawn.preview_vehicle || g->clone_pv.preview_vehicle)
) {
auto location = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(self::ped, 0.f, 10.f, .5f);
if (m_current_veh == 0)
{
m_new_model = false;
location.z = -10.f;
if (m_owned_mods.empty())
{
m_current_veh = vehicle::spawn(m_model_hash, location, 0.f, false);
}
else
{
m_current_veh = vehicle::clone_from_owned_mods(m_owned_mods, location, 0.f, false);
}
if (m_current_veh)
{
if (m_spawn_max)
{
vehicle::max_vehicle(m_current_veh);
}
ENTITY::FREEZE_ENTITY_POSITION(m_current_veh, true);
ENTITY::SET_ENTITY_ALPHA(m_current_veh, 0, 0);
ENTITY::SET_ENTITY_COLLISION(m_current_veh, false, false);
ENTITY::SET_CAN_CLIMB_ON_ENTITY(m_current_veh, false);
OBJECT::SET_OBJECT_ALLOW_LOW_LOD_BUOYANCY(m_current_veh, false);
}
}
else if (m_new_model)
{
ENTITY::DETACH_ENTITY(m_current_veh, 1, 1);
ENTITY::DELETE_ENTITY(&m_current_veh);
}
else
{
if (const int alpha = ENTITY::GET_ENTITY_ALPHA(m_current_veh); alpha < 250)
{
ENTITY::SET_ENTITY_ALPHA(m_current_veh, std::min<int>(255, alpha + 10), 0);
}
ENTITY::SET_ENTITY_HEADING(m_current_veh, m_heading);
ENTITY::SET_ENTITY_COORDS(m_current_veh, location.x, location.y, location.z, 0, 0, 0, 0);
}
if (m_heading += 0.5f; m_heading > 359)
{
m_heading = 0;
}
script::get_current()->yield(15ms);
}
entity::delete_entity(m_current_veh);
m_current_veh = 0;
m_model_hash = 0;
m_owned_mods.clear();
m_running = false;
m_loop_running = false;
});
}
void vehicle_preview_service::stop_preview()
{
m_owned_mods.clear();
m_running = false;
}
}

33
BigBaseV2/src/services/vehicle_preview/vehicle_preview_service.hpp
View File

@ -1,33 +0,0 @@
#pragma once
#include "file_manager/file.hpp"
#include "services/gta_data/gta_data_service.hpp"
namespace big
{
class vehicle_preview_service
{
std::condition_variable m_cond;
std::mutex m_mutex;
Vehicle m_current_veh = 0;
Hash m_model_hash;
std::map<int, int32_t> m_owned_mods;
bool m_new_model = false;
float m_heading = 0.f;
bool m_spawn_max = false;
bool m_loop_running = false;
bool m_running = false;
public:
vehicle_preview_service();
~vehicle_preview_service();
void set_preview_vehicle(const vehicle_item& item, bool spawn_max);
void set_preview_vehicle(const std::map<int, int32_t>& owned_mods, bool spawn_max);
void preview_loop();
void stop_preview();
};
inline vehicle_preview_service* g_vehicle_preview_service{};
}

25
BigBaseV2/src/util/ped.hpp
View File

@ -1,6 +1,7 @@
#pragma once
#include "natives.hpp"
#include "script.hpp"
#include "pointers.hpp"
namespace big::ped
{
@ -37,4 +38,28 @@ namespace big::ped
ENTITY::SET_ENTITY_HEALTH(self::ped, current_health, 0);
PED::SET_PED_ARMOUR(self::ped, current_armor);
}
inline Ped spawn(ePedType pedType, Hash hash, Vector3 location, float heading, bool is_networked = true)
{
for (uint8_t i = 0; !STREAMING::HAS_MODEL_LOADED(hash) && i < 100; i++)
{
STREAMING::REQUEST_MODEL(hash);
script::get_current()->yield();
}
if (!STREAMING::HAS_MODEL_LOADED(hash))
{
return 0;
}
*(unsigned short*)g_pointers->m_model_spawn_bypass = 0x9090;
auto ped = PED::CREATE_PED(pedType, hash, location.x, location.y, location.z, heading, is_networked, false);
*(unsigned short*)g_pointers->m_model_spawn_bypass = 0x0574;
script::get_current()->yield();
STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(hash);
return ped;
}
}

70
BigBaseV2/src/views/self/view_self.cpp
View File

@ -3,6 +3,7 @@
#include "util/local_player.hpp"
#include "views/view.hpp"
#include "services/gta_data/gta_data_service.hpp"
#include "services/model_preview/model_preview_service.hpp"
#include <imgui_internal.h>
namespace big
@ -44,30 +45,30 @@ namespace big
components::small_text("Player Model Changer");
static int selected_player_ped_type = -1;
static bool player_model_open = false;
static char player_model_name[64];
static int selected_ped_type = -1;
static bool ped_model_dropdown_open = false;
static char ped_model_buf[64];
auto ped_type_arr = g_gta_data_service->get_ped_type_arr();
auto ped_arr = g_gta_data_service->get_ped_arr();
ImGui::SetNextItemWidth(300.f);
if (ImGui::BeginCombo("Ped Type", selected_player_ped_type == -1 ? "ALL" : ped_type_arr[selected_player_ped_type].c_str()))
if (ImGui::BeginCombo("Ped Type", selected_ped_type == -1 ? "ALL" : ped_type_arr[selected_ped_type].c_str()))
{
if (ImGui::Selectable("ALL", selected_player_ped_type == -1))
if (ImGui::Selectable("ALL", selected_ped_type == -1))
{
selected_player_ped_type = -1;
selected_ped_type = -1;
}
for (int i = 0; i < ped_type_arr.size(); i++)
{
if (ImGui::Selectable(ped_type_arr[i].c_str(), selected_player_ped_type == i))
if (ImGui::Selectable(ped_type_arr[i].c_str(), selected_ped_type == i))
{
selected_player_ped_type = i;
player_model_name[0] = 0;
selected_ped_type = i;
ped_model_buf[0] = 0;
}
if (selected_player_ped_type == i)
if (selected_ped_type == i)
{
ImGui::SetItemDefaultFocus();
}
@ -77,22 +78,24 @@ namespace big
}
ImGui::SetNextItemWidth(300.f);
components::input_text_with_hint("Model Name##player_model_name", "Model Name", player_model_name, sizeof(player_model_name), ImGuiInputTextFlags_EnterReturnsTrue, [] {
player_model_open = false;
components::input_text_with_hint("Model Name##player_model_name", "Model Name", ped_model_buf, sizeof(ped_model_buf), ImGuiInputTextFlags_EnterReturnsTrue, [] {
ped_model_dropdown_open = false;
});
bool player_model_focused = ImGui::IsItemActive();
bool ped_model_dropdown_focused = ImGui::IsItemActive();
if (ImGui::IsItemActivated())
{
player_model_open = true;
ped_model_dropdown_open = true;
}
if (player_model_open)
if (ped_model_dropdown_open)
{
bool is_open = true;
bool item_hovered = false;
std::string lower_search = player_model_name;
std::string lower_search = ped_model_buf;
std::transform(lower_search.begin(), lower_search.end(), lower_search.begin(), tolower);
ImGui::SetNextWindowPos({ ImGui::GetItemRectMin().x, ImGui::GetItemRectMax().y });
@ -100,7 +103,7 @@ namespace big
if (ImGui::Begin("##player_model_popup", &is_open, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_Tooltip))
{
ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
player_model_focused |= ImGui::IsWindowFocused();
ped_model_dropdown_focused |= ImGui::IsWindowFocused();
for (auto& item : ped_arr)
{
@ -110,36 +113,55 @@ namespace big
std::transform(name.begin(), name.end(), name.begin(), tolower);
if ((
selected_player_ped_type == -1 || ped_type_arr[selected_player_ped_type] == ped_type
selected_ped_type == -1 || ped_type_arr[selected_ped_type] == ped_type
) && (
name.find(lower_search) != std::string::npos
)) {
bool selectable_highlighted = lower_search == name;
bool selectable_clicked = ImGui::Selectable(item.name.c_str(), selectable_highlighted);
player_model_focused |= ImGui::IsItemFocused();
ped_model_dropdown_focused |= ImGui::IsItemFocused();
if (selectable_clicked)
{
strncpy(player_model_name, item.name.c_str(), 64);
player_model_open = false;
player_model_focused = false;
strncpy(ped_model_buf, item.name.c_str(), 64);
ped_model_dropdown_open = false;
ped_model_dropdown_focused = false;
}
if (selectable_highlighted)
{
ImGui::SetItemDefaultFocus();
}
if (ImGui::IsItemHovered())
{
item_hovered = true;
g_model_preview_service->show_ped(item.hash);
}
}
}
ImGui::End();
}
player_model_open = player_model_focused;
ped_model_dropdown_open = ped_model_dropdown_focused;
if (!g->self.preview_ped || (g->self.preview_ped && (!item_hovered || !ped_model_dropdown_open)))
{
g_model_preview_service->stop_preview();
}
}
if (ImGui::Checkbox("Preview", &g->self.preview_ped))
{
if (!g->self.preview_ped)
{
g_model_preview_service->stop_preview();
}
}
ImGui::SameLine();
components::button("Change Player Model", [] {
const Hash hash = rage::joaat(player_model_name);
const Hash hash = rage::joaat(ped_model_buf);
for (uint8_t i = 0; !STREAMING::HAS_MODEL_LOADED(hash) && i < 100; i++)
{

39
BigBaseV2/src/views/vehicle/view_pv.cpp
View File

@ -2,7 +2,8 @@
#include "fiber_pool.hpp"
#include "natives.hpp"
#include "services/mobile/mobile_service.hpp"
#include "services/vehicle_preview/vehicle_preview_service.hpp"
#include "services/gta_data/gta_data_service.hpp"
#include "services/model_preview/model_preview_service.hpp"
#include "util/vehicle.hpp"
namespace big
@ -10,12 +11,18 @@ namespace big
void view::pv() {
ImGui::SetWindowSize({ 0.f, (float)*g_pointers->m_resolution_y }, ImGuiCond_Always);
ImGui::Checkbox("Preview", &g->clone_pv.preview_vehicle);
if (ImGui::Checkbox("Preview", &g->clone_pv.preview_vehicle))
{
if (!g->clone_pv.preview_vehicle)
{
g_model_preview_service->stop_preview();
}
}
ImGui::SameLine();
ImGui::Checkbox("Spawn In", &g->clone_pv.spawn_inside);
ImGui::SameLine();
static char plate[9] = { 0 };
static char plate_buf[9] = { 0 };
int num_of_rows = 3;
ImGui::Checkbox("Spawn Clone", &g->clone_pv.spawn_clone);
@ -26,7 +33,6 @@ namespace big
ImGui::Checkbox("Spawn Maxed", &g->clone_pv.spawn_maxed);
ImGui::SameLine();
strncpy(plate, g->clone_pv.plate.c_str(), 9);
ImGui::Checkbox("Clone PV Plate", &g->clone_pv.clone_plate);
if (g->clone_pv.clone_plate)
{
@ -36,8 +42,9 @@ namespace big
{
ImGui::SetNextItemWidth(300.f);
components::input_text_with_hint("Plate", "Plate Number", plate, sizeof(plate), ImGuiInputTextFlags_None, [] {
g->clone_pv.plate = plate;
strncpy(plate_buf, g->clone_pv.plate.c_str(), 9);
components::input_text_with_hint("Plate", "Plate Number", plate_buf, sizeof(plate_buf), ImGuiInputTextFlags_None, [] {
g->clone_pv.plate = plate_buf;
});
}
}
@ -117,10 +124,10 @@ namespace big
auto vehicle_idx = personal_veh->get_vehicle_idx();
auto owned_mods = vehicle::get_owned_mods_from_vehicle_idx(vehicle_idx);
const char* spawn_plate = plate;
const char* spawn_plate_buf = plate_buf;
if (g->clone_pv.clone_plate)
{
spawn_plate = personal_veh->get_plate();
spawn_plate_buf = personal_veh->get_plate();
}
auto veh = vehicle::clone_from_owned_mods(owned_mods, spawn_location, spawn_heading);
@ -136,7 +143,7 @@ namespace big
vehicle::max_vehicle(veh);
}
vehicle::set_plate(veh, plate);
vehicle::set_plate(veh, spawn_plate_buf);
if (g->clone_pv.spawn_inside)
{
@ -150,23 +157,23 @@ namespace big
personal_veh->summon();
}
g_vehicle_preview_service->stop_preview();
g_model_preview_service->stop_preview();
});
ImGui::PopID();
if (g->clone_pv.preview_vehicle && ImGui::IsItemHovered())
if (!g->spawn.preview_vehicle || (g->spawn.preview_vehicle && !ImGui::IsAnyItemHovered()))
{
g_model_preview_service->stop_preview();
}
else if (ImGui::IsItemHovered())
{
g_fiber_pool->queue_job([&personal_veh] {
g_vehicle_preview_service->set_preview_vehicle(
g_model_preview_service->show_vehicle(
vehicle::get_owned_mods_from_vehicle_idx(personal_veh->get_vehicle_idx()),
g->clone_pv.spawn_maxed
);
});
}
else if (g->clone_pv.preview_vehicle && !ImGui::IsAnyItemHovered())
{
g_vehicle_preview_service->stop_preview();
}
}
}
}

47
BigBaseV2/src/views/vehicle/view_spawn.cpp
View File

@ -1,7 +1,8 @@
#include "views/view.hpp"
#include "fiber_pool.hpp"
#include "natives.hpp"
#include "services/vehicle_preview/vehicle_preview_service.hpp"
#include "services/gta_data/gta_data_service.hpp"
#include "services/model_preview/model_preview_service.hpp"
#include "util/vehicle.hpp"
namespace big
@ -10,18 +11,24 @@ namespace big
{
ImGui::SetWindowSize({ 0.f, (float)*g_pointers->m_resolution_y }, ImGuiCond_Always);
ImGui::Checkbox("Preview", &g->spawn.preview_vehicle);
if (ImGui::Checkbox("Preview", &g->spawn.preview_vehicle))
{
if (!g->spawn.preview_vehicle)
{
g_model_preview_service->stop_preview();
}
}
ImGui::SameLine();
ImGui::Checkbox("Spawn In", &g->spawn.spawn_inside);
ImGui::SameLine();
ImGui::Checkbox("Spawn Maxed", &g->spawn.spawn_maxed);
static char plate[9] = { 0 };
strncpy(plate, g->spawn.plate.c_str(), 9);
static char plate_buf[9] = { 0 };
strncpy(plate_buf, g->spawn.plate.c_str(), 9);
ImGui::SetNextItemWidth(300.f);
components::input_text_with_hint("Plate", "Plate Number", plate, sizeof(plate), ImGuiInputTextFlags_None, [] {
g->spawn.plate = plate;
components::input_text_with_hint("Plate", "Plate Number", plate_buf, sizeof(plate_buf), ImGuiInputTextFlags_None, [] {
g->spawn.plate = plate_buf;
});
@ -94,7 +101,7 @@ namespace big
vehicle::max_vehicle(veh);
}
vehicle::set_plate(veh, plate);
vehicle::set_plate(veh, plate_buf);
if (g->spawn.spawn_inside)
{
@ -103,22 +110,22 @@ namespace big
}
}
g_vehicle_preview_service->stop_preview();
g_model_preview_service->stop_preview();
});
if (g->spawn.preview_vehicle && ImGui::IsItemHovered())
if (!g->spawn.preview_vehicle || (g->spawn.preview_vehicle && !ImGui::IsAnyItemHovered()))
{
g_model_preview_service->stop_preview();
}
else if (ImGui::IsItemHovered())
{
g_fiber_pool->queue_job([] {
g_vehicle_preview_service->set_preview_vehicle(
g_model_preview_service->show_vehicle(
vehicle::get_owned_mods_from_vehicle(self::veh),
g->spawn.spawn_maxed
);
});
}
else if (g->spawn.preview_vehicle && !ImGui::IsAnyItemHovered())
{
g_vehicle_preview_service->stop_preview();
}
}
}
@ -162,7 +169,7 @@ namespace big
vehicle::max_vehicle(veh);
}
vehicle::set_plate(veh, plate);
vehicle::set_plate(veh, plate_buf);
if (g->spawn.spawn_inside)
{
@ -170,17 +177,17 @@ namespace big
}
}
g_vehicle_preview_service->stop_preview();
g_model_preview_service->stop_preview();
});
ImGui::PopID();
if (g->spawn.preview_vehicle && ImGui::IsItemHovered())
if (!g->spawn.preview_vehicle || (g->spawn.preview_vehicle && !ImGui::IsAnyItemHovered()))
{
g_vehicle_preview_service->set_preview_vehicle(item, g->spawn.spawn_maxed);
g_model_preview_service->stop_preview();
}
else if (g->spawn.preview_vehicle && !ImGui::IsAnyItemHovered())
else if (ImGui::IsItemHovered())
{
g_vehicle_preview_service->stop_preview();
g_model_preview_service->show_vehicle(item.hash, g->spawn.spawn_maxed);
}
}
}