asset manager

funnyassets/models/cube.fmdl

@@ -1,4 +1,4 @@
 {
-	"mesh": "cube.fmesh",
+	"mesh": "game/core/meshes/cube.fmesh_c",
 	"material": "cube.fmat"
 }

game/client/assetmgr.cpp

@@ -1,27 +1,80 @@
 #include "assetmgr.h"
 #include "tier2/ifilesystem.h"
 #include "tier2/fileformats/json.h"
+#include "game.h"
+
+struct FunnyShader_t
+{
+	CUtlString m_szName;
+	IShader *m_pShader;
+};
+#define MAX_MODEL_COUNT 2048
+#define MAX_MATERIAL_COUNT 2048
+#define MAX_SHADER_COUNT 1024
 
 class CAssetManager: public IAssetManager
 {
 public:
-	virtual FunnyModel_t *LoadModel( const char *szName ) override;
+	virtual uint32_t LoadModel( const char *szName ) override;
-	virtual FunnyMaterial_t *LoadMaterial( const char *szName ) override;
+	virtual uint32_t LoadMaterial( const char *szName ) override;
-	virtual void UnrefModel( FunnyModel_t *pModel ) override;
+	virtual FunnyModel_t *GetModelByIndex( uint32_t uIndex ) override;
-	virtual void UnrefMaterial( FunnyMaterial_t *pModel ) override;
+	virtual FunnyMaterial_t *GetMaterialByIndex( uint32_t uIndex ) override;
-	CUtlVector<FunnyModel_t> m_models;
+	virtual void UnrefModel( uint32_t uIndex ) override;
-	CUtlVector<FunnyModel_t*> m_modelUsages;
+	virtual void UnrefMaterial( uint32_t uIndex ) override;
-	CUtlVector<FunnyMaterial_t> m_materials;
-	CUtlVector<FunnyMaterial_t*> m_materialUsages;
 	
 	FunnyModel_t *LoadModelFromParams( const char *szMesh, const char *szMaterial );
+	
+	uint32_t LoadShader( const char *szName );
+	void UnrefShader( uint32_t uIndex );
+
+	FunnyModel_t *m_models[MAX_MODEL_COUNT] = {};
+	uint32_t m_modelUsages[MAX_MODEL_COUNT] = {};
+	FunnyMaterial_t *m_materials[MAX_MATERIAL_COUNT] = {};
+	uint32_t m_materialsUsages[MAX_MATERIAL_COUNT] = {};
+
+	FunnyShader_t *m_shaders[MAX_SHADER_COUNT] = {};
+	uint32_t m_shaderUsages[MAX_SHADER_COUNT] = {};
+
 };
 
-FunnyModel_t *CAssetManager::LoadModel( const char *szName )
+FunnyModel_t *CAssetManager::GetModelByIndex( uint32_t uIndex )
 {
+	return m_models[uIndex];
+}
+
+FunnyMaterial_t *CAssetManager::GetMaterialByIndex( uint32_t uIndex )
+{
+	return m_materials[uIndex];
+}
+
+
+uint32_t CAssetManager::LoadModel( const char *szName )
+{
+	uint32_t u = 0;
+	uint32_t uFoundIndex = 1;
+	for ( auto &m: m_models)
+	{
+		if (m == NULL)
+		{
+			u++;
+			continue;
+		}
+		if (m->m_szName == szName)
+		{
+			m_modelUsages[uFoundIndex]++;
+			return u;
+		}
+		u++;
+	}
+	for ( auto &m: m_models)
+	{
+		if (m == NULL)
+			break;
+		uFoundIndex++;
+	}
+
 	IFileHandle *pHandle = filesystem->Open(szName, FILEMODE_READ);
 	CUtlString szProperties = filesystem->ReadString(pHandle);
-	V_printf("%s\n", szProperties.GetString());
 	IJSONValue *pRoot = JSONManager()->ReadString(szProperties);
 	IJSONObject *pMainObject;
 	CUtlString szMeshData;
@@ -34,7 +87,7 @@ FunnyModel_t *CAssetManager::LoadModel( const char *szName )
 			if (!pMainObject)
 			{
 				V_printf("Failed to load properties\n");
-				return NULL;
+				return 0;
 
 			}
 			IJSONValue *pMesh = pMainObject->GetValue("mesh");
@@ -42,31 +95,119 @@ FunnyModel_t *CAssetManager::LoadModel( const char *szName )
 			CUtlString szMesh = pMesh->GetStringValue();
 			CUtlString szMaterial = pMaterial->GetStringValue();
 
-			return NULL;
+			m_models[uFoundIndex] = LoadModelFromParams(szMesh, szMaterial);
+			m_modelUsages[uFoundIndex]++;
+
+			return uFoundIndex;
 		}	
 		break;
 	default:
-		return NULL;
+		return 0;
 	}
 }
 
-void CAssetManager::UnrefModel( FunnyModel_t *pModel )
+void CAssetManager::UnrefModel( uint32_t uIndex )
 {
 
 }
 
-FunnyMaterial_t *CAssetManager::LoadMaterial( const char *szName )
+
+uint32_t CAssetManager::LoadMaterial( const char *szName )
 {
-	FunnyMaterial_t stMaterial = {};
+	uint32_t u = 0;
+	uint32_t uFoundIndex = 1;
+	for ( auto &m: m_models)
+	{
+		if (m == NULL)
+		{
+			u++;
+			continue;
+		}
+		if (m->m_szName == szName)
+		{
+			m_modelUsages[uFoundIndex]++;
+			return u;
+		}
+		u++;
+	}
+	for ( auto &m: m_models)
+	{
+		if (m == NULL)
+			break;
+		uFoundIndex++;
+	}
 }
 
-void CAssetManager::UnrefMaterial( FunnyMaterial_t *pModel )
+void CAssetManager::UnrefMaterial( uint32_t uIndex )
 {
 
 }
+
 FunnyModel_t *CAssetManager::LoadModelFromParams( const char *szMesh, const char *szMaterial )
 {
+	IFileHandle *hMesh = filesystem->Open(szMesh, FILEMODE_READ);
+	if ( hMesh == NULL )
+	{
+		V_printf("Failed to load %s\n", szMesh);
+		return NULL;
+	}
+
+	IVertexBuffer *pVertexBuffer = g_pRenderContext->CreateVertexBuffer(filesystem->Size(hMesh));
+	pVertexBuffer->Lock();
+	void *pMapped = pVertexBuffer->Map();
+	filesystem->Read(hMesh, pMapped, pVertexBuffer->GetSize());
+	pVertexBuffer->Unmap();
+	pVertexBuffer->Unlock();
+
+	FunnyModel_t *pModel = new FunnyModel_t;
+	pModel->m_szName = szMesh;
+	pModel->m_pMesh = g_pWorldRenderer->CreateMesh(szMesh);
+	pModel->m_pMesh->SetVertices(pVertexBuffer);
+	return pModel;
 }
 
+uint32_t CAssetManager::LoadShader( const char *szName )
+{
+	uint32_t u = 0;
+	uint32_t uFoundIndex = 1;
+	for ( auto &s: m_shaders)
+	{
+		if (s == NULL)
+		{
+			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);
+	if ( pShader == NULL )
+	{
+		V_printf("Failed to load %s\n", szName);
+		return 0;
+	}
+	FunnyShader_t *pFunnyShader = new FunnyShader_t;
+	pFunnyShader->m_szName = szName;
+	pFunnyShader->m_pShader = pShader;
+	return uFoundIndex;
+}
+
+void CAssetManager::UnrefShader( uint32_t uIndex )
+{
+
+}
+
+
 static CAssetManager s_assetmgr;
 IAssetManager *g_pAssetManager = &s_assetmgr;

game/client/assetmgr.h

@@ -9,6 +9,7 @@
 
 struct FunnyMaterial_t
 {
+	CUtlString m_szName;
 	IShader *m_pShaders;
 	IMaterial *m_pMaterial;
 	CBaseMaterial *m_pLayout;
@@ -16,6 +17,7 @@ struct FunnyMaterial_t
 
 struct FunnyModel_t
 {
+	CUtlString m_szName;
 	IMesh *m_pMesh;
 	FunnyMaterial_t *m_pFunnyMaterial;
 };
@@ -24,10 +26,12 @@ struct FunnyModel_t
 class IAssetManager
 {
 public:
-	virtual FunnyModel_t *LoadModel( const char *szName ) = 0;
+	virtual uint32_t LoadModel( const char *szName ) = 0;
-	virtual FunnyMaterial_t *LoadMaterial( const char *szName ) = 0;
+	virtual uint32_t LoadMaterial( const char *szName ) = 0;
-	virtual void UnrefModel( FunnyModel_t *pModel ) = 0;
+	virtual FunnyModel_t *GetModelByIndex( uint32_t uIndex ) = 0;
-	virtual void UnrefMaterial( FunnyMaterial_t *pModel ) = 0;
+	virtual FunnyMaterial_t *GetMaterialByIndex( uint32_t uIndex ) = 0;
+	virtual void UnrefModel( uint32_t uIndex ) = 0;
+	virtual void UnrefMaterial( uint32_t uIndex ) = 0;
 };
 
 extern IAssetManager *g_pAssetManager;

game/client/materials.h

@@ -41,6 +41,11 @@ class CBaseMaterial
 public:
 	DECLARE_CLASS_NOBASE(CBaseMaterial)
 	DECLARE_DATADESC_NOBASE()
+	virtual const char *GetShaderPath() { return NULL; };
+	virtual void *GetDataPtr() { return 0; };
+	virtual size_t GetDataSize() { return 0; };
+
+	uint64_t m_uHash;
 };
 
 typedef CBaseMaterial *( *InstantiateMaterialFn )( void );
@@ -56,6 +61,11 @@ public:
 };
 CBaseMaterial *CreateMaterial( const char *szName );
 
+#define DECLARE_SHADER(path) \
+	virtual const char *GetShaderPath() override { return path; }; \
+	virtual void *GetDataPtr() override { return (char*)this+_class_offsetof(ThisClass, m_uHash); } \
+	virtual size_t GetDataSize() override { return sizeof(ThisClass)-_class_offsetof(ThisClass, m_uHash); }
+
 #define DEFINE_MATERIAL( className, name ) \
 	static CBaseMaterial *__Create##className##_material() { return ( CBaseMaterial* )( new className ); }; \
 	static CFunnyMaterialRegistry __CreateMaterail##className##_registry( __Create##className##_material, name );

game/client/milmoba/materials.cpp

@@ -5,6 +5,8 @@ class CBasicPBR: public CBaseMaterial
 public:
 	DECLARE_CLASS(CBasicPBR, CBaseMaterial)
 	DECLARE_DATADESC()
+	DECLARE_SHADER("game/core/shaders/funny_basic_pbr.shader_c")
+
 
 	FMat::XMFLOAT4 m_vAlbedo = { 1, 1, 1, 1 };
 	FMat::XMTexture m_tAlbedo = TEXTURE_NO_TEXTURE;
@@ -23,6 +25,7 @@ class CBasicError: public CBaseMaterial
 public:
 	DECLARE_CLASS(CBasicError, CBaseMaterial)
 	DECLARE_DATADESC()
+	DECLARE_SHADER("game/core/shaders/funny_error.shader_c")
 };
 
 BEGIN_DATADESC(CBasicError)

game/client/milmoba/player.cpp

@@ -4,7 +4,9 @@
 
 void C_MOBAPlayer::Precache()
 {
-	g_pAssetManager->LoadModel("game/core/models/cube.fmdl");
+	uint32_t uIndex = g_pAssetManager->LoadModel("game/core/models/cube.fmdl");
+	V_printf("%u\n", uIndex);
+	pModel = g_pAssetManager->GetModelByIndex(uIndex);
 }
 
 

game/client/worldrender.cpp

@@ -23,7 +23,6 @@ class CFunnyMeshInstance;
 class CFunnyMesh: public IMesh
 {
 public:
-	virtual void ConfigureShader( IShader *pShader ) override;
 
 	virtual void SetVertices( IVertexBuffer *pBuffer ) override;
 	virtual void SetIndicies( IIndexBuffer *pBuffer, EIndexFormat eIndexFormat ) override;
@@ -36,22 +35,6 @@ public:
 	IVertexBuffer *m_pVertexBuffer;
 };
 
-void CFunnyMesh::ConfigureShader( IShader *pShader )
-{
-	pShader->AddLayout(0, 32);
-	pShader->AddAttribute(0, 0, VERTEX_FORMAT_XYZ32_SFLOAT, 0);
-	pShader->AddAttribute(0, 1, VERTEX_FORMAT_XY32_SFLOAT, 12);
-	pShader->AddAttribute(0, 2, VERTEX_FORMAT_XYZ32_SFLOAT, 20);
-	// albedo
-	pShader->AddOutputImage(0, IMAGE_FORMAT_RGBA8_UNORM);
-	pShader->AddOutputImage(1, IMAGE_FORMAT_RGBA16_SFLOAT);
-	pShader->AddOutputImage(2, IMAGE_FORMAT_RGBA32_SFLOAT);
-
-	pShader->SetMultisampling(MULTISAMPLE_TYPE_4_SAMPLES);
-
-	pShader->SetDepthImage(IMAGE_FORMAT_D32_SFLOAT);
-}
-
 void CFunnyMesh::SetVertices( IVertexBuffer *pBuffer )
 {
 	m_pVertexBuffer = pBuffer;
@@ -137,6 +120,8 @@ public:
 
 	virtual IMesh *CreateMesh( const char *szName ) override;
 	virtual IMeshInstance *CreateInstance( IMesh *pMesh ) override;
+
+	virtual void ConfigureShader( IShader *pShader ) override;
 private:
 	CUtlVector<CFunnyMesh*> m_pMeshes;
 	IImage *m_pOutputImage = NULL;
@@ -154,6 +139,23 @@ private:
 	versor m_vRot;
 };
 
+void CFunnyWorldRenderer::ConfigureShader( IShader *pShader )
+{
+	pShader->AddLayout(0, 32);
+	pShader->AddAttribute(0, 0, VERTEX_FORMAT_XYZ32_SFLOAT, 0);
+	pShader->AddAttribute(0, 1, VERTEX_FORMAT_XY32_SFLOAT, 12);
+	pShader->AddAttribute(0, 2, VERTEX_FORMAT_XYZ32_SFLOAT, 20);
+	// albedo
+	pShader->AddOutputImage(0, IMAGE_FORMAT_RGBA8_UNORM);
+	pShader->AddOutputImage(1, IMAGE_FORMAT_RGBA16_SFLOAT);
+	pShader->AddOutputImage(2, IMAGE_FORMAT_RGBA32_SFLOAT);
+
+	pShader->SetMultisampling(MULTISAMPLE_TYPE_4_SAMPLES);
+
+	pShader->SetDepthImage(IMAGE_FORMAT_D32_SFLOAT);
+}
+
+
 static CFunnyWorldRenderer s_renderer;
 IWorldRenderer *g_pWorldRenderer = &s_renderer;
 

game/client/worldrender.h

@@ -9,7 +9,6 @@
 abstract_class IMesh
 {
 public:
-	virtual void ConfigureShader( IShader *pShader ) = 0;
 
 	virtual void SetVertices( IVertexBuffer *pBuffer ) = 0;
 	virtual void SetIndicies( IIndexBuffer *pBuffer, EIndexFormat eIndexFormat ) = 0;
@@ -33,6 +32,8 @@ public:
 
 	virtual IMesh *CreateMesh( const char *szName ) = 0;
 	virtual IMeshInstance *CreateInstance( IMesh *pMesh ) = 0;
+
+	virtual void ConfigureShader( IShader *pShader ) = 0;
 };
 
 extern IWorldRenderer *g_pWorldRenderer;