kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

a bit of stuff, time to add spirv-link into this project

Browse Source
This commit is contained in:
kotofyt
2026-02-23 01:42:17 +02:00
parent c00ecf4081
commit 003106a4d7
48 changed files with 626 additions and 752 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
game/client/assetmgr.cpp Normal file
View File

@@ -0,0 +1,72 @@
#include "assetmgr.h"
#include "tier2/ifilesystem.h"
#include "tier2/fileformats/json.h"
class CAssetManager: public IAssetManager
{
public:
virtual FunnyModel_t *LoadModel( const char *szName ) override;
virtual FunnyMaterial_t *LoadMaterial( const char *szName ) override;
virtual void UnrefModel( FunnyModel_t *pModel ) override;
virtual void UnrefMaterial( FunnyMaterial_t *pModel ) override;
CUtlVector<FunnyModel_t> m_models;
CUtlVector<FunnyModel_t*> m_modelUsages;
CUtlVector<FunnyMaterial_t> m_materials;
CUtlVector<FunnyMaterial_t*> m_materialUsages;
FunnyModel_t *LoadModelFromParams( const char *szMesh, const char *szMaterial );
};
FunnyModel_t *CAssetManager::LoadModel( const char *szName )
{
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;
IVertexBuffer *pVertices;
switch (pRoot->GetType())
{
case JSON_PARAMETER_OBJECT:
{
pMainObject = pRoot->GetObject();
if (!pMainObject)
{
V_printf("Failed to load properties\n");
return NULL;
}
IJSONValue *pMesh = pMainObject->GetValue("mesh");
IJSONValue *pMaterial = pMainObject->GetValue("material");
CUtlString szMesh = pMesh->GetStringValue();
CUtlString szMaterial = pMaterial->GetStringValue();
return NULL;
}
break;
default:
return NULL;
}
}
void CAssetManager::UnrefModel( FunnyModel_t *pModel )
{
}
FunnyMaterial_t *CAssetManager::LoadMaterial( const char *szName )
{
FunnyMaterial_t stMaterial = {};
}
void CAssetManager::UnrefMaterial( FunnyMaterial_t *pModel )
{
}
FunnyModel_t *CAssetManager::LoadModelFromParams( const char *szMesh, const char *szMaterial )
{
}
static CAssetManager s_assetmgr;
IAssetManager *g_pAssetManager = &s_assetmgr;

35
game/client/assetmgr.h Normal file
View File

@@ -0,0 +1,35 @@
#ifndef ASSET_MANAGER_H
#define ASSET_MANAGER_H
#include "materialsystem/imaterialsystem.h"
#include "worldrender.h"
#include "datamap.h"
#include "materials.h"
#include "tier1/utlstring.h"
struct FunnyMaterial_t
{
IShader *m_pShaders;
IMaterial *m_pMaterial;
CBaseMaterial *m_pLayout;
};
struct FunnyModel_t
{
IMesh *m_pMesh;
FunnyMaterial_t *m_pFunnyMaterial;
};
class IAssetManager
{
public:
virtual FunnyModel_t *LoadModel( const char *szName ) = 0;
virtual FunnyMaterial_t *LoadMaterial( const char *szName ) = 0;
virtual void UnrefModel( FunnyModel_t *pModel ) = 0;
virtual void UnrefMaterial( FunnyMaterial_t *pModel ) = 0;
};
extern IAssetManager *g_pAssetManager;
#endif

4
game/client/baseentity.cpp
View File

@@ -107,7 +107,7 @@ lookforname:
BEGIN_DATADESC_NOBASE(C_BaseEntity)
DEFINE_KEYFIELD(m_vPosition, FIELD_VECTOR, "origin")
DEFINE_KEYFIELD(m_vPosition, FIELD_FLOAT3, "origin")
DEFINE_KEYFIELD(m_vRotation, FIELD_QUATERNION, "angles")
DEFINE_KEYFIELD(m_vScale, FIELD_VECTOR, "scales")
DEFINE_KEYFIELD(m_vScale, FIELD_FLOAT3, "scales")
END_DATADESC()

1
game/client/baseentity.h
View File

@@ -9,7 +9,6 @@
#include "entitysystem.h"
#include "datamap.h"
#include "cglm/cglm.h"
#include "trig.h"
#define DECLARE_CLASS_NOBASE( className ) \

31
game/client/build.cpp
View File

@@ -3,6 +3,7 @@
#include "ld.h"
#define EXTERNAL "../../external/"
ADD_DEPENDENCY_BUILD_FILE(cfg, "../../buildcfg.cpp");
#define FUNNYSTDLIB EXTERNAL"funnystdlib/"
ADD_DEPENDENCY_BUILD_FILE(tier0, FUNNYSTDLIB"tier0/build.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier1, FUNNYSTDLIB"tier1/build.cpp");
@@ -15,12 +16,19 @@ DECLARE_BUILD_STAGE(Client)
compileProject.m_szName = "client";
compileProject.files = {
"game.cpp",
"worldrender.cpp",
"baseentity.cpp",
"entitysystem.cpp",
"worldrender.cpp",
"assetmgr.cpp",
"materials.cpp",
"milmoba/materials.cpp",
"milmoba/player.cpp",
};
compileProject.includeDirectories = {
".",
"../shared",
"../../public",
FUNNYSTDLIB"public",
@@ -28,12 +36,21 @@ DECLARE_BUILD_STAGE(Client)
};
compileProject.bFPIC = true;
ldProject = ccompiler->Compile(&compileProject);
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
ldProject.libraryObjects = {
GET_PROJECT_LIBRARY(tier0, "tier0"),
};
ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier2, "tier2")});
if ( GET_PROJECT_VALUE(config, "static") == "true" )
{
ldProject.linkType = ELINK_STATIC_LIBRARY;
}
else
{
ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
ldProject.libraryObjects = {
GET_PROJECT_LIBRARY(tier0, "tier0"),
};
ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier2, "tier2")});
}
if (ldProject.m_target.kernel & TARGET_KERNEL_WINDOWS_DEVICES)
{

26
game/client/materials.cpp Normal file
View File

@@ -0,0 +1,26 @@
#include "materials.h"
#include "tier0/lib.h"
BEGIN_DATADESC_NOBASE(CBaseMaterial)
END_DATADESC()
static CFunnyMaterialRegistry *s_pMaterials = NULL;
CFunnyMaterialRegistry::CFunnyMaterialRegistry( InstantiateMaterialFn fn, const char *szName )
{
m_CreateFn = fn;
m_szName = szName;
m_pNext = s_pMaterials;
s_pMaterials = this;
}
CBaseMaterial *CreateMaterial( const char *szName )
{
CFunnyMaterialRegistry *pRegistry = s_pMaterials;
while (pRegistry)
{
if (!V_strcmp(szName, pRegistry->m_szName))
return pRegistry->m_CreateFn();
pRegistry = pRegistry->m_pNext;
}
return NULL;
}

63
game/client/materials.h Normal file
View File

@@ -0,0 +1,63 @@
#ifndef FUNNY_MATERIALS_H
#define FUNNY_MATERIALS_H
#include "datamap.h"
#include "stdint.h"
#define TEXTURE_INVALID 0
#define TEXTURE_NO_TEXTURE -1
namespace FMat
{
typedef int32_t XMTexture;
struct XMFLOAT2
{
float x;
float y;
};
struct XMFLOAT3
{
float x;
float y;
float z;
};
struct XMFLOAT4
{
float x;
float y;
float z;
float w;
};
struct XMFLOAT4x4
{
XMFLOAT4 row1;
XMFLOAT4 row2;
XMFLOAT4 row3;
XMFLOAT4 row4;
};
}
class CBaseMaterial
{
public:
DECLARE_CLASS_NOBASE(CBaseMaterial)
DECLARE_DATADESC_NOBASE()
};
typedef CBaseMaterial *( *InstantiateMaterialFn )( void );
class CFunnyMaterialRegistry
{
public:
CFunnyMaterialRegistry( InstantiateMaterialFn fn, const char *szName );
InstantiateMaterialFn m_CreateFn;
const char *m_szName;
CFunnyMaterialRegistry *m_pNext;
};
CBaseMaterial *CreateMaterial( const char *szName );
#define DEFINE_MATERIAL( className, name ) \
static CBaseMaterial *__Create##className##_material() { return ( CBaseMaterial* )( new className ); }; \
static CFunnyMaterialRegistry __CreateMaterail##className##_registry( __Create##className##_material, name );
#endif

30
game/client/milmoba/materials.cpp Normal file
View File

@@ -0,0 +1,30 @@
#include "materials.h"
class CBasicPBR: public CBaseMaterial
{
public:
DECLARE_CLASS(CBasicPBR, CBaseMaterial)
DECLARE_DATADESC()
FMat::XMFLOAT4 m_vAlbedo = { 1, 1, 1, 1 };
FMat::XMTexture m_tAlbedo = TEXTURE_NO_TEXTURE;
};
BEGIN_DATADESC(CBasicPBR)
DEFINE_KEYFIELD(m_vAlbedo, FIELD_SHADER_COLOR_FLOAT4, "AlbedoMultiplier")
DEFINE_KEYFIELD(m_tAlbedo, FIELD_SHADER_TEXTURE, "AlbedoTexture")
END_DATADESC()
DEFINE_MATERIAL(CBasicPBR, "funny_basic_pbr")
class CBasicError: public CBaseMaterial
{
public:
DECLARE_CLASS(CBasicError, CBaseMaterial)
DECLARE_DATADESC()
};
BEGIN_DATADESC(CBasicError)
END_DATADESC()
DEFINE_MATERIAL(CBasicError, "funny_error")

63
game/client/milmoba/player.cpp
View File

@@ -1,58 +1,10 @@
#include "../baseentity.h"
#include "../worldrender.h"
#include "materialsystem/imaterialsystem.h"
#include "game.h"
class C_MOBAPlayer: public C_BaseEntity
{
public:
DECLARE_CLASS(C_MOBAPlayer, C_BaseEntity)
virtual void Precache ( void ) override;
virtual void Spawn( void ) override;
virtual void Think( float fDelta );
IMesh *m_pMesh;
IMeshInstance *m_pMeshInstances[10];
};
#include "player.h"
#include "cglm/cglm.h"
#include "assetmgr.h"
void C_MOBAPlayer::Precache()
{
IVertexBuffer *pBuffer;
IBuffer *pDataBuffer;
IShader *pShader;
IMaterial *pMaterial;
pShader = g_pRenderContext->CreateShader("game/core/shaders/mesh_raster.shader_c");
IFileHandle *pHandle = filesystem->Open("game/core/meshes/spot.fmesh_c", FILEMODE_READ);
float *pData = (float*)V_malloc(filesystem->Size(pHandle));
filesystem->Read(pHandle, pData, filesystem->Size(pHandle));
pBuffer = g_pRenderContext->CreateVertexBuffer(filesystem->Size(pHandle));
pBuffer->Lock();
void *pMapped = pBuffer->Map();
V_memcpy(pMapped, pData, filesystem->Size(pHandle));
pBuffer->Unmap();
pBuffer->Unlock();
V_free(pData);
filesystem->Close(pHandle);
m_pMesh = g_pWorldRenderer->CreateMesh("game/core/meshes/spot.fmesh_c");
g_pWorldRenderer->SetCameraPosition((Vector){0,0,-20});
g_pWorldRenderer->SetCameraRotation((Quat){1,0,0,0});
m_pMesh->ConfigureShader(pShader);
pShader->Build();
pMaterial = g_pRenderContext->CreateMaterial(pShader);
m_pMesh->SetVertices(pBuffer);
m_pMesh->SetMaterial(pMaterial);
for (int i = 0; i < 10; i++)
{
m_pMeshInstances[i] = g_pWorldRenderer->CreateInstance(m_pMesh);
m_pMeshInstances[i]->SetScale({1, 1, 1});
m_pMeshInstances[i]->SetPosition({(float)i,0,0});
m_pMeshInstances[i]->SetRotation({1,0,0,0});
}
g_pAssetManager->LoadModel("game/core/models/cube.fmdl");
}
@@ -64,13 +16,6 @@ void C_MOBAPlayer::Spawn()
void C_MOBAPlayer::Think( float fDelta )
{
for (int i = 0; i < 10; i++)
{
m_pMeshInstances[i]->SetPosition({(float)i, 0 ,-(float)g_pEngineVars->m_fTime});
versor v;
glm_euler_zxy_quat((vec3){(float)g_pEngineVars->m_fTime,0,0}, v);
m_pMeshInstances[i]->SetRotation({v[0], v[1], v[2], v[3]});
}
};
LINK_ENTITY_TO_CLASS(player, C_MOBAPlayer)

17
game/client/milmoba/player.h Normal file
View File

@@ -0,0 +1,17 @@
#include "baseentity.h"
#include "worldrender.h"
#include "game.h"
#include "assetmgr.h"
class C_MOBAPlayer: public C_BaseEntity
{
public:
DECLARE_CLASS(C_MOBAPlayer, C_BaseEntity)
virtual void Precache ( void ) override;
virtual void Spawn( void ) override;
virtual void Think( float fDelta );
FunnyModel_t *pModel;
};

0
game/client/modelloader.cpp
View File

0
game/client/modelloader.h
View File

36
game/client/worldrender.cpp
View File

@@ -47,7 +47,7 @@ void CFunnyMesh::ConfigureShader( IShader *pShader )
pShader->AddOutputImage(1, IMAGE_FORMAT_RGBA16_SFLOAT);
pShader->AddOutputImage(2, IMAGE_FORMAT_RGBA32_SFLOAT);
pShader->SetMultisampling(MULTISAMPLE_TYPE_1_SAMPLES);
pShader->SetMultisampling(MULTISAMPLE_TYPE_4_SAMPLES);
pShader->SetDepthImage(IMAGE_FORMAT_D32_SFLOAT);
}
@@ -140,6 +140,7 @@ public:
private:
CUtlVector<CFunnyMesh*> m_pMeshes;
IImage *m_pOutputImage = NULL;
IImage *m_pResolvedOutputImage = NULL;
IImage *m_pDepthImage = NULL;
IImage *m_pNormalImage = NULL;
IImage *m_pWorldSpaceImage = NULL;
@@ -162,29 +163,35 @@ void CFunnyWorldRenderer::Init()
100,
100,
IMAGE_FORMAT_RGBA8_UNORM,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
m_pResolvedOutputImage = g_pRenderContext->CreateRenderTarget(
100,
100,
IMAGE_FORMAT_RGBA8_UNORM,
MULTISAMPLE_TYPE_1_SAMPLES
);
m_pNormalImage = g_pRenderContext->CreateRenderTarget(
100,
100,
IMAGE_FORMAT_RGBA16_SFLOAT,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
m_pWorldSpaceImage = g_pRenderContext->CreateRenderTarget(
100,
100,
IMAGE_FORMAT_RGBA32_SFLOAT,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
m_pDepthImage = g_pRenderContext->CreateRenderTarget(
100,
100,
IMAGE_FORMAT_D32_SFLOAT,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
g_pMainWindow->SetOutputImage(m_pOutputImage);
g_pMainWindow->SetOutputImage(m_pResolvedOutputImage);
m_pRasterCommandList = g_pRenderContext->CreateCommandList();
m_pViewBuffer = g_pRenderContext->CreateConstantBuffer(sizeof(ViewBuffer_t));
@@ -226,26 +233,31 @@ void CFunnyWorldRenderer::Frame( float fDelta )
g_pMainWindow->GetRenderWidth(),
g_pMainWindow->GetRenderHeight(),
IMAGE_FORMAT_RGBA8_UNORM,
MULTISAMPLE_TYPE_NONE);
MULTISAMPLE_TYPE_4_SAMPLES);
m_pResolvedOutputImage = g_pRenderContext->CreateRenderTarget(
g_pMainWindow->GetRenderWidth(),
g_pMainWindow->GetRenderHeight(),
IMAGE_FORMAT_RGBA8_UNORM,
MULTISAMPLE_TYPE_1_SAMPLES);
m_pNormalImage = g_pRenderContext->CreateRenderTarget(
g_pMainWindow->GetRenderWidth(),
g_pMainWindow->GetRenderHeight(),
IMAGE_FORMAT_RGBA16_SFLOAT,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
m_pWorldSpaceImage = g_pRenderContext->CreateRenderTarget(
g_pMainWindow->GetRenderWidth(),
g_pMainWindow->GetRenderHeight(),
IMAGE_FORMAT_RGBA32_SFLOAT,
MULTISAMPLE_TYPE_NONE
MULTISAMPLE_TYPE_4_SAMPLES
);
m_pDepthImage = g_pRenderContext->CreateRenderTarget(
g_pMainWindow->GetRenderWidth(),
g_pMainWindow->GetRenderHeight(),
IMAGE_FORMAT_D32_SFLOAT,
MULTISAMPLE_TYPE_NONE);
g_pMainWindow->SetOutputImage(m_pOutputImage);
MULTISAMPLE_TYPE_4_SAMPLES);
g_pMainWindow->SetOutputImage(m_pResolvedOutputImage);
}
m_pRasterCommandList->StartRecording();
m_pRasterCommandList->SetRenderResolution(uWidth, uHeight);
@@ -290,6 +302,8 @@ void CFunnyWorldRenderer::Frame( float fDelta )
m_pRasterCommandList->SetVertexBuffer(0, mesh->m_pVertexBuffer);
m_pRasterCommandList->DrawPrimitives(mesh->m_pVertexBuffer->GetSize()/32, 0, mesh->m_instances.GetSize(), 0);
}
m_pRasterCommandList->ResolveImage(m_pOutputImage, m_pResolvedOutputImage);
m_pRasterCommandList->EndRecording();
g_pRenderContext->SubmitCommandList(m_pRasterCommandList);