bool PListFile::LoadValue(PListValue& value, const XMLElement& valueElem)
{
String valueType = valueElem.GetName();
if (valueType == "string")
value.SetString(valueElem.GetValue());
else if (valueType == "real")
value.SetFloat(ToFloat(valueElem.GetValue()));
else if (valueType == "integer")
value.SetInt(ToInt(valueElem.GetValue()));
else if (valueType == "true")
value.SetBool(true);
else if (valueType == "false")
value.SetBool(false);
else if (valueType == "dict")
{
if (!LoadDict(value.ConvertToValueMap(), valueElem))
return false;
}
else if (valueType == "array")
{
if (!LoadArray(value.ConvertToValueVector(), valueElem))
return false;
}
else
{
URHO3D_LOGERROR("Supported value type");
return false;
}
return true;
}
bool Shader::Load(const void* wrapper)
{
EntityManager::Ptr entityMgr = EntityManager::Instance();
std::string str;
if (!LoadMemberValue(wrapper, "type", str))
{
FURYE << "Shader param 'type' not found!";
return false;
}
m_Type = EnumUtil::ShaderTypeFromString(str);
// read shader texture flags
std::vector<ShaderTexture> textures;
m_TextureFlags = 0;
if (LoadArray(wrapper, "textures", [&](const void* node) -> bool
{
if (!LoadValue(node, str))
{
FURYE << "Shader's texture flag not found!";
return false;
}
textures.push_back(EnumUtil::ShaderTextureFromString(str));
return true;
}))
{
for (auto texture : textures)
m_TextureFlags = m_TextureFlags | (unsigned int)texture;
}
// end: read shader texture flags
if (!LoadMemberValue(wrapper, "path", str))
{
FURYE << "Shader param 'path' not found!";
return false;
}
LoadAndCompile(FileUtil::GetAbsPath() + str);
return true;
}
void main ( int argc, char *argv[] )
{
Element **Array;
int Items = 2000;
if ( argc != 2 && argc != 3 )
{
fprintf ( stderr, "Usage: quick1 infile [maxitems]\n" );
return;
}
if ( argc == 3 )
Items = atoi ( argv[2] );
if (( Items = LoadArray ( argv[1], Items, &Array )) == -1 )
return; /* Couldn't load file */
QuickSort1 ( Array, Items, (CompFunc) Cfunc );
ShowArray ( Array, Items, (CompFunc) Cfunc );
}
void Config::LoadConfig(const std::string path)
{
std::ifstream input_file(path);
if (!input_file.good())
return;
try
{
config << input_file;
}
catch (...)
{
input_file.close();
return;
}
Load(g_Options.misc_autoaccept, "misc_autoaccept");
Load(g_Options.misc_revealAllRanks, "misc_revealAllRanks");
Load(g_Options.misc_bhop, "misc_bhop");
Load(g_Options.misc_autostrafe, "misc_autostrafe");
Load(g_Options.misc_auto_pistol, "misc_auto_pistol");
Load(g_Options.misc_chatspamer, "misc_chatspamer");
Load(g_Options.misc_thirdperson, "misc_thirdperson");
Load(g_Options.misc_thirdperson_bind, "misc_thirdperson_bind");
Load(g_Options.misc_fakewalk, "misc_fakewalk");
Load(g_Options.misc_fakewalk_bind, "misc_fakewalk_bind");
Load(g_Options.misc_fakelag_enabled, "misc_fakelag_enabled");
Load(g_Options.misc_fakelag_value, "misc_fakelag_value");
Load(g_Options.misc_fakelag_activation_type, "misc_fakelag_activation_type");
Load(g_Options.misc_fakelag_adaptive, "misc_fakelag_adaptive");
Load(g_Options.misc_animated_clantag, "misc_animated_clantag");
Load(g_Options.misc_spectatorlist, "misc_spectatorlist");
Load(g_Options.misc_logevents, "misc_logevents");
Load(g_Options.removals_flash, "removals_flash");
Load(g_Options.removals_smoke, "removals_smoke");
Load(g_Options.removals_smoke_type, "removals_smoke_type");
Load(g_Options.removals_scope, "removals_scope");
Load(g_Options.removals_novisualrecoil, "removals_novisualrecoil");
Load(g_Options.removals_postprocessing, "removals_postprocessing");
Load(g_Options.esp_enemies_only, "esp_enemies_only");
Load(g_Options.esp_farther, "esp_farther");
Load(g_Options.esp_fill_amount, "esp_fill_amount");
LoadArray(g_Options.esp_player_fill_color_t, "esp_player_fill_color_t");
LoadArray(g_Options.esp_player_fill_color_ct, "esp_player_fill_color_ct");
LoadArray(g_Options.esp_player_fill_color_t_visible, "esp_player_fill_color_t_visible");
LoadArray(g_Options.esp_player_fill_color_ct_visible, "esp_player_fill_color_ct_visible");
Load(g_Options.esp_player_boundstype, "esp_player_boundstype");
Load(g_Options.esp_player_boxtype, "esp_player_boxtype");
LoadArray(g_Options.esp_player_bbox_color_t, "esp_player_bbox_color_t");
LoadArray(g_Options.esp_player_bbox_color_ct, "esp_player_bbox_color_ct");
LoadArray(g_Options.esp_player_bbox_color_t_visible, "esp_player_bbox_color_t_visible");
LoadArray(g_Options.esp_player_bbox_color_ct_visible, "esp_player_bbox_color_ct_visible");
Load(g_Options.esp_player_name, "esp_player_name");
Load(g_Options.esp_player_health, "esp_player_health");
Load(g_Options.esp_player_weapons, "esp_player_weapons");
Load(g_Options.esp_player_snaplines, "esp_player_snaplines");
Load(g_Options.esp_player_chams, "esp_player_chams");
Load(g_Options.esp_player_chams_type, "esp_player_chams_type");
LoadArray(g_Options.esp_player_chams_color_t_visible, "esp_player_chams_color_t_visible");
LoadArray(g_Options.esp_player_chams_color_ct_visible, "esp_player_chams_color_ct_visible");
LoadArray(g_Options.esp_player_chams_color_t, "esp_player_chams_color_t");
LoadArray(g_Options.esp_player_chams_color_ct, "esp_player_chams_color_ct");
Load(g_Options.esp_player_skelet, "esp_player_skelet");
Load(g_Options.esp_player_anglelines, "esp_player_anglelines");
Load(g_Options.esp_dropped_weapons, "esp_dropped_weapons");
Load(g_Options.esp_planted_c4, "esp_planted_c4");
Load(g_Options.esp_grenades, "esp_grenades");
Load(g_Options.esp_grenades_type, "esp_grenades_type");
Load(g_Options.esp_backtracked_player_skelet, "esp_backtracked_player_skelet");
Load(g_Options.esp_lagcompensated_hitboxes, "esp_lagcompensated_hitboxes");
Load(g_Options.esp_lagcompensated_hitboxes_type, "esp_lagcompensated_hitboxes_type");
Load(g_Options.visuals_others_player_fov, "visuals_others_player_fov");
Load(g_Options.visuals_others_player_fov_viewmodel, "visuals_others_player_fov_viewmodel");
Load(g_Options.visuals_others_watermark, "visuals_others_watermark");
Load(g_Options.visuals_others_grenade_pred, "visuals_others_grenade_pred");
Load(g_Options.visuals_others_hitmarker, "visuals_others_hitmarker");
Load(g_Options.visuals_others_bulletimpacts, "visuals_others_bulletimpacts");
LoadArray(g_Options.visuals_others_bulletimpacts_color, "visuals_others_bulletimpacts_color");
Load(g_Options.visuals_others_sky, "visuals_others_sky");
Load(g_Options.glow_enabled, "glow_enabled");
Load(g_Options.glow_players, "glow_players");
LoadArray(g_Options.glow_player_color_t, "glow_player_color_t");
LoadArray(g_Options.glow_player_color_ct, "glow_player_color_ct");
LoadArray(g_Options.glow_player_color_t_visible, "glow_player_color_t_visible");
LoadArray(g_Options.glow_player_color_ct_visible, "glow_player_color_ct_visible");
Load(g_Options.glow_players_style, "glow_players_style");
Load(g_Options.glow_others, "glow_others");
Load(g_Options.glow_others_style, "glow_others_style");
Load(g_Options.legit_enabled, "legit_enabled");
Load(g_Options.legit_aimkey1, "legit_aimkey1");
Load(g_Options.legit_aimkey2, "legit_aimkey2");
Load(g_Options.legit_rcs, "legit_rcs");
Load(g_Options.legit_trigger, "legit_trigger");
Load(g_Options.legit_trigger_with_aimkey, "legit_trigger_with_aimkey");
Load(g_Options.legit_preaim, "legit_preaim");
Load(g_Options.legit_aftershots, "legit_aftershots");
Load(g_Options.legit_afteraim, "legit_afteraim");
Load(g_Options.legit_smooth_factor, "legit_smooth_factor");
Load(g_Options.legit_fov, "legit_fov");
Load(g_Options.rage_enabled, "rage_enabled");
Load(g_Options.rage_aimkey, "rage_aimkey");
Load(g_Options.rage_usekey, "rage_usekey");
Load(g_Options.rage_silent, "rage_silent");
Load(g_Options.rage_norecoil, "rage_norecoil");
Load(g_Options.rage_autoshoot, "rage_autoshoot");
Load(g_Options.rage_autoscope, "rage_autoscope");
Load(g_Options.rage_autocrouch, "rage_autocrouch");
Load(g_Options.rage_autostop, "rage_autostop");
Load(g_Options.rage_autobaim, "rage_autobaim");
Load(g_Options.rage_autocockrevolver, "rage_autocockrevolver");
Load(g_Options.rage_baim_after_x_shots, "rage_baim_after_x_shots");
Load(g_Options.rage_lagcompensation, "rage_lagcompensation");
Load(g_Options.rage_lagcompensation_type, "rage_lagcompensation_type");
Load(g_Options.rage_fixup_entities, "rage_fixup_entities");
Load(g_Options.rage_mindmg, "rage_mindmg");
Load(g_Options.rage_hitchance_amount, "rage_hitchance_amount");
Load(g_Options.rage_hitbox, "rage_hitbox");
Load(g_Options.rage_prioritize, "rage_prioritize");
Load(g_Options.rage_multipoint, "rage_multipoint");
Load(g_Options.rage_pointscale, "rage_pointscale");
LoadArray(g_Options.rage_multiHitboxes, "rage_multiHitboxes");
Load(g_Options.hvh_antiaim_x, "hvh_antiaim_x");
Load(g_Options.hvh_antiaim_y, "hvh_antiaim_y");
Load(g_Options.hvh_antiaim_y_fake, "hvh_antiaim_y_fake");
Load(g_Options.hvh_antiaim_lby_breaker, "hvh_antiaim_lby_breaker");
Load(g_Options.hvh_show_real_angles, "hvh_show_real_angles");
Load(g_Options.hvh_resolver, "hvh_resolver");
Load(g_Options.hvh_resolver_override, "hvh_resolver_override");
Load(g_Options.hvh_resolver_override_key, "hvh_resolver_override_key");
Load(g_Options.skinchanger_enabled, "skinchanger_enabled");
input_file.close();
}
CPNLBase *CPersistMatrixFlt::Load(CContextLoad *pContext)
{
CommonMatrixAttrs attrs;
pnlString text;
pContext->GetText(text);
MatrixCommonLoad(&attrs, pContext);
if(attrs.m_Class == mcDense || attrs.m_Class == mcNumericDense
|| attrs.m_Class == mc2DNumericDense)
{
floatVector data;
std::istringstream buf(text.c_str());
LoadArray<float>(buf, data);
switch(attrs.m_Class)
{
case mcDense:
return CDenseMatrix<float>::Create(attrs.m_nDim, &attrs.m_Ranges.front(),
&data.front(), attrs.m_bClamp);
case mcNumericDense:
return CNumericDenseMatrix<float>::Create(attrs.m_nDim,
&attrs.m_Ranges.front(), &data.front(), attrs.m_bClamp);
case mc2DNumericDense:
return C2DNumericDenseMatrix<float>::Create(&attrs.m_Ranges.front(),
&data.front(), attrs.m_bClamp);
}
PNL_THROW(CInvalidOperation, "Unknown matrix type");
}
CSparseMatrix<float> *pSparse;
switch(attrs.m_Class)
{
case mcSparse:
pSparse = CSparseMatrix<float>::Create(attrs.m_nDim, &attrs.m_Ranges.front(), 0);
break;
case mcNumericSparse:
pSparse = CNumericSparseMatrix<float>::Create(attrs.m_nDim,
&attrs.m_Ranges.front(), attrs.m_bClamp);
break;
case mc2DNumericSparse:
default:
PNL_THROW(CInvalidOperation, "Unknown matrix type");
break;
}
std::istringstream bufSparse(text.c_str());
intVector index;
char ch;
float val;
for(;bufSparse.good();)
{
LoadArray(bufSparse, index);
if(!bufSparse.good())
{
break;
}
if(bufSparse.peek() == ']')
{
bufSparse >> ch;
}
bufSparse >> ch;
ASSERT(ch == ':');
bufSparse >> val;
pSparse->SetElementByIndexes(val, &index.front());
}
bool Pass::Load(const void* wrapper)
{
EntityUtil::Ptr entityUtil = EntityUtil::Instance();
EnumUtil::Ptr enumUtil = EnumUtil::Instance();
std::string str;
if (!IsObject(wrapper)) return false;
if (!LoadMemberValue(wrapper, "camera", str))
{
LOGE << "Pass param 'camera' not found!";
return false;
}
if (auto camNode = entityUtil->FindEntity<SceneNode>(str))
SetCameraNode(camNode);
if (!LoadMemberValue(wrapper, "blendMode", str))
{
LOGE << "Pass param 'blendMode' not found!";
return false;
}
SetBlendMode(enumUtil->BlendModeFromString(str));
if (!LoadMemberValue(wrapper, "compareMode", str))
{
LOGE << "Pass param 'compareMode' not found!";
return false;
}
SetCompareMode(enumUtil->CompareModeFromString(str));
if (!LoadMemberValue(wrapper, "cullMode", str))
{
LOGE << "Pass param 'cullMode' not found!";
return false;
}
SetCullMode(enumUtil->CullModeFromString(str));
if (!LoadMemberValue(wrapper, "drawMode", str))
{
LOGE << "Pass param 'drawMode' not found!";
return false;
}
SetDrawMode(enumUtil->DrawModeFromString(str));
if (!LoadMemberValue(wrapper, "index", (int&)m_RenderIndex))
{
LOGE << "Pass param 'index' not found!";
return false;
}
if (!LoadArray(wrapper, "shaders", [&](const void* node) -> bool
{
if (!LoadValue(node, str))
{
LOGE << "Pass's shader name not found!";
return false;
}
if (auto shader = entityUtil->FindEntity<Shader>(str))
{
AddShader(shader);
return true;
}
else
{
LOGW << "Shader " << str << " not found!";
return false;
}
})) return false;
if (!LoadArray(wrapper, "input", [&](const void* node) -> bool
{
if (!LoadValue(node, str))
{
LOGE << "Pass's inputTexture name not found!";
return false;
}
if (auto texture = entityUtil->FindEntity<Texture>(str))
{
AddTexture(texture, true);
return true;
}
else
{
LOGW << "Input Texture " << str << " not found!";
return false;
}
})) return false;
if (!LoadArray(wrapper, "output", [&](const void* node) -> bool
{
if (!LoadValue(node, str))
{
LOGE << "Pass's outputTexture name not found!";
return false;
}
if (auto texture = entityUtil->FindEntity<Texture>(str))
{
AddTexture(texture, false);
return true;
}
else
{
LOGW << "Output Texture " << str << " not found!";
return false;
}
})) return false;
return true;
}
