Merge pull request #171 from xr-lucy/lucy-game-object-shader-texture-changing

Lucy game object shader texture changing

Author: themrdemonized

gamedata/scripts/lua_help_ex.script

@@ -389,6 +389,8 @@
 		// 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
@@ -406,10 +408,16 @@
 			},
 		},
 
+		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 {
@@ -651,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

@@ -32,10 +32,14 @@ class IRenderVisual
 #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(char* shader, LPCSTR texture) {};
+	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
 

src/Layers/xrRender/FBasicVisual.cpp

@@ -68,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));
-		SetShaderTexture(fnS, fnT);
+		dbg_shader_def = fnS;
+		dbg_texture_def = fnT;
+		ResetShaderTexture();
 	}
 
 	// desc
@@ -117,11 +119,12 @@ void dxRender_Visual::MarkAsGlowing(bool is_glowing)
 }
 //--DSR-- SilencerOverheat_end
 
-void dxRender_Visual::SetShaderTexture(char* s_shader, LPCSTR s_texture)
+void dxRender_Visual::SetShaderTexture(LPCSTR s_shader, LPCSTR s_texture)
 {
 	if (s_shader && strlen(s_shader))
 	{
-		char* no_shadow = strstr(s_shader, "$no_shadows");
+		char* shader = xr_strdup(s_shader);
+		char* no_shadow = strstr(shader, "$no_shadows");
 
 		if (no_shadow)
 		{
@@ -131,7 +134,8 @@ void dxRender_Visual::SetShaderTexture(char* s_shader, LPCSTR s_texture)
 		else
 			flags.set(IRenderVisualFlags::eNoShadow, FALSE);
 
-		dbg_shader = s_shader;
+		dbg_shader = shader;
+		xr_delete(shader);
 	}
 
 	if (s_texture && strlen(s_texture))
@@ -143,6 +147,12 @@ void dxRender_Visual::SetShaderTexture(char* s_shader, LPCSTR s_texture)
 	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)
@@ -156,6 +166,8 @@ void dxRender_Visual::Copy(dxRender_Visual* pFrom)
 	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

@@ -51,9 +51,13 @@ class ECORE_API dxRender_Visual : public IRenderVisual
 	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
@@ -80,7 +84,8 @@ class ECORE_API dxRender_Visual : public IRenderVisual
 	//	virtual	CKinematicsAnimated*dcast_PKinematicsAnimated	()				{ return 0;	}
 	//	virtual IParticleCustom*	dcast_ParticleCustom		()				{ return 0;	}
 
-	virtual void SetShaderTexture(char* shader, LPCSTR texture);
+	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/ModelPool.cpp

@@ -171,6 +171,9 @@ void CModelPool::Instance_Register(LPCSTR N, dxRender_Visual* V)
 
 void CModelPool::Destroy()
 {
+	// Pool
+	Pool.clear();
+
 	// Registry
 	while (!Registry.empty())
 	{
@@ -237,21 +240,37 @@ dxRender_Visual* CModelPool::Create(const char* name, IReader* data)
 	strlwr(low_name);
 	if (strext(low_name)) *strext(low_name) = 0;
 
-	// 1. Search for already loaded model (reference, base model)
-	dxRender_Visual* Base = Instance_Find(low_name);
-	if (0 == Base)
+	// 0. Search POOL
+	POOL_IT it = Pool.find(low_name);
+	if (it != Pool.end())
 	{
-		// 2. If not found
-		bAllowChildrenDuplicate = FALSE;
-		if (data) Base = Instance_Load(low_name, data, TRUE);
-		else Base = Instance_Load(low_name, TRUE);
-		bAllowChildrenDuplicate = TRUE;
+		// 1. Instance found
+		dxRender_Visual* Model = it->second;
+		Model->Spawn();
+		Pool.erase(it);
+		return Model;
 	}
+	else
+	{
+		// 1. Search for already loaded model (reference, base model)
+		dxRender_Visual* Base = Instance_Find(low_name);
 
-	// 3. If found - return (cloned) reference
-	dxRender_Visual* Model = Instance_Duplicate(Base);
-	Registry.insert(mk_pair(Model, low_name));
-	return Model;
+		if (0 == Base)
+		{
+			// 2. If not found
+			bAllowChildrenDuplicate = FALSE;
+			if (data) Base = Instance_Load(low_name, data, TRUE);
+			else Base = Instance_Load(low_name, TRUE);
+			bAllowChildrenDuplicate = TRUE;
+#ifdef _EDITOR
+			if (!Base)		return 0;
+#endif
+		}
+		// 3. If found - return (cloned) reference
+		dxRender_Visual* Model = Instance_Duplicate(Base);
+		Registry.insert(mk_pair(Model, low_name));
+		return Model;
+	}
 }
 
 dxRender_Visual* CModelPool::CreateChild(LPCSTR name, IReader* data)
@@ -282,7 +301,32 @@ void CModelPool::DeleteInternal(dxRender_Visual* & V, BOOL bDiscard)
 	VERIFY(!g_bRendering);
 	if (!V) return;
 	V->Depart();
-	Discard(V, bDiscard || bForceDiscard);
+	if (bDiscard || bForceDiscard)
+	{
+		Discard(V, TRUE);
+	}
+	else
+	{
+		//
+		REGISTRY_IT it = Registry.find(V);
+		if (it != Registry.end())
+		{
+			// 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
+		{
+			// Registry entry not-found - just special type of visual / particles / etc.
+			xr_delete(V);
+		}
+	}
 	V = NULL;
 }
 
@@ -291,18 +335,20 @@ void CModelPool::Delete(dxRender_Visual* & V, BOOL bDiscard)
 	if (NULL == V) return;
 	if (g_bRendering)
 	{
-		ModelsToDelete.insert(mk_pair(V, !!bDiscard));
+		VERIFY(!bDiscard);
+		ModelsToDelete.push_back(V);
 	}
 	else
 	{
 		DeleteInternal(V, bDiscard);
 	}
+	V = NULL;
 }
 
 void CModelPool::DeleteQueue()
 {
-	for (xr_map<dxRender_Visual*, bool>::iterator it = ModelsToDelete.begin(); it != ModelsToDelete.end(); it++)
-		DeleteInternal((dxRender_Visual*)it->first, it->second);
+	for (u32 it = 0; it < ModelsToDelete.size(); it++)
+		DeleteInternal(ModelsToDelete[it]);
 	ModelsToDelete.clear();
 }
 
@@ -391,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:");
@@ -409,6 +466,7 @@ void CModelPool::dump()
 	Msg("--- models: %d, mem usage: %d Kb ", k, sz / 1024);
 	sz = 0;
 	k = 0;
+	int free_cnt = 0;
 	for (REGISTRY_IT it = Registry.begin(); it != Registry.end(); it++)
 	{
 		CKinematics* K = PCKinematics((dxRender_Visual*)it->first);
@@ -417,10 +475,12 @@ void CModelPool::dump()
 		{
 			u32 cur = K->mem_usage(true);
 			sz += cur;
-			Msg("#%3d: [%5d Kb] - %s", k++, cur / 1024, it->second.c_str());
+			bool b_free = (Pool.find(it->second) != Pool.end());
+			if (b_free) ++free_cnt;
+			Msg("#%3d: [%s] [%5d Kb] - %s", k++, (b_free) ? "free" : "used", cur / 1024, it->second.c_str());
 		}
 	}
-	Msg("--- instances: %d, mem usage: %d Kb ", k, sz / 1024);
+	Msg("--- instances: %d, free %d, mem usage: %d Kb ", k, free_cnt, sz / 1024);
 	Log("--- model pool --- end.");
 }
 

src/Layers/xrRender/ModelPool.h

@@ -18,6 +18,14 @@ class ECORE_API CModelPool
 private:
 	friend class CRender;
 
+	struct str_pred : public std::binary_function<const shared_str&, const shared_str&, bool>
+	{
+		IC bool operator()(const shared_str& x, const shared_str& y) const
+		{
+			return xr_strcmp(x, y) < 0;
+		}
+	};
+
 	struct ModelDef
 	{
 		shared_str name;
@@ -31,12 +39,15 @@ class ECORE_API CModelPool
 		}
 	};
 
+	typedef xr_multimap<shared_str, dxRender_Visual*, str_pred> POOL;
+	typedef POOL::iterator POOL_IT;
 	typedef xr_map<dxRender_Visual*, shared_str> REGISTRY;
 	typedef REGISTRY::iterator REGISTRY_IT;
 private:
 	xr_vector<ModelDef> Models; // Reference / Base
-	xr_map<dxRender_Visual*, bool> ModelsToDelete; // 
+	xr_vector<dxRender_Visual*> ModelsToDelete; // 
 	REGISTRY Registry; // Just pairing of pointer / Name
+	POOL Pool; // Unused / Inactive
 	BOOL bLogging;
 	BOOL bForceDiscard;
 	BOOL bAllowChildrenDuplicate;
@@ -65,6 +76,7 @@ class ECORE_API CModelPool
 
 	void Prefetch();
 	void Prefetch_One(LPCSTR N);
+	void ClearPool(BOOL b_complete);
 
 	void dump();
 

src/Layers/xrRenderPC_R1/FStaticRender.cpp

@@ -184,7 +184,6 @@ void CRender::ros_destroy(IRender_ObjectSpecific* & p) { xr_delete(p); }
 IRenderVisual* CRender::model_Create(LPCSTR name, IReader* data) { return Models->Create(name, data); }
 IRenderVisual* CRender::model_CreateChild(LPCSTR name, IReader* data) { return Models->CreateChild(name, data); }
 IRenderVisual* CRender::model_Duplicate(IRenderVisual* V) { return Models->Instance_Duplicate((dxRender_Visual*)V); }
-IRenderVisual* CRender::model_Instance(LPCSTR name) { return Models->Instance_Find(name); }
 
 void CRender::model_Delete(IRenderVisual* & V, BOOL bDiscard)
 {
@@ -232,6 +231,7 @@ IRenderVisual* CRender::model_CreateParticles(LPCSTR name)
 
 void CRender::models_Prefetch() { Models->Prefetch(); }
 void CRender::models_PrefetchOne(LPCSTR name) { Models->Prefetch_One(name); }
+void CRender::models_Clear(BOOL b_complete) { Models->ClearPool(b_complete); }
 
 ref_shader CRender::getShader(int id)
 {

src/Layers/xrRenderPC_R1/FStaticRender.h

@@ -198,12 +198,12 @@ class CRender : public R_dsgraph_structure
 	virtual IRenderVisual* model_Create(LPCSTR name, IReader* data = 0);
 	virtual IRenderVisual* model_CreateChild(LPCSTR name, IReader* data);
 	virtual IRenderVisual* model_Duplicate(IRenderVisual* V);
-	virtual IRenderVisual* model_Instance(LPCSTR name);
 	virtual void model_Delete(IRenderVisual* & V, BOOL bDiscard);
 	virtual void model_Delete(IRender_DetailModel* & F);
 	virtual void model_Logging(BOOL bEnable) { Models->Logging(bEnable); }
 	virtual void models_Prefetch();
 	virtual void models_PrefetchOne(LPCSTR name);
+	virtual void models_Clear(BOOL b_complete);
 
 	// Occlusion culling
 	virtual BOOL occ_visible(vis_data& V);

src/Layers/xrRenderPC_R2/r2.cpp

@@ -478,7 +478,6 @@ void CRender::ros_destroy(IRender_ObjectSpecific* & p) { xr_delete(p); }
 IRenderVisual* CRender::model_Create(LPCSTR name, IReader* data) { return Models->Create(name, data); }
 IRenderVisual* CRender::model_CreateChild(LPCSTR name, IReader* data) { return Models->CreateChild(name, data); }
 IRenderVisual* CRender::model_Duplicate(IRenderVisual* V) { return Models->Instance_Duplicate((dxRender_Visual*)V); }
-IRenderVisual* CRender::model_Instance(LPCSTR name) { return Models->Instance_Find(name); }
 
 void CRender::model_Delete(IRenderVisual* & V, BOOL bDiscard)
 {
@@ -526,6 +525,7 @@ IRenderVisual* CRender::model_CreateParticles(LPCSTR name)
 
 void CRender::models_Prefetch() { Models->Prefetch(); }
 void CRender::models_PrefetchOne(LPCTSTR name) { Models->Prefetch_One(name); }
+void CRender::models_Clear(BOOL b_complete) { Models->ClearPool(b_complete); }
 
 ref_shader CRender::getShader(int id)
 {

src/Layers/xrRenderPC_R2/r2.h

@@ -296,12 +296,12 @@ class CRender : public R_dsgraph_structure
 	virtual IRenderVisual* model_Create(LPCSTR name, IReader* data = 0);
 	virtual IRenderVisual* model_CreateChild(LPCSTR name, IReader* data);
 	virtual IRenderVisual* model_Duplicate(IRenderVisual* V);
-	virtual IRenderVisual* model_Instance(LPCSTR name);
 	virtual void model_Delete(IRenderVisual* & V, BOOL bDiscard);
 	virtual void model_Delete(IRender_DetailModel* & F);
 	virtual void model_Logging(BOOL bEnable) { Models->Logging(bEnable); }
 	virtual void models_Prefetch();
 	virtual void models_PrefetchOne(LPCSTR name);
+	virtual void models_Clear(BOOL b_complete);
 
 	// Occlusion culling
 	virtual BOOL occ_visible(vis_data& V);