Merge branch 'themrdemonized:all-in-one-vs2022-wpo' into all-in-one-vs2022-wpo

Author: Kutez

README.md

@@ -188,6 +188,12 @@ How to compile exes:
 6. For successful compilation, **the latest build tools with MFC and ATL libraries is required**
 
 ## Changelog
+**2025.04.19**
+* Lucy: (https://github.com/themrdemonized/xray-monolith/pull/171)
+  * Removal of Model Pool caused a lot of unpredictable crashes, so now it's back but with a small change to work in line with the set_shader lua methods :)
+  * Added `get_default_shaders` and `reset_shader` to easily revert a model to its vanilla shaders without the need to store default values in a table
+  * Added support for getting/setting/resetting Script Attachment model shaders/textures
+
 **2025.04.18**
 * VodoXleb: Actor camera y offset (https://github.com/themrdemonized/xray-monolith/pull/170)
 

gamedata/scripts/lua_help_ex.script

@@ -385,6 +385,39 @@
         function add_attachment(number, string);
         function get_attachment(number);
         function remove_attachment(number);
+		
+		// Shader/Textures
+		function get_shaders(bool)
+		function set_shader(number, string, string, bool)
+		function get_default_shaders(bool)
+		function reset_shader(number, bool)
+		
+		get_shaders(hud_mode)
+		hud_mode is optional and will default to false
+		returns a table of submesh IDs with subtables containing the shader and texture names of all submeshes of a model, table looks like this for example:
+		{
+		1 = 
+			{
+			texture = "act\act_face_mask_03",
+			shader = "models\model_pn",
+			},
+		2 = 
+			{
+			texture = "act\act_stalker_cskysun_2",
+			shader = "models\model_pn",
+			},
+		},
+		
+		get_default_shaders(hud_mode)
+		returns similar table as get_shaders but containing the default shader and texture names, even after they were changed by set_shader
+		
+		set_shader(id, shader, texture, hud_mode) can assign a new shader/texture to the submesh ID
+		id can be -1 to apply the shader/texture to all submeshes at once
+		shader/texture can be nil if you only want to apply one of them
+		hud_mode is optional and will default to false
+		
+		reset_shader(id, hud_mode)
+		same as set_shader but resets to the default shader/texture values, so you don't need to store them in a table to reset them later
     }
 
     class CArtefact : CGameObject {
@@ -626,6 +659,10 @@
         function set_ui_position();
         function set_ui_rotation(vector);
         function set_ui_rotation(number, number, number);
+		function get_shaders()
+		function get_default_shaders()
+		function set_shader(number, string, string)
+		function reset_shader(number)
     }
 
     flags:

src/Include/xrRender/RenderVisual.h

@@ -7,10 +7,16 @@ class IKinematicsAnimated;
 class IParticleCustom;
 struct vis_data;
 
+enum IRenderVisualFlags
+{
+	eIgnoreOptimization = (1 << 0),
+	eNoShadow = (1 << 1),
+};
+
 class IRenderVisual
 {
 public:
-	IRenderVisual() { _ignore_optimization = false; }
+	IRenderVisual() { flags.zero(); }
 
 	virtual ~IRenderVisual()
 	{
@@ -19,15 +25,25 @@ class IRenderVisual
 	virtual vis_data& _BCL getVisData() = 0;
 	virtual u32 getType() = 0;
 
-	bool _ignore_optimization;
+	Flags16 flags;
 
 #ifdef DEBUG
 	virtual shared_str	_BCL	getDebugName() = 0;
 #endif
+	virtual LPCSTR _BCL getDebugShader() { return nullptr; }
+	virtual LPCSTR _BCL getDebugTexture() { return nullptr; }
+	
+	virtual LPCSTR _BCL getDebugShaderDef() { return nullptr; }
+	virtual LPCSTR _BCL getDebugTextureDef() { return nullptr; }
+
+	virtual xr_vector<IRenderVisual*>* get_children() { return nullptr; };
 
+	virtual void SetShaderTexture(LPCSTR shader, LPCSTR texture) {};
+	virtual void ResetShaderTexture() {};
 	virtual void MarkAsHot(bool is_hot) {};				//--DSR-- HeatVision
 	virtual void MarkAsGlowing(bool is_glowing) {};		//--DSR-- SilencerOverheat
 
+	virtual IRenderVisual* _BCL dcast_RenderVisual() { return this; }
 	virtual IKinematics* _BCL dcast_PKinematics() { return 0; }
 	virtual IKinematicsAnimated* dcast_PKinematicsAnimated() { return 0; }
 	virtual IParticleCustom* dcast_ParticleCustom() { return 0; }

src/Layers/xrRender/FBasicVisual.cpp

@@ -43,6 +43,7 @@ void dxRender_Visual::Release()
 void dxRender_Visual::Load(const char* N, IReader* data, u32)
 {
 	dbg_name = N;
+	skinning = ::Render->m_skinning;
 
 	// header
 	VERIFY(data);
@@ -67,7 +68,9 @@ void dxRender_Visual::Load(const char* N, IReader* data, u32)
 		string256 fnT, fnS;
 		data->r_stringZ(fnT, sizeof(fnT));
 		data->r_stringZ(fnS, sizeof(fnS));
-		shader.create(fnS, fnT);
+		dbg_shader_def = fnS;
+		dbg_texture_def = fnT;
+		ResetShaderTexture();
 	}
 
 	// desc
@@ -116,6 +119,40 @@ void dxRender_Visual::MarkAsGlowing(bool is_glowing)
 }
 //--DSR-- SilencerOverheat_end
 
+void dxRender_Visual::SetShaderTexture(LPCSTR s_shader, LPCSTR s_texture)
+{
+	if (s_shader && strlen(s_shader))
+	{
+		char* shader = xr_strdup(s_shader);
+		char* no_shadow = strstr(shader, "$no_shadows");
+
+		if (no_shadow)
+		{
+			flags.set(IRenderVisualFlags::eNoShadow, TRUE);
+			*no_shadow = 0;
+		}
+		else
+			flags.set(IRenderVisualFlags::eNoShadow, FALSE);
+
+		dbg_shader = shader;
+		xr_delete(shader);
+	}
+
+	if (s_texture && strlen(s_texture))
+	{
+		dbg_texture = s_texture;
+	}
+
+	::Render->m_skinning = skinning;
+	shader.create(*dbg_shader, *dbg_texture);
+}
+
+void dxRender_Visual::ResetShaderTexture()
+{
+	if (!dbg_shader.equal(dbg_shader_def) || !dbg_texture.equal(dbg_texture_def))
+		SetShaderTexture(*dbg_shader_def, *dbg_texture_def);
+}
+
 #define PCOPY(a)	a = pFrom->a
 
 void dxRender_Visual::Copy(dxRender_Visual* pFrom)
@@ -126,5 +163,11 @@ void dxRender_Visual::Copy(dxRender_Visual* pFrom)
 #ifdef _EDITOR
 	PCOPY(desc);
 #endif
+	PCOPY(flags);
 	PCOPY(dbg_name);
+	PCOPY(dbg_shader);
+	PCOPY(dbg_shader_def);
+	PCOPY(dbg_texture);
+	PCOPY(dbg_texture_def);
+	PCOPY(skinning);
 }

src/Layers/xrRender/FBasicVisual.h

@@ -49,12 +49,21 @@ class ECORE_API dxRender_Visual : public IRenderVisual
     ogf_desc					desc		;
 #endif
 	shared_str					dbg_name	;
+	shared_str					dbg_shader	;
+	shared_str					dbg_texture	;
+	shared_str					dbg_shader_def	;
+	shared_str					dbg_texture_def	;
 	virtual shared_str	_BCL	getDebugName() { return dbg_name; }
+	virtual LPCSTR _BCL			getDebugShader() { return *dbg_shader; }
+	virtual LPCSTR _BCL			getDebugTexture() { return *dbg_texture; }
+	virtual LPCSTR _BCL			getDebugShaderDef() { return *dbg_shader_def; }
+	virtual LPCSTR _BCL			getDebugTextureDef() { return *dbg_texture_def; }
 public:
 	// Common data for rendering
 	u32 Type; // visual's type
 	vis_data vis; // visibility-data
 	ref_shader shader; // pipe state, shared
+	s32 skinning;
 
 	virtual void Render(float LOD)
 	{
@@ -75,6 +84,9 @@ class ECORE_API dxRender_Visual : public IRenderVisual
 	//	virtual	CKinematicsAnimated*dcast_PKinematicsAnimated	()				{ return 0;	}
 	//	virtual IParticleCustom*	dcast_ParticleCustom		()				{ return 0;	}
 
+	virtual void SetShaderTexture(LPCSTR shader, LPCSTR texture);
+	virtual void ResetShaderTexture();
+
 	virtual vis_data& _BCL getVisData() { return vis; }
 	virtual u32 getType() { return Type; }
 

src/Layers/xrRender/FHierrarhyVisual.cpp

@@ -37,7 +37,7 @@ void FHierrarhyVisual::Release()
 	if (!bDontDelete)
 	{
 		for (u32 i = 0; i < children.size(); i++)
-			children[i]->Release();
+			((dxRender_Visual*)children[i])->Release();
 	}
 }
 
@@ -55,7 +55,7 @@ void FHierrarhyVisual::Load(const char* N, IReader* data, u32 dwFlags)
 			THROW;
 #else
 			u32 ID = data->r_u32();
-			children[i] = (dxRender_Visual*)::Render->getVisual(ID);
+			children[i] = ::Render->getVisual(ID);
 #endif
 		}
 		bDontDelete = TRUE;
@@ -75,7 +75,7 @@ void FHierrarhyVisual::Load(const char* N, IReader* data, u32 dwFlags)
 					xr_strcpy(short_name, N);
 					if (strext(short_name)) *strext(short_name) = 0;
 					strconcat(sizeof(name_load), name_load, short_name, ":", itoa(count, num, 10));
-					children.push_back((dxRender_Visual*)::Render->model_CreateChild(name_load, O));
+					children.push_back(::Render->model_CreateChild(name_load, O));
 					O->close();
 					O = OBJ->open_chunk(count);
 				}
@@ -109,7 +109,7 @@ void FHierrarhyVisual::Copy(dxRender_Visual* pSrc)
 	children.reserve(pFrom->children.size());
 	for (u32 i = 0; i < pFrom->children.size(); i++)
 	{
-		dxRender_Visual* p = (dxRender_Visual*)::Render->model_Duplicate(pFrom->children[i]);
+		IRenderVisual* p = ::Render->model_Duplicate(pFrom->children[i]);
 		children.push_back(p);
 	}
 	bDontDelete = FALSE;

src/Layers/xrRender/FHierrarhyVisual.h

@@ -12,7 +12,7 @@
 class FHierrarhyVisual : public dxRender_Visual
 {
 public:
-	xr_vector<dxRender_Visual*> children;
+	xr_vector<IRenderVisual*> children;
 	BOOL bDontDelete;
 public:
 	FHierrarhyVisual();
@@ -25,6 +25,8 @@ class FHierrarhyVisual : public dxRender_Visual
 	//--DSR-- HeatVision_start
 	virtual void MarkAsHot(bool is_hot);
 	//--DSR-- HeatVision_end
+
+	virtual xr_vector<IRenderVisual*>* get_children() { return &children; };
 };
 
 #endif //FHierrarhyVisualH

src/Layers/xrRender/ModelPool.cpp

@@ -239,8 +239,7 @@ dxRender_Visual* CModelPool::Create(const char* name, IReader* data)
 	xr_strcpy(low_name, name);
 	strlwr(low_name);
 	if (strext(low_name)) *strext(low_name) = 0;
-	//	Msg						("-CREATE %s",low_name);
-
+	
 	// 0. Search POOL
 	POOL_IT it = Pool.find(low_name);
 	if (it != Pool.end())
@@ -260,8 +259,8 @@ dxRender_Visual* CModelPool::Create(const char* name, IReader* data)
 		{
 			// 2. If not found
 			bAllowChildrenDuplicate = FALSE;
-			if (data) Base = Instance_Load(low_name, data,TRUE);
-			else Base = Instance_Load(low_name,TRUE);
+			if (data) Base = Instance_Load(low_name, data, TRUE);
+			else Base = Instance_Load(low_name, TRUE);
 			bAllowChildrenDuplicate = TRUE;
 #ifdef _EDITOR
 			if (!Base)		return 0;
@@ -312,7 +311,14 @@ void CModelPool::DeleteInternal(dxRender_Visual* & V, BOOL bDiscard)
 		REGISTRY_IT it = Registry.find(V);
 		if (it != Registry.end())
 		{
-			// Registry entry found - move it to pool
+			// Registry entry found - move it to pool and reset changed shader/texture if necessary
+			xr_vector<IRenderVisual*>* children = V->get_children();
+			if (children)
+				for (auto* child : *children)
+					child->ResetShaderTexture();
+			else
+				V->ResetShaderTexture();
+
 			Pool.insert(mk_pair(it->second, V));
 		}
 		else
@@ -352,8 +358,6 @@ void CModelPool::Discard(dxRender_Visual* & V, BOOL b_complete)
 	REGISTRY_IT it = Registry.find(V);
 	if (it != Registry.end())
 	{
-		// Pool - OK
-
 		// Base
 		const shared_str& name = it->second;
 		xr_vector<ModelDef>::iterator I = Models.begin();
@@ -387,7 +391,6 @@ void CModelPool::Discard(dxRender_Visual* & V, BOOL b_complete)
 		}
 		// Registry
 		xr_delete(V);
-		//.		xr_free			(name);
 		Registry.erase(it);
 	}
 	else
@@ -420,17 +423,6 @@ void CModelPool::Prefetch_One(LPCSTR N)
 	Delete(V,FALSE);
 }
 
-void CModelPool::ClearPool(BOOL b_complete)
-{
-	POOL_IT _I = Pool.begin();
-	POOL_IT _E = Pool.end();
-	for (; _I != _E; _I++)
-	{
-		Discard(_I->second, b_complete);
-	}
-	Pool.clear();
-}
-
 dxRender_Visual* CModelPool::CreatePE(PS::CPEDef* source)
 {
 	PS::CParticleEffect* V = (PS::CParticleEffect*)Instance_Create(MT_PARTICLE_EFFECT);
@@ -445,6 +437,17 @@ dxRender_Visual* CModelPool::CreatePG(PS::CPGDef* source)
 	return V;
 }
 
+void CModelPool::ClearPool(BOOL b_complete)
+{
+	POOL_IT _I = Pool.begin();
+	POOL_IT _E = Pool.end();
+	for (; _I != _E; _I++)
+	{
+		Discard(_I->second, b_complete);
+	}
+	Pool.clear();
+}
+
 void CModelPool::dump()
 {
 	Log("--- model pool --- begin:");

src/Layers/xrRender/SkeletonCustom.cpp

@@ -585,7 +585,7 @@ void CKinematics::Visibility_Update()
 		if (!_c->has_visible_bones())
 		{
 			// move into invisible list
-			children_invisible.push_back(children[c_it]);
+			children_invisible.push_back((dxRender_Visual*)children[c_it]);
 			swap(children[c_it], children.back());
 			children.pop_back();
 			Update_Visibility = TRUE;