nullworks/cathook
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

idk

Browse Source
This commit is contained in:
nullifiedcat 2017-04-17 20:57:11 +03:00
parent b06a140b16
commit b6a77dd839
6 changed files with 236 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/EffectChams.cpp
View File

@ -10,6 +10,8 @@
//static CatVar chams_experimental(CV_SWITCH, "chams_effect", "0", "Experimental Chams"); //static CatVar chams_experimental(CV_SWITCH, "chams_effect", "0", "Experimental Chams");
namespace effect_chams {
CatVar enable(CV_SWITCH, "chams_enable", "0", "Enable"); CatVar enable(CV_SWITCH, "chams_enable", "0", "Enable");
static CatVar flat(CV_SWITCH, "chams_flat", "0", "Flat"); static CatVar flat(CV_SWITCH, "chams_flat", "0", "Flat");
static CatVar health(CV_SWITCH, "chams_health", "0", "Health"); static CatVar health(CV_SWITCH, "chams_health", "0", "Health");
@ -57,7 +59,6 @@ void EffectChams::Init() {
void EffectChams::BeginRenderChams() { void EffectChams::BeginRenderChams() {
drawing = true; drawing = true;
CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem)); CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem));
g_IVRenderView->SetBlend(1.0f);
} }
void EffectChams::EndRenderChams() { void EffectChams::EndRenderChams() {
@ -170,7 +171,6 @@ void EffectChams::Render(int x, int y, int w, int h) {
if (g_IEngine->IsTakingScreenshot() && clean_screenshots) return; if (g_IEngine->IsTakingScreenshot() && clean_screenshots) return;
if (!enable) return; if (!enable) return;
CMatRenderContextPtr ptr(g_IMaterialSystem->GetRenderContext()); CMatRenderContextPtr ptr(g_IMaterialSystem->GetRenderContext());
BeginRenderChams(); BeginRenderChams();
for (int i = 1; i < HIGHEST_ENTITY; i++) { for (int i = 1; i < HIGHEST_ENTITY; i++) {
IClientEntity* ent = g_IEntityList->GetClientEntity(i); IClientEntity* ent = g_IEntityList->GetClientEntity(i);
@ -183,3 +183,5 @@ void EffectChams::Render(int x, int y, int w, int h) {
EffectChams g_EffectChams; EffectChams g_EffectChams;
CScreenSpaceEffectRegistration* g_pEffectChams = nullptr; CScreenSpaceEffectRegistration* g_pEffectChams = nullptr;
}

4
src/EffectChams.hpp
View File

@ -10,6 +10,8 @@
#include "common.h" #include "common.h"
namespace effect_chams {
class EffectChams : public IScreenSpaceEffect { class EffectChams : public IScreenSpaceEffect {
public: public:
virtual void Init( ); virtual void Init( );
@ -41,4 +43,6 @@ public:
extern EffectChams g_EffectChams; extern EffectChams g_EffectChams;
extern CScreenSpaceEffectRegistration* g_pEffectChams; extern CScreenSpaceEffectRegistration* g_pEffectChams;
}
#endif /* EFFECTCHAMS_HPP_ */ #endif /* EFFECTCHAMS_HPP_ */

335
src/EffectGlow.cpp
View File

@ -10,7 +10,6 @@
IMaterialSystem* materials = nullptr; IMaterialSystem* materials = nullptr;
// FIXME move to sdk
CScreenSpaceEffectRegistration *CScreenSpaceEffectRegistration::s_pHead = NULL; CScreenSpaceEffectRegistration *CScreenSpaceEffectRegistration::s_pHead = NULL;
IScreenSpaceEffectManager* g_pScreenSpaceEffects = nullptr; IScreenSpaceEffectManager* g_pScreenSpaceEffects = nullptr;
CScreenSpaceEffectRegistration** g_ppScreenSpaceRegistrationHead = nullptr; CScreenSpaceEffectRegistration** g_ppScreenSpaceRegistrationHead = nullptr;
@ -24,156 +23,242 @@ CScreenSpaceEffectRegistration::CScreenSpaceEffectRegistration( const char *pNam
logging::Info("New head: 0x%08x", *g_ppScreenSpaceRegistrationHead); logging::Info("New head: 0x%08x", *g_ppScreenSpaceRegistrationHead);
} }
/*IMaterial* GetRenderTarget() { namespace effect_glow {
if (!tr_cathook_rt) {
tr_cathook_rt.InitRenderTarget(256, 256, RT_SIZE_FULL_FRAME_BUFFER, IMAGE_FORMAT_ARGB8888, MATERIAL_RT_DEPTH_NONE, false, "cathook_rt");
}
return tr_cathook_rt.;
}*/
IMaterial* GetGlowMaterial() { CatVar enable(CV_SWITCH, "glow_experimental_enable", "0", "Enable");
return vfunc<IMaterial*(*)(IMaterialSystemFixed*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/glow_color", TEXTURE_GROUP_OTHER, true, 0); static CatVar health(CV_SWITCH, "glow_experimental_health", "0", "Health");
} static CatVar teammates(CV_SWITCH, "glow_experimental_teammates", "0", "Teammates");
static CatVar players(CV_SWITCH, "glow_experimental_players", "1", "Players");
static CatVar glow_experimental(CV_SWITCH, "glow_experimental", "0", "Experimental Glow"); static CatVar medkits(CV_SWITCH, "glow_experimental_medkits", "0", "Medkits");
static CatVar ammobox(CV_SWITCH, "glow_experimental_ammo", "0", "Ammoboxes");
static CatVar buildings(CV_SWITCH, "glow_experimental_buildings", "0", "Buildings");
static CatVar stickies(CV_SWITCH, "glow_experimental_stickies", "0", "Stickies");
static CatVar teammate_buildings(CV_SWITCH, "glow_experimental_teammate_buildings", "0", "Teammate Buildings");
void EffectGlow::Init() { void EffectGlow::Init() {
logging::Info("Init EffectGlow..."); logging::Info("Init EffectChams...");
rt_A.InitRenderTarget(1920/2, 1080/2, RT_SIZE_DEFAULT, IMAGE_FORMAT_RGBA8888, MATERIAL_RT_DEPTH_SEPARATE, false, "__cathook_glow_rta"); {
rt_B.InitRenderTarget(1920/2, 1080/2, RT_SIZE_DEFAULT, IMAGE_FORMAT_RGBA8888, MATERIAL_RT_DEPTH_SEPARATE, false, "__cathook_glow_rtb"); KeyValues* kv = new KeyValues("UnlitGeneric");
logging::Info("Textures init!"); kv->SetString("$basetexture", "vgui/white_additive");
//rt_B.InitRenderTarget(256, 256, RT_SIZE_FULL_FRAME_BUFFER, IMAGE_FORMAT_ARGB8888, MATERIAL_RT_DEPTH_NONE, false, "__cathook_glow_rtB"); kv->SetInt("$ignorez", 0);
KeyValues *kv2 = new KeyValues( "VertexLitGeneric" ); mat_unlit.Init("__cathook_echams_unlit", kv);
kv2->SetString( "$basetexture", "vgui/white" ); }
kv2->SetInt( "$selfillum", 1 ); {
kv2->SetString( "$selfillummask", "vgui/white" ); KeyValues* kv = new KeyValues("UnlitGeneric");
kv2->SetInt( "$vertexalpha", 1 ); kv->SetString("$basetexture", "vgui/white_additive");
kv2->SetInt( "$model", 1 ); kv->SetInt("$ignorez", 1);
glow_material.Init( "__cathook_glow_mat_color", TEXTURE_GROUP_CLIENT_EFFECTS, kv2 ); mat_unlit_z.Init("__cathook_echams_unlit_z", kv);
glow_material->Refresh(); }
KeyValues* kv = new KeyValues("UnlitGeneric");
kv->SetString("$basetexture", "_rt_FullFrameFB");
kv->SetInt("$additive", 1);
result_material.Init("__cathook_glow_mat", TEXTURE_GROUP_CLIENT_EFFECTS, kv);
result_material->Refresh();
logging::Info("Material init!");
//dev_glow_color.Init(vfunc<IMaterial*(*)(IMaterialSystem*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/glow_color", TEXTURE_GROUP_OTHER, true, 0));
dev_bloomdadd.Init(vfunc<IMaterial*(*)(IMaterialSystemFixed*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/bloomadd", TEXTURE_GROUP_OTHER, true, 0));
dev_blurfilterx.Init(vfunc<IMaterial*(*)(IMaterialSystemFixed*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/blurfilterx", TEXTURE_GROUP_OTHER, true, 0));
dev_blurfiltery.Init(vfunc<IMaterial*(*)(IMaterialSystemFixed*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/blurfiltery", TEXTURE_GROUP_OTHER, true, 0));
dev_halo_add_to_screen.Init(vfunc<IMaterial*(*)(IMaterialSystemFixed*, const char*, const char*, bool, const char*)>(g_IMaterialSystem, 73)(g_IMaterialSystem, "dev/halo_add_to_screen", TEXTURE_GROUP_OTHER, true, 0));
logging::Info("Init done!"); logging::Info("Init done!");
init = true; init = true;
} }
void EffectGlow::BeginRenderGlow() { void EffectGlow::BeginRenderChams() {
drawing = true;
CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem)); CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem));
ptr->PushRenderTargetAndViewport(rt_A);
g_IVModelRender->SuppressEngineLighting(true);
g_IVRenderView->GetColorModulation(orig_modulation);
static Vector red(1.0f, 0.1f, 0.1f);
g_IVRenderView->SetColorModulation(red.Base());
g_IStudioRender->ForcedMaterialOverride(glow_material);
g_IVRenderView->SetBlend(1.0f);
} }
void EffectGlow::EndRenderGlow() { void EffectGlow::EndRenderChams() {
drawing = false;
CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem)); CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem));
g_IVRenderView->SetColorModulation(orig_modulation); g_IVModelRender->ForcedMaterialOverride(nullptr);
g_IStudioRender->ForcedMaterialOverride(nullptr);
g_IVModelRender->SuppressEngineLighting(false);
ptr->PopRenderTargetAndViewport();
} }
void EffectGlow::RenderGlow(int idx) { int EffectGlow::ChamsColor(IClientEntity* entity) {
CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem)); CachedEntity* ent = ENTITY(entity->entindex());
ptr->PushRenderTargetAndViewport( rt_A ); if (CE_BAD(ent)) return colors::white;
if (vfunc<bool(*)(IClientEntity*)>(entity, 0xBE, 0)(entity)) {
IClientEntity* owner = vfunc<IClientEntity*(*)(IClientEntity*)>(entity, 0x1C3, 0)(entity);
if (owner) {
return ChamsColor(owner);
}
}
switch (ent->m_Type) {
case ENTITY_BUILDING:
if (!ent->m_bEnemy && !(teammates || teammate_buildings)) {
return 0;
}
if (health) {
return colors::Health(ent->m_iHealth, ent->m_iMaxHealth);
}
break;
case ENTITY_PLAYER:
if (!players) return 0;
if (!ent->m_bEnemy && !teammates) return 0;
if (health) {
return colors::Health(ent->m_iHealth, ent->m_iMaxHealth);
}
break;
}
return colors::EntityF(ent);
}
g_IVModelRender->SuppressEngineLighting( true ); bool EffectGlow::ShouldRenderChams(IClientEntity* entity) {
if (!enable) return false;
// Set the glow tint since selfillum trumps color modulation if (entity->entindex() < 0) return false;
IMaterialVar *var = glow_material->FindVar( "$selfillumtint", NULL, false ); CachedEntity* ent = ENTITY(entity->entindex());
static float color[4] = { 1.0f, 0.0f, 0.0f, 1.0f }; if (CE_BAD(ent)) return false;
var->SetVecValue( color, 4 ); // Fixed compilation error /*if (weapons && vfunc<bool(*)(IClientEntity*)>(entity, 0xBE, 0)(entity)) {
var = glow_material->FindVar( "$alpha", NULL, false ); IClientEntity* owner = vfunc<IClientEntity*(*)(IClientEntity*)>(entity, 0x1C3, 0)(entity);
var->SetFloatValue( color[3] ); // Fixed compilation error if (owner) {
return ShouldRenderChams(owner);
g_IVModelRender->ForcedMaterialOverride( glow_material ); }
IClientEntity* ent = g_IEntityList->GetClientEntity(idx);
if (ent) ent->DrawModel(1);
g_IVModelRender->ForcedMaterialOverride( NULL );
g_IVModelRender->SuppressEngineLighting( false );
ptr->PopRenderTargetAndViewport();
/*IClientEntity* ent = g_IEntityList->GetClientEntity(idx);
if (ent) {
ent->DrawModel(1);
}*/ }*/
switch (ent->m_Type) {
case ENTITY_BUILDING:
if (!buildings) return false;
if (!ent->m_bEnemy && !(teammate_buildings || teammates)) return false;
return true;
case ENTITY_PLAYER:
if (!players) return false;
if (!teammates && !ent->m_bEnemy) return false;
if (CE_BYTE(ent, netvar.iLifeState) != LIFE_ALIVE) return false;
return true;
break;
case ENTITY_PROJECTILE:
if (!ent->m_bEnemy) return false;
if (stickies && ent->m_iClassID == g_pClassID->CTFGrenadePipebombProjectile) {
return true;
}
break;
case ENTITY_GENERIC:
switch (ent->m_ItemType) {
case ITEM_HEALTH_LARGE:
case ITEM_HEALTH_MEDIUM:
case ITEM_HEALTH_SMALL:
return medkits;
case ITEM_AMMO_LARGE:
case ITEM_AMMO_MEDIUM:
case ITEM_AMMO_SMALL:
return ammobox;
}
break;
}
return false;
}
static CTextureReference buffers[4] {};
ITexture* GetBuffer(int i) {
if (!buffers[i]) {
ITexture* fullframe = g_IMaterialSystem->FindTexture("_rt_FullFrameFB", TEXTURE_GROUP_RENDER_TARGET);
char* newname = new char[32];
std::string name = format("_cathook_buff", i);
strncpy(newname, name.c_str(), 30);
logging::Info("Creating new buffer %d with size %dx%d %s", i, fullframe->GetActualWidth(), fullframe->GetActualHeight(), newname);
int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT | TEXTUREFLAGS_EIGHTBITALPHA;
int renderTargetFlags = CREATERENDERTARGETFLAGS_HDR;
ITexture* texture = g_IMaterialSystem->CreateNamedRenderTargetTextureEx( newname, fullframe->GetActualWidth(), fullframe->GetActualHeight(), RT_SIZE_LITERAL, IMAGE_FORMAT_RGBA8888,
MATERIAL_RT_DEPTH_SEPARATE, textureFlags, renderTargetFlags );
buffers[i].Init(texture);
//buffers[i].InitRenderTarget(fullframe->GetActualWidth(), fullframe->GetActualHeight(), RenderTargetSizeMode_t::RT_SIZE_FULL_FRAME_BUFFER, IMAGE_FORMAT_ABGR8888, MaterialRenderTargetDepth_t::MATERIAL_RT_DEPTH_SEPARATE, true, newname);
}
return buffers[i];
}
IMaterial* GetBlurX() {
static CMaterialReference blur;
if (!blur) {
GetBuffer(1);
KeyValues* kv = new KeyValues("BlurFilterX");
kv->SetString("$basetexture", "_cathook_buff1");
kv->SetInt("$ignorez", 1);
kv->SetInt("$translucent", 1);
kv->SetInt("$alphatest", 1);
blur.Init("_cathook_blurx", kv);
blur->Refresh();
}
return blur;
}
IMaterial* GetBlurY() {
static CMaterialReference blur;
if (!blur) {
GetBuffer(2);
KeyValues* kv = new KeyValues("BlurFilterY");
kv->SetString("$basetexture", "_cathook_buff2");
kv->SetInt("$bloomamount", 5);
kv->SetInt("$ignorez", 1);
kv->SetInt("$translucent", 1);
kv->SetInt("$alphatest", 1);
blur.Init("_cathook_blury", kv);
blur->Refresh();
}
return blur;
}
void EffectGlow::RenderChams(int idx) {
CMatRenderContextPtr ptr(g_IMaterialSystem->GetRenderContext());
IClientEntity* entity = g_IEntityList->GetClientEntity(idx);
if (entity && !entity->IsDormant()) {
if (ShouldRenderChams(entity)) {
int color = ChamsColor(entity);
unsigned char _b = (color >> 16) & 0xFF;
unsigned char _g = (color >> 8) & 0xFF;
unsigned char _r = (color) & 0xFF;
float color_1[] = { (float)_r / 255.0f, (float)_g / 255.0f, (float)_b / 255.0f };
float color_2[] = { color_1[0] * 0.6f, color_1[1] * 0.6f, color_1[2] * 0.6f };
mat_unlit_z->AlphaModulate(1.0f);
ptr->DepthRange(0.0f, 0.01f);
g_IVRenderView->SetColorModulation(color_1);
g_IVModelRender->ForcedMaterialOverride(mat_unlit_z);
entity->DrawModel(1);
//((DrawModelExecute_t)(hooks::hkIVModelRender->GetMethod(hooks::offDrawModelExecute)))(_this, state, info, matrix);
mat_unlit->AlphaModulate(1.0f);
g_IVRenderView->SetColorModulation(color_2);
ptr->DepthRange(0.0f, 1.0f);
g_IVModelRender->ForcedMaterialOverride(mat_unlit);
entity->DrawModel(1);
}
}
} }
void EffectGlow::Render(int x, int y, int w, int h) { void EffectGlow::Render(int x, int y, int w, int h) {
if (!init) Init(); if (!init) Init();
if (!glow_experimental) return; if (g_IEngine->IsTakingScreenshot() && clean_screenshots) return;
CMatRenderContextPtr ptr(vfunc<IMatRenderContext*(*)(IMaterialSystemFixed*)>(g_IMaterialSystem, 100, 0)(g_IMaterialSystem)); if (!enable) return;
CMatRenderContextPtr ptr(g_IMaterialSystem->GetRenderContext());
//ptr->Viewport(x, y, w, h); ITexture* orig = ptr->GetRenderTarget();
ptr->ClearColor4ub(0, 0, 0, 0);
ITexture* rt = ptr->GetRenderTarget(); ptr->PushRenderTargetAndViewport();
ptr->SetRenderTarget(GetBuffer(1));
IMaterialVar* var; ptr->Viewport(x, y, w, h);
var = dev_blurfilterx->FindVar("$basetexture", nullptr); ptr->OverrideAlphaWriteEnable( true, true );
var->SetTextureValue(rt_A); g_IVRenderView->SetBlend(0.99f);
var = dev_blurfiltery->FindVar("$basetexture", nullptr); ptr->ClearBuffers(true, false);
var->SetTextureValue(rt_B); BeginRenderChams();
var = result_material->FindVar("$basetexture", nullptr); for (int i = 1; i < HIGHEST_ENTITY; i++) {
var->SetTextureValue(rt_A);
//var = dev_blurfilterx->FindVar("$bloomamount", nullptr);
//var->SetFloatValue(10);
var = dev_blurfiltery->FindVar("$bloomamount", nullptr);
var->SetFloatValue(10);
ptr->ClearColor4ub(0, 0, 0, 255);
ptr->PushRenderTargetAndViewport(rt_A);
ptr->ClearBuffers(true, true);
ptr->PopRenderTargetAndViewport();
ptr->PushRenderTargetAndViewport(rt_B);
ptr->ClearBuffers(true, true);
ptr->PopRenderTargetAndViewport();
ptr->ClearStencilBufferRectangle( 0, 0, 1920, 1080, 0 );
BeginRenderGlow();
for (int i = 1; i < 32; i++) {
IClientEntity* ent = g_IEntityList->GetClientEntity(i); IClientEntity* ent = g_IEntityList->GetClientEntity(i);
if (ent && !ent->IsDormant() && NET_BYTE(ent, netvar.iLifeState) == LIFE_ALIVE) { if (ent && !ent->IsDormant()) {
//BeginRenderGlow(); RenderChams(i);
RenderGlow(i);
//EndRenderGlow();
} }
} }
EndRenderChams();
ptr->PushRenderTargetAndViewport( rt_B ); ptr->SetRenderTarget(GetBuffer(2));
ptr->Viewport(x, y, w, h);
ptr->ClearBuffers(true, false);
ptr->DrawScreenSpaceRectangle(GetBlurX(), x, y, w, h, 0, 0, w - 1, h - 1, w, h);
static CMaterialReference blitmat;
if (!blitmat) {
KeyValues *kv = new KeyValues( "UnlitGeneric" );
kv->SetString( "$basetexture", "_cathook_buff1" );
kv->SetInt( "$additive", 1 );
blitmat.Init( "_cathook_composite", TEXTURE_GROUP_CLIENT_EFFECTS, kv );
blitmat->Refresh();
}
ptr->SetRenderTarget(GetBuffer(1));
ptr->DrawScreenSpaceRectangle(GetBlurY(), x, y, w, h, 0, 0, w - 1, h - 1, w, h);
ptr->Viewport(x, y, w, h); ptr->Viewport(x, y, w, h);
ptr->DrawScreenSpaceQuad( dev_blurfilterx );
ptr->PopRenderTargetAndViewport(); ptr->PopRenderTargetAndViewport();
ptr->DrawScreenSpaceRectangle(blitmat, x, y, w, h, 0, 0, w - 1, h - 1, w, h);
ptr->PushRenderTargetAndViewport( rt_A );
ptr->Viewport(x, y, w, h);
ptr->DrawScreenSpaceQuad( dev_blurfiltery );
ptr->PopRenderTargetAndViewport();
ptr->SetRenderTarget(rt);
ptr->Viewport(x, y, w, h);
ptr->DrawScreenSpaceQuad(result_material);
var = result_material->FindVar("$basetexture", nullptr);
//var->SetTextureValue(rt_B);
//ptr->DrawScreenSpaceQuad(result_material);
} }
EffectGlow g_EffectGlow; EffectGlow g_EffectGlow;
CScreenSpaceEffectRegistration* g_pEffectGlow = nullptr; CScreenSpaceEffectRegistration* g_pEffectGlow = nullptr;
}

23
src/EffectGlow.hpp
View File

@ -10,6 +10,8 @@
#include "common.h" #include "common.h"
namespace effect_glow {
class EffectGlow : public IScreenSpaceEffect { class EffectGlow : public IScreenSpaceEffect {
public: public:
virtual void Init( ); virtual void Init( );
@ -22,24 +24,23 @@ public:
inline virtual void Enable( bool bEnable ) { enabled = bEnable; }; inline virtual void Enable( bool bEnable ) { enabled = bEnable; };
inline virtual bool IsEnabled( ) { return enabled; }; inline virtual bool IsEnabled( ) { return enabled; };
void RenderGlow(int idx); int ChamsColor(IClientEntity* entity);
void BeginRenderGlow(); bool ShouldRenderChams(IClientEntity* entity);
void EndRenderGlow(); void RenderChams(int idx);
void BeginRenderChams();
void EndRenderChams();
public: public:
bool init { false }; bool init { false };
bool drawing { false };
bool enabled; bool enabled;
float orig_modulation[3]; float orig_modulation[3];
CTextureReference rt_A; CMaterialReference mat_unlit;
CTextureReference rt_B; CMaterialReference mat_unlit_z;
CMaterialReference result_material;
CMaterialReference glow_material;
CMaterialReference dev_bloomdadd;
CMaterialReference dev_halo_add_to_screen;
CMaterialReference dev_blurfilterx;
CMaterialReference dev_blurfiltery;
}; };
extern EffectGlow g_EffectGlow; extern EffectGlow g_EffectGlow;
extern CScreenSpaceEffectRegistration* g_pEffectGlow; extern CScreenSpaceEffectRegistration* g_pEffectGlow;
}
#endif /* EFFECTGLOW_HPP_ */ #endif /* EFFECTGLOW_HPP_ */

10
src/hack.cpp
View File

@ -183,15 +183,15 @@ void hack::Initialize() {
hack::command_stack().push("cat_spam_reload"); hack::command_stack().push("cat_spam_reload");
logging::Info("Hooked!"); logging::Info("Hooked!");
playerlist::Load(); playerlist::Load();
g_pEffectChams = new CScreenSpaceEffectRegistration("_cathook_chams", &g_EffectChams); effect_chams::g_pEffectChams = new CScreenSpaceEffectRegistration("_cathook_chams", &effect_chams::g_EffectChams);
g_pScreenSpaceEffects->EnableScreenSpaceEffect("_cathook_chams"); g_pScreenSpaceEffects->EnableScreenSpaceEffect("_cathook_chams");
g_EffectChams.Init(); effect_chams::g_EffectChams.Init();
//g_pEffectGlow = new CScreenSpaceEffectRegistration("_cathook_glow", &g_EffectGlow); effect_glow::g_pEffectGlow = new CScreenSpaceEffectRegistration("_cathook_glow", &effect_glow::g_EffectGlow);
//for (CScreenSpaceEffectRegistration* reg = *g_ppScreenSpaceRegistrationHead; reg; reg = reg->m_pNext) { //for (CScreenSpaceEffectRegistration* reg = *g_ppScreenSpaceRegistrationHead; reg; reg = reg->m_pNext) {
// logging::Info("%s", reg->m_pEffectName); // logging::Info("%s", reg->m_pEffectName);
//} //}
//g_pScreenSpaceEffects->EnableScreenSpaceEffect("_cathook_glow"); g_pScreenSpaceEffects->EnableScreenSpaceEffect("_cathook_glow");
//g_EffectGlow.Init(); effect_glow::g_EffectGlow.Init();
logging::Info("SSE enabled.."); logging::Info("SSE enabled..");
} }

2
src/hooks/others.cpp
View File

@ -58,7 +58,7 @@ void DrawModelExecute_hook(IVModelRender* _this, const DrawModelState_t& state,
IClientUnknown* unk = info.pRenderable->GetIClientUnknown(); IClientUnknown* unk = info.pRenderable->GetIClientUnknown();
if (unk) { if (unk) {
IClientEntity* ent = unk->GetIClientEntity(); IClientEntity* ent = unk->GetIClientEntity();
if (ent && !g_EffectChams.drawing && g_EffectChams.ShouldRenderChams(ent)) { if (ent && !effect_chams::g_EffectChams.drawing && effect_chams::g_EffectChams.ShouldRenderChams(ent)) {
return; return;
} }
} }