some work on assetmgr

engine/engine.cpp

@@ -41,7 +41,9 @@ extern "C" void FunnyMain( int argc, char **argv )
 
 	stConstants.m_bIsSteam = true; 
 	if (!SteamAPI_Init())
-		Plat_FatalErrorFunc("SteamAPI_Init failed lol\n");
+	{
+		stConstants.m_bIsSteam = false;
+	}
 	stConstants.LaunchServer = LaunchServerAtSteamRelay;	
 	stConstants.ConnectSteamServer = ConnectBySteamID;	
 

game/client/assetmgr.cpp

@@ -3,91 +3,152 @@
 #include "tier2/fileformats/json.h"
 #include "game.h"
 
-struct FunnyShader_t
-{
-	CUtlString m_szName;
-	IShader *m_pShader;
-};
 #define MAX_MODEL_COUNT 2048
+#define MAX_MESH_COUNT 2048
 #define MAX_MATERIAL_COUNT 2048
 #define MAX_TEXTURE_COUNT 4096
 #define MAX_SHADER_COUNT 1024
 
+#define MAX_PHYSICAL_MESH_COUNT 1024
+#define MAX_PHYSICAL_MATERIAL_COUNT 512
+
+template<typename T, uint32_t nCount>
+class CAssetArc
+{
+	struct ObjectHandle_t
+	{
+		CUtlString m_szName;
+		uint32_t m_uUsageCount;
+		T *m_pObject;
+	};
+	ObjectHandle_t m_objects[nCount] = {};
+public:
+	uint32_t GetOrCreateObject( const char *szName, bool *pbHasBeenCreated )
+	{
+		uint32_t uFoundIndex = 1;
+		for ( uint32_t u = 1; u < nCount; u++ )
+		{
+			if (m_objects[u].m_pObject == NULL)
+			{
+				continue;
+			}
+			if (m_objects[u].m_szName == szName)
+			{
+				m_objects[u].m_uUsageCount++;
+				if (pbHasBeenCreated)
+					*pbHasBeenCreated = false;
+				return u;
+			}
+		}
+		for ( auto &m: m_objects)
+		{
+			if (m.m_pObject == NULL)
+				break;
+			uFoundIndex++;
+		}
+		m_objects[uFoundIndex].m_szName = szName;
+		m_objects[uFoundIndex].m_uUsageCount++;
+		m_objects[uFoundIndex].m_pObject = (T*)V_malloc(sizeof(T));
+		if (pbHasBeenCreated)
+			*pbHasBeenCreated = true;
+		return uFoundIndex;
+	}
+	T *GetObjectPtr( uint32_t uIndex )
+	{
+		if (uIndex >= nCount)
+			return 0;
+		return m_objects[uIndex].m_pObject;
+	}
+	void UnrefObject( uint32_t uIndex )
+	{
+		if (uIndex >= nCount)
+			return;
+
+		m_objects[uIndex].m_uUsageCount--;
+		if (m_objects[uIndex].m_uUsageCount == 0)
+		{
+			V_free(m_objects[uIndex].m_pObject);
+			m_objects[uIndex].m_pObject = NULL;
+			m_objects[uIndex].m_szName = NULL;
+		}
+	}
+};
+
 class CAssetManager: public IAssetManager
 {
 public:
-	virtual uint32_t LoadModel( const char *szName ) override;
+	virtual HFunnyModel LoadModel( const char *szName ) override;
-	virtual uint32_t LoadMaterial( const char *szName ) override;
+	virtual FunnyModel_t *GetModelByIndex( HFunnyModel hModel ) override;
-	virtual FunnyModel_t *GetModelByIndex( uint32_t uIndex ) override;
+	virtual void UnrefModel( HFunnyModel uIndex ) override;
-	virtual FunnyMaterial_t *GetMaterialByIndex( uint32_t uIndex ) override;
-	virtual void UnrefModel( uint32_t uIndex ) override;
-	virtual void UnrefMaterial( uint32_t uIndex ) override;
 
-	FunnyModel_t *LoadModelFromParams( const char *szMesh, const char *szMaterial );
+	virtual HFunnyMesh LoadMesh( const char *szName ) override;
+	virtual FunnyMesh_t *GetMeshByIndex( HFunnyMesh hMesh ) override;
+	virtual void UnrefMesh( HFunnyMesh hMesh ) override;
+
+	virtual HFunnyMaterial LoadMaterial( const char *szName ) override;
+	virtual FunnyMaterial_t *GetMaterialByIndex( HFunnyMaterial hMat ) override;
+	virtual void UnrefMaterial( HFunnyMaterial hMat ) override;
+
+	virtual HFunnyPhysicalMesh LoadPhysicalMesh( const char *szName ) override;
+	virtual FunnyPhysicalMesh_t *GetPhysicalMeshByIndex( HFunnyPhysicalMesh hPhysicalMesh ) override;
+	virtual void UnrefPhysicalMesh( HFunnyPhysicalMesh hPhysicalMesh ) override;
+	
+	virtual HFunnyPhysicalMaterial LoadPhysicalMaterial( const char *szName ) override;
+	virtual FunnyPhysicalMaterial_t *GetPhysicalMaterialByIndex( HFunnyPhysicalMaterial hPhysicalMaterial ) override;
+	virtual void UnrefPhysicalMaterial( HFunnyPhysicalMaterial hPhysicalMaterial ) override;
 
 	uint32_t LoadShader( const char *szName );
-	FunnyShader_t *GetShaderByIndex( uint32_t uIndex );
+	IShader **GetShaderByIndex( uint32_t hShader );
-	void UnrefShader( uint32_t uIndex );
+	void UnrefShader( uint32_t hShader );
 
-	FunnyModel_t *m_models[MAX_MODEL_COUNT] = {};
+	CAssetArc<FunnyModel_t, MAX_MODEL_COUNT> m_models = {};
-	uint32_t m_modelUsages[MAX_MODEL_COUNT] = {};
+	CAssetArc<FunnyMesh_t, MAX_MESH_COUNT> m_meshes = {};
-
+	CAssetArc<FunnyMaterial_t, MAX_MATERIAL_COUNT> m_materials = {};
-	FunnyMaterial_t *m_materials[MAX_MATERIAL_COUNT] = {};
+	CAssetArc<IShader*, MAX_SHADER_COUNT> m_shaders = {};
-	uint32_t m_materialsUsages[MAX_MATERIAL_COUNT] = {};
-	
-	FunnyMaterial_t *m_textures[MAX_TEXTURE_COUNT] = {};
-	uint32_t m_textureUsages[MAX_TEXTURE_COUNT] = {};
-
-	FunnyShader_t *m_shaders[MAX_SHADER_COUNT] = {};
-	uint32_t m_shaderUsages[MAX_SHADER_COUNT] = {};
 
 };
 
 FunnyModel_t *CAssetManager::GetModelByIndex( uint32_t uIndex )
 {
-	return m_models[uIndex];
+	return m_models.GetObjectPtr(uIndex);
 }
 
 FunnyMaterial_t *CAssetManager::GetMaterialByIndex( uint32_t uIndex )
 {
-	return m_materials[uIndex];
+	return m_materials.GetObjectPtr(uIndex);
 }
-FunnyShader_t *CAssetManager::GetShaderByIndex( uint32_t uIndex )
+
+IShader **CAssetManager::GetShaderByIndex( uint32_t uIndex )
 {
-	return m_shaders[uIndex];
+	return m_shaders.GetObjectPtr(uIndex);
+}
+
+FunnyMesh_t *CAssetManager::GetMeshByIndex( uint32_t uIndex )
+{
+	return m_meshes.GetObjectPtr(uIndex);
 }
 
 
 uint32_t CAssetManager::LoadModel( const char *szName )
 {
-	uint32_t u = 0;
+	bool bHasBeenCreated = false;
-	uint32_t uFoundIndex = 1;
+	HFunnyModel hModel = m_models.GetOrCreateObject(szName, &bHasBeenCreated);
-	for ( auto &m: m_models)
+	if (!bHasBeenCreated)
-	{
+		return hModel;
-		if (m == NULL)
+	
-		{
+	FunnyModel_t *pModel = m_models.GetObjectPtr(hModel);	
-			u++;
-			continue;
-		}
-		if (m->m_szParentName == szName)
-		{
-			m_modelUsages[uFoundIndex]++;
-			return u;
-		}
-		u++;
-	}
-	for ( auto &m: m_models)
-	{
-		if (m == NULL)
-			break;
-		uFoundIndex++;
-	}
 
 	IFileHandle *pHandle = filesystem->Open(szName, FILEMODE_READ);
+	if (!pHandle)
+		return 0;
+
 	CUtlString szProperties = filesystem->ReadString(pHandle);
 	IJSONValue *pRoot = JSONManager()->ReadString(szProperties);
 	filesystem->Close(pHandle);
 
+	if (!pRoot)
+		return 0;
+
 	IJSONObject *pMainObject;
 	CUtlString szMeshData;
 	IVertexBuffer *pVertices;
@@ -104,16 +165,14 @@ uint32_t CAssetManager::LoadModel( const char *szName )
 			}
 			IJSONValue *pMesh = pMainObject->GetValue("mesh");
 			IJSONValue *pMaterial = pMainObject->GetValue("material");
+			if (pMesh)
+				pModel->m_hMesh = LoadMesh(pMesh->GetStringValue());
+			if (pMaterial)
+				pModel->m_hMaterial = LoadMaterial(pMaterial->GetStringValue());
 
 
-			CUtlString szMesh = pMesh->GetStringValue();
-			CUtlString szMaterial = pMaterial->GetStringValue();
 
-			m_models[uFoundIndex] = LoadModelFromParams(szMesh, szMaterial);
+			return hModel;
-			m_models[uFoundIndex]->m_szParentName = szName;
-			m_modelUsages[uFoundIndex]++;
-
-			return uFoundIndex;
 		}	
 		break;
 	default:
@@ -129,31 +188,20 @@ void CAssetManager::UnrefModel( uint32_t uIndex )
 
 uint32_t CAssetManager::LoadMaterial( const char *szName )
 {
-	uint32_t u = 0;
+	bool bHasBeenCreated = false;
-	uint32_t uFoundIndex = 1;
+	HFunnyMaterial hMaterial = m_materials.GetOrCreateObject(szName, &bHasBeenCreated);
-	for ( auto &m: m_materials)
+	if (!bHasBeenCreated)
-	{
+		return hMaterial;
-		if (m == NULL)
+	FunnyMaterial_t *pMaterial = m_materials.GetObjectPtr(hMaterial);	
-		{
+
-			u++;
-			continue;
-		}
-		if (m->m_szName == szName)
-		{
-			m_materialsUsages[uFoundIndex]++;
-			return u;
-		}
-		u++;
-	}
-	for ( auto &m: m_materials)
-	{
-		if (m == NULL)
-			break;
-		uFoundIndex++;
-	}
 	IFileHandle *pHandle = filesystem->Open(szName, FILEMODE_READ);
+	if (!pHandle)
+		return 0;
 	CUtlString szProperties = filesystem->ReadString(pHandle);
 	IJSONValue *pRoot = JSONManager()->ReadString(szProperties);
+	if (!pRoot)
+		return 0;
+
 	IJSONObject *pMainObject;
 	switch (pRoot->GetType())
 	{
@@ -168,23 +216,25 @@ uint32_t CAssetManager::LoadMaterial( const char *szName )
 			}
 			IJSONValue *pShaderValue = pMainObject->GetValue("shader");
 			CUtlString szShader = pShaderValue->GetStringValue();
-			CBaseMaterial *pMaterial = CreateMaterial(szShader);
+			CBaseMaterial *pRenderMaterial = CreateMaterial(szShader);
 
-			uint32_t uShaderId = LoadShader(pMaterial->GetShaderPath());
+			uint32_t uShaderId = LoadShader(pRenderMaterial->GetShaderPath());
-			FunnyShader_t *pShader = GetShaderByIndex(uShaderId);
+			if (!uShaderId)
-			m_materials[uFoundIndex] = new FunnyMaterial_t;
+				return 0;
-			m_materials[uFoundIndex]->m_pShaders = pShader->m_pShader;
-			m_materials[uFoundIndex]->m_pMaterial = g_pRenderContext->CreateMaterial(pShader->m_pShader);
-			m_materials[uFoundIndex]->m_pLayout = pMaterial;
-			m_materialsUsages[uFoundIndex]++;
 
-			return uFoundIndex;
+			IShader **ppShader = GetShaderByIndex(uShaderId);
+
+			pMaterial->m_pShaders = *ppShader; 
+			pMaterial->m_pMaterial = g_pRenderContext->CreateMaterial(*ppShader); 
+			pMaterial->m_pLayout = pRenderMaterial; 
+
+			return hMaterial;
 		}	
 		break;
 	default:
 		return 0;
 	}
-	return uFoundIndex;
+	return hMaterial;
 }
 
 void CAssetManager::UnrefMaterial( uint32_t uIndex )
@@ -192,13 +242,21 @@ void CAssetManager::UnrefMaterial( uint32_t uIndex )
 
 }
 
-FunnyModel_t *CAssetManager::LoadModelFromParams( const char *szMesh, const char *szMaterial )
+HFunnyMesh CAssetManager::LoadMesh( const char *szName )
 {
-	IFileHandle *hMesh = filesystem->Open(szMesh, FILEMODE_READ);
+
+	bool bHasBeenCreated = false;
+	HFunnyMesh hAsset = m_meshes.GetOrCreateObject(szName, &bHasBeenCreated);
+	if (!bHasBeenCreated)
+		return hAsset;
+	FunnyMesh_t *pMesh = m_meshes.GetObjectPtr(hAsset);
+
+	IFileHandle *hMesh = filesystem->Open(szName, FILEMODE_READ);
 	if ( hMesh == NULL )
 	{
-		V_printf("Failed to load %s\n", szMesh);
+		V_printf("Failed to load %s\n", szName);
-		return NULL;
+		m_meshes.UnrefObject(hAsset);
+		return 0;
 	}
 
 	IVertexBuffer *pVertexBuffer = g_pRenderContext->CreateVertexBuffer(filesystem->Size(hMesh));
@@ -208,38 +266,24 @@ FunnyModel_t *CAssetManager::LoadModelFromParams( const char *szMesh, const char
 	pVertexBuffer->Unmap();
 	pVertexBuffer->Unlock();
 
-	FunnyModel_t *pModel = new FunnyModel_t;
+	pMesh->m_pMesh = g_pWorldRenderer->CreateMesh(szName);
-	pModel->m_szName = szMesh;
+	pMesh->m_pMesh->SetVertices(pVertexBuffer);
-	pModel->m_pMesh = g_pWorldRenderer->CreateMesh(szMesh);
+
-	pModel->m_pMesh->SetVertices(pVertexBuffer);
+	return hAsset;
-	uint32_t uMaterial = LoadMaterial(szMaterial);
+
-	pModel->m_pFunnyMaterial = GetMaterialByIndex(uMaterial);
+}
-	return pModel;
+void CAssetManager::UnrefMesh( uint32_t uIndex )
+{
+	m_meshes.UnrefObject(uIndex);
 }
 
 uint32_t CAssetManager::LoadShader( const char *szName )
 {
-	uint32_t u = 0;
+	bool bHasBeenCreated = false;
-	uint32_t uFoundIndex = 1;
+	uint32_t hShader = m_shaders.GetOrCreateObject(szName, &bHasBeenCreated);
-	for ( auto &s: m_shaders)
+	if (!bHasBeenCreated)
-	{
+		return hShader;
-		if (s == NULL)
+	IShader **ppShader = m_shaders.GetObjectPtr(hShader);	
-		{
-			u++;
-			continue;
-		}
-		if ( s->m_szName == szName )
-		{
-			return u;
-		}
-		u++;
-	}	
-	for ( auto &m: m_models)
-	{
-		if (m == NULL)
-			break;
-		uFoundIndex++;
-	}
 
 
 	IShader *pShader = g_pRenderContext->CreateShader(szName);
@@ -248,11 +292,8 @@ uint32_t CAssetManager::LoadShader( const char *szName )
 		V_printf("Failed to load %s\n", szName);
 		return 0;
 	}
-	FunnyShader_t *pFunnyShader = new FunnyShader_t;
+	*ppShader = pShader;
-	pFunnyShader->m_szName = szName;
+	return hShader;
-	pFunnyShader->m_pShader = pShader;
-	m_shaders[uFoundIndex] = pFunnyShader;
-	return uFoundIndex;
 }
 
 void CAssetManager::UnrefShader( uint32_t uIndex )
@@ -260,6 +301,38 @@ void CAssetManager::UnrefShader( uint32_t uIndex )
 
 }
 
+HFunnyPhysicalMesh CAssetManager::LoadPhysicalMesh( const char *szName )
+{
+
+}
+
+FunnyPhysicalMesh_t *CAssetManager::GetPhysicalMeshByIndex( HFunnyPhysicalMesh hPhysicalMesh )
+{
+
+}
+
+void CAssetManager::UnrefPhysicalMesh( HFunnyPhysicalMesh hPhysicalMesh )
+{
+
+}
+
+
+HFunnyPhysicalMaterial CAssetManager::LoadPhysicalMaterial( const char *szName )
+{
+
+}
+
+FunnyPhysicalMaterial_t *CAssetManager::GetPhysicalMaterialByIndex( HFunnyPhysicalMaterial hPhysicalMaterial )
+{
+
+}
+
+void CAssetManager::UnrefPhysicalMaterial( HFunnyPhysicalMaterial hPhysicalMaterial )
+{
+
+}
+
+
 
 static CAssetManager s_assetmgr;
 IAssetManager *g_pAssetManager = &s_assetmgr;

game/client/assetmgr.h

@@ -1,40 +1,75 @@
 #ifndef ASSET_MANAGER_H
 #define ASSET_MANAGER_H
+
 #include "materialsystem/imaterialsystem.h"
 #include "worldrender.h"
 #include "datamap.h"
 #include "materials.h"
+#include "iphysics.h"
 #include "tier1/utlstring.h"
 
+typedef uint32_t HFunnyMaterial;
+typedef uint32_t HFunnyMesh;
+typedef uint32_t HFunnyPhysicalMesh;
+typedef uint32_t HFunnyPhysicalMaterial;
+typedef uint32_t HFunnyModel;
 
 struct FunnyMaterial_t
 {
-	CUtlString m_szName;
 	IShader *m_pShaders;
 	IMaterial *m_pMaterial;
 	CBaseMaterial *m_pLayout;
 };
 
+struct FunnyMesh_t
+{
+	IMesh *m_pMesh;
+};
+
+struct FunnyPhysicalMaterial_t
+{
+};
+
+struct FunnyPhysicalMesh_t
+{
+	HShape m_hShape;
+};
+
 struct FunnyModel_t
 {
-	CUtlString m_szName;
+	HFunnyMesh m_hMesh;
-	IMesh *m_pMesh;
+	HFunnyMaterial m_hMaterial;
-	FunnyMaterial_t *m_pFunnyMaterial;
+	HFunnyPhysicalMesh m_hPhysicalMesh;
-	CUtlString m_szParentName;
+	HFunnyPhysicalMaterial m_hPhysicalMaterial;
 };
 
 
 class IAssetManager
 {
 public:
-	virtual uint32_t LoadModel( const char *szName ) = 0;
+	virtual HFunnyModel LoadModel( const char *szName ) = 0;
-	virtual uint32_t LoadMaterial( const char *szName ) = 0;
+	virtual FunnyModel_t *GetModelByIndex( HFunnyModel hModel ) = 0;
-	virtual FunnyModel_t *GetModelByIndex( uint32_t uIndex ) = 0;
+	virtual void UnrefModel( HFunnyModel uIndex ) = 0;
-	virtual FunnyMaterial_t *GetMaterialByIndex( uint32_t uIndex ) = 0;
+
-	virtual void UnrefModel( uint32_t uIndex ) = 0;
+	virtual HFunnyMesh LoadMesh( const char *szName ) = 0;
-	virtual void UnrefMaterial( uint32_t uIndex ) = 0;
+	virtual FunnyMesh_t *GetMeshByIndex( HFunnyMesh hMesh ) = 0;
+	virtual void UnrefMesh( HFunnyMesh hMesh ) = 0;
+
+	virtual HFunnyMaterial LoadMaterial( const char *szName ) = 0;
+	virtual FunnyMaterial_t *GetMaterialByIndex( HFunnyMaterial hMat ) = 0;
+	virtual void UnrefMaterial( HFunnyMaterial hMat ) = 0;
+
+	virtual HFunnyPhysicalMesh LoadPhysicalMesh( const char *szName ) = 0;
+	virtual FunnyPhysicalMesh_t *GetPhysicalMeshByIndex( HFunnyPhysicalMesh hPhysicalMesh ) = 0;
+	virtual void UnrefPhysicalMesh( HFunnyPhysicalMesh hPhysicalMesh ) = 0;
+	
+	virtual HFunnyPhysicalMaterial LoadPhysicalMaterial( const char *szName ) = 0;
+	virtual FunnyPhysicalMaterial_t *GetPhysicalMaterialByIndex( HFunnyPhysicalMaterial hPhysicalMaterial ) = 0;
+	virtual void UnrefPhysicalMaterial( HFunnyPhysicalMaterial hPhysicalMaterial ) = 0;
 };
 
 extern IAssetManager *g_pAssetManager;
 
+#define ASSET_MANAGER_INTERFACE_VERSION "AssetMgr001"
+
 #endif

game/client/basemodelentity.cpp

@@ -26,12 +26,15 @@ void C_BaseModelEntity::SetModel( const char *szName )
 	}
 	m_uModelIndex = g_pAssetManager->LoadModel(szName);
 	m_pModel = g_pAssetManager->GetModelByIndex(m_uModelIndex);
-	m_pInstance = g_pWorldRenderer->CreateInstance(m_pModel->m_pMesh);
+	
+	FunnyMesh_t *pMesh = g_pAssetManager->GetMeshByIndex(m_pModel->m_hMesh);
+	m_pInstance = g_pWorldRenderer->CreateInstance(pMesh->m_pMesh);
 }
 
 C_BaseModelEntity::~C_BaseModelEntity()
 {
-	g_pWorldRenderer->DestroyMeshInstance(m_pModel->m_pMesh, m_pInstance);
+	FunnyMesh_t *pMesh = g_pAssetManager->GetMeshByIndex(m_pModel->m_hMesh);
+	g_pWorldRenderer->DestroyMeshInstance(pMesh->m_pMesh, m_pInstance);
 	g_pAssetManager->UnrefModel(m_uModelIndex);
 }
 

game/client/basemodelentity.h

@@ -20,7 +20,7 @@ public:
 	void SetModel( const char *szName );
 private:
 
-	uint32_t m_uModelIndex;
+	HFunnyModel m_hModelHandle;
 	FunnyModel_t *m_pModel;
 	IMeshInstance *m_pInstance;
 };

game/server/basemodelentity.cpp

@@ -1 +1,11 @@
+#include "basemodelentity.h"
+
+void CBaseModelEntity::Spawn()
+{
+}
+
+void CBaseModelEntity::Precache()
+{
+
+}
 

game/server/basemodelentity.h

@@ -3,6 +3,7 @@
 
 #include "baseentity.h"
 #include "iphysics.h"
+#include "assetmgr.h"
 
 class CBaseModelEntity: public CBaseEntity
 {
@@ -11,7 +12,12 @@ public:
 	virtual void Spawn() override;
 	virtual void Precache() override;
 
+	void SetModel( const char *szName );
 private:
+
+	HFunnyModel m_hModelHandle;
+	FunnyModel_t *m_pModel;
+
 	HShape m_hShape;
 	HCollider m_hCollider;
 	IPhysicsBody *m_pBody;