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);

4
game/server/baseentity.cpp
View File

@@ -103,7 +103,7 @@ lookforname:
BEGIN_DATADESC_NOBASE(CBaseEntity)
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()

20
game/server/build.cpp
View File

@@ -4,6 +4,7 @@
#define EXTERNAL "../../external/"
#define FUNNYSTDLIB EXTERNAL"funnystdlib/"
ADD_DEPENDENCY_BUILD_FILE(cfg, "../../buildcfg.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier0, FUNNYSTDLIB"tier0/build.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier1, FUNNYSTDLIB"tier1/build.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier2, FUNNYSTDLIB"tier2/build.cpp");
@@ -27,12 +28,19 @@ DECLARE_BUILD_STAGE(Server)
};
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)
{

97
game/server/datamap.h
View File

@@ -1,97 +0,0 @@
//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose: Valve-styled entity data maps
//
// Note: This file is insipired by Valve's convention in Source SDK, but it
// was written for scratch with compatibility in mind.
//
//===========================================================================//
#ifndef DATAMAP_H
#define DATAMAP_H
#include "stddef.h"
enum fieldtype_t {
FIELD_VOID = 0,
FIELD_FLOAT,
FIELD_STRING,
FIELD_VECTOR2D,
FIELD_VECTOR,
FIELD_VECTOR4D,
FIELD_QUATERNION,
FIELD_QUATERNION_QANGLE,
FIELD_COLOR255,
FIELD_COLOR1,
FIELD_INTEGER,
FIELD_BOOLEAN,
FIELD_MATERIAL,
FIELD_TEXTURE,
FIELD_MODEL,
};
struct typedescription_t
{
const char *m_szFieldName;
const char *m_szEditorName;
fieldtype_t m_eFieldType;
size_t m_iFieldOffset;
unsigned int m_uFieldCount;
unsigned short m_uFieldSize;
unsigned int m_iFlags;
};
struct datamap_t
{
struct datamap_t *m_pBase;
typedescription_t *m_pData;
int m_iNumFields;
};
#define DECLARE_DATADESC() \
datamap_t *GetBaseMap(); \
virtual datamap_t *GetDataMap() override; \
virtual datamap_t DataMapInit() override;
#define DECLARE_DATADESC_NOBASE() \
datamap_t *GetBaseMap(); \
virtual datamap_t *GetDataMap(); \
virtual datamap_t DataMapInit();
#define BEGIN_DATADESC( className ) \
datamap_t *className::GetBaseMap() { return BaseClass::GetDataMap(); } \
BEGIN_DATADESC_INTERNAL(className)
#define BEGIN_DATADESC_NOBASE( className ) \
datamap_t *className::GetBaseMap() { return NULL; } \
BEGIN_DATADESC_INTERNAL(className)
#define BEGIN_DATADESC_INTERNAL( className ) \
datamap_t *className::GetDataMap() { static datamap_t s_DataMap = ThisClass::DataMapInit(); return &s_DataMap; } \
datamap_t className::DataMapInit() \
{ \
datamap_t map; \
map.m_pBase = ThisClass::GetBaseMap(); \
static typedescription_t dataDesc[] \
{\
#define END_DATADESC() \
};\
map.m_iNumFields = sizeof(dataDesc)/sizeof(typedescription_t); \
map.m_pData = dataDesc; \
return map; \
}
#define IMPLEMENT_NULL_DATADESC( className ) \
BEGIN_DATADESC(className) \
END_DATADESC()
#define _class_offsetof( class, var ) ((size_t)&(((class*)0)->var))
#define _FIELD( name, fieldtype, count, flags, mapname, tolerance) { #name, mapname, fieldtype, _class_offsetof(ThisClass, name), count, sizeof(((ThisClass*)0)->name), flags },
#define DEFINE_KEYFIELD( name, fieldtype, mapname ) _FIELD( name, fieldtype, 1, FTYPEDESC_KEY, mapname, 0)
#define FTYPEDESC_KEY 0x0004
#endif

109
game/server/milmoba/baseentity.cpp
View File

@@ -1,109 +0,0 @@
//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose:
//
//===========================================================================//
#include "baseentity.h"
#include "datamap.h"
#include "tier0/lib.h"
CBaseEntity::~CBaseEntity()
{
}
void CBaseEntity::Spawn()
{
}
void CBaseEntity::SetAbsAngles( float fPitch, float fYaw, float fRoll )
{
}
void CBaseEntity::SetAbsOrigin( Vector origin )
{
m_vPosition = origin;
}
void CBaseEntity::SetScale( float fScale )
{
m_vScale.x = fScale;
m_vScale.y = fScale;
m_vScale.z = fScale;
}
QAngle CBaseEntity::GetAbsAngles( void )
{
}
Vector CBaseEntity::GetAbsOrigin( void )
{
}
float CBaseEntity::GetScale( void )
{
}
void CBaseEntity::SetThink( fnThink pfnThink )
{
m_pfnThink = pfnThink;
}
void CBaseEntity::SetNextThink( float fThink )
{
}
typedescription_t *CBaseEntity::FindDataByName( const char *szName )
{
datamap_t *pDataMap;
int i;
pDataMap = GetDataMap();
lookforname:
for ( i = 0; i < pDataMap->m_iNumFields; i++ )
{
if (!V_strcmp(pDataMap->m_pData[i].m_szFieldName, szName))
return &pDataMap->m_pData[i];
}
pDataMap = pDataMap->m_pBase;
if (pDataMap)
goto lookforname;
return NULL;
};
typedescription_t *CBaseEntity::FindDataByMapName( const char *szName )
{
datamap_t *pDataMap;
int i;
pDataMap = GetDataMap();
lookforname:
for ( i = 0; i < pDataMap->m_iNumFields; i++ )
{
if (!V_strcmp(pDataMap->m_pData[i].m_szEditorName, szName))
return &pDataMap->m_pData[i];
}
pDataMap = pDataMap->m_pBase;
if (pDataMap)
goto lookforname;
return NULL;
};
BEGIN_DATADESC_NOBASE(CBaseEntity)
DEFINE_KEYFIELD(m_vPosition, FIELD_VECTOR, "origin")
DEFINE_KEYFIELD(m_vRotation, FIELD_QUATERNION, "angles")
DEFINE_KEYFIELD(m_vScale, FIELD_VECTOR, "scales")
END_DATADESC()

79
game/server/milmoba/baseentity.h
View File

@@ -1,79 +0,0 @@
//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose:
//
//===========================================================================//
#ifndef BASEENTITY_H
#define BASEENTITY_H
#include "entitysystem.h"
#include "datamap.h"
#include "cglm/cglm.h"
#include "trig.h"
#define DECLARE_CLASS_NOBASE( className ) \
typedef className ThisClass;
#define DECLARE_CLASS( className, baseName ) \
typedef baseName BaseClass; \
typedef className ThisClass;
#define LINK_ENTITY_TO_CLASS( mapClassName, DLLClassName) \
static CEntityFactory<DLLClassName> g_EntityFactory_##mapClassName( #mapClassName );
class CBaseEntity;
class IEntityFactory
{
public:
virtual CBaseEntity *Create() = 0;
};
template<class T>
class CEntityFactory : public IEntityFactory
{
public:
CEntityFactory( const char *szClassName )
{
EntitySystem()->RegisterEntityClass(this, szClassName);
};
virtual CBaseEntity *Create() {
return new T;
}
};
class CBaseEntity;
typedef void(*fnThink)( CBaseEntity *pThis );
class CBaseEntity
{
public:
DECLARE_CLASS_NOBASE(CBaseEntity);
DECLARE_DATADESC_NOBASE()
typedescription_t *FindDataByName( const char *szName );
typedescription_t *FindDataByMapName( const char *szName );
virtual ~CBaseEntity();
virtual void Spawn();
virtual void SetAbsAngles( float fPitch, float fYaw, float fRoll );
virtual void SetAbsOrigin( Vector origin );
virtual void SetScale( float fScale );
virtual QAngle GetAbsAngles( void );
virtual Vector GetAbsOrigin( void );
virtual float GetScale( void );
virtual void SetThink( fnThink pfnThink );
virtual void SetNextThink( float fThink );
fnThink m_pfnThink = NULL;
private:
Vector m_vPosition;
Quat m_vRotation;
Vector m_vScale;
};
#endif

44
game/server/milmoba/build.cpp
View File

@@ -1,44 +0,0 @@
#include "helper.h"
#include "c.h"
#include "ld.h"
#define EXTERNAL "../../external/"
#define FUNNYSTDLIB EXTERNAL"funnystdlib/"
ADD_DEPENDENCY_BUILD_FILE(tier0, FUNNYSTDLIB"tier0/build.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier1, FUNNYSTDLIB"tier1/build.cpp");
ADD_DEPENDENCY_BUILD_FILE(tier2, FUNNYSTDLIB"tier2/build.cpp");
DECLARE_BUILD_STAGE(Server)
{
CProject_t compileProject = {};
LinkProject_t ldProject = {};
compileProject.m_szName = "server";
compileProject.files = {
"game.cpp",
"entitysystem.cpp",
"baseentity.cpp",
};
compileProject.includeDirectories = {
"../../public",
FUNNYSTDLIB"public",
EXTERNAL"cglm/include"
};
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 (ldProject.m_target.kernel & TARGET_KERNEL_WINDOWS_DEVICES)
{
ldProject.libraries.AppendTail("pthread");
};
CUtlString outputProject = linker->Link(&ldProject);
ADD_OUTPUT_OBJECT("server", outputProject);
return 0;
}

97
game/server/milmoba/datamap.h
View File

@@ -1,97 +0,0 @@
//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose: Valve-styled entity data maps
//
// Note: This file is insipired by Valve's convention in Source SDK, but it
// was written for scratch with compatibility in mind.
//
//===========================================================================//
#ifndef DATAMAP_H
#define DATAMAP_H
#include "stddef.h"
enum fieldtype_t {
FIELD_VOID = 0,
FIELD_FLOAT,
FIELD_STRING,
FIELD_VECTOR2D,
FIELD_VECTOR,
FIELD_VECTOR4D,
FIELD_QUATERNION,
FIELD_QUATERNION_QANGLE,
FIELD_COLOR255,
FIELD_COLOR1,
FIELD_INTEGER,
FIELD_BOOLEAN,
FIELD_MATERIAL,
FIELD_TEXTURE,
FIELD_MODEL,
};
struct typedescription_t
{
const char *m_szFieldName;
const char *m_szEditorName;
fieldtype_t m_eFieldType;
size_t m_iFieldOffset;
unsigned int m_uFieldCount;
unsigned short m_uFieldSize;
unsigned int m_iFlags;
};
struct datamap_t
{
struct datamap_t *m_pBase;
typedescription_t *m_pData;
int m_iNumFields;
};
#define DECLARE_DATADESC() \
datamap_t *GetBaseMap(); \
virtual datamap_t *GetDataMap() override; \
virtual datamap_t DataMapInit() override;
#define DECLARE_DATADESC_NOBASE() \
datamap_t *GetBaseMap(); \
virtual datamap_t *GetDataMap(); \
virtual datamap_t DataMapInit();
#define BEGIN_DATADESC( className ) \
datamap_t *className::GetBaseMap() { return BaseClass::GetDataMap(); } \
BEGIN_DATADESC_INTERNAL(className)
#define BEGIN_DATADESC_NOBASE( className ) \
datamap_t *className::GetBaseMap() { return NULL; } \
BEGIN_DATADESC_INTERNAL(className)
#define BEGIN_DATADESC_INTERNAL( className ) \
datamap_t *className::GetDataMap() { static datamap_t s_DataMap = ThisClass::DataMapInit(); return &s_DataMap; } \
datamap_t className::DataMapInit() \
{ \
datamap_t map; \
map.m_pBase = ThisClass::GetBaseMap(); \
static typedescription_t dataDesc[] \
{\
#define END_DATADESC() \
};\
map.m_iNumFields = sizeof(dataDesc)/sizeof(typedescription_t); \
map.m_pData = dataDesc; \
return map; \
}
#define IMPLEMENT_NULL_DATADESC( className ) \
BEGIN_DATADESC(className) \
END_DATADESC()
#define _class_offsetof( class, var ) ((size_t)&(((class*)0)->var))
#define _FIELD( name, fieldtype, count, flags, mapname, tolerance) { #name, mapname, fieldtype, _class_offsetof(ThisClass, name), count, sizeof(((ThisClass*)0)->name), flags },
#define DEFINE_KEYFIELD( name, fieldtype, mapname ) _FIELD( name, fieldtype, 1, FTYPEDESC_KEY, mapname, 0)
#define FTYPEDESC_KEY 0x0004
#endif

120
game/server/milmoba/entitysystem.cpp
View File

@@ -1,120 +0,0 @@
//================= Copyright kotofyt, All rights reserved ==================//
//
// Purpose:
//
//===========================================================================//
#include "entitysystem.h"
#include "baseentity.h"
#include "stddef.h"
#include "string.h"
#include "stdlib.h"
CEntitySystem *EntitySystem()
{
static CEntitySystem s_entitySystem;
return &s_entitySystem;
}
static struct EntityRegistry_t
{
IEntityFactory *m_pFactory;
const char *m_szClassName;
struct EntityRegistry_t *m_pNext;
} *s_pEntitiesRegistry = NULL;
CEntitySystem::CEntitySystem()
{
int i = 0;
for ( i = 0; i < MAX_EDICTS; i++ )
{
m_pEntities[i] = NULL;
}
m_nEntityCount = 0;
}
void CEntitySystem::RegisterEntityClass( IEntityFactory *pEntityFactory, const char *szClassName )
{
IEntityFactory *pFactory;
EntityRegistry_t *pRegistry;
pFactory = GetFactoryByClassname(szClassName);
if ( pFactory != NULL )
{
// Already registered
return;
}
pRegistry = new EntityRegistry_t;
pRegistry->m_pFactory = pEntityFactory;
pRegistry->m_pNext = s_pEntitiesRegistry;
pRegistry->m_szClassName = szClassName;
s_pEntitiesRegistry = pRegistry;
}
CBaseEntity *CEntitySystem::CreateByClassname( const char *szName )
{
IEntityFactory *pFactory;
CBaseEntity *pEntity;
int i;
int iSelectedSlot;
pFactory = GetFactoryByClassname(szName);
if ( !pFactory )
return NULL;
// We do not want to have more than MAX_EDICT entities
if ( m_nEntityCount >= MAX_EDICTS-1 )
return NULL;
// Search for space
// Could be more efficient but nobody cares
for ( i = 0; i < MAX_EDICTS; i++ )
{
if ( m_pEntities[i] == NULL )
{
iSelectedSlot = i;
break;
}
}
pEntity = pFactory->Create();
m_pEntities[iSelectedSlot] = pEntity;
m_nEntityCount++;
return pEntity;
}
IEntityFactory *CEntitySystem::GetFactoryByClassname( const char *szName )
{
EntityRegistry_t *pEntity;
for ( pEntity = s_pEntitiesRegistry; pEntity; pEntity = pEntity->m_pNext )
{
if (!strcmp(szName, pEntity->m_szClassName))
{
return pEntity->m_pFactory;
}
}
return NULL;
}
void CEntitySystem::Think()
{
CBaseEntity *pEntity;
int i;
for ( i = 0; i < MAX_EDICTS; i++ )
{
pEntity = m_pEntities[i];
if ( pEntity == NULL )
continue;
if ( !pEntity->m_pfnThink )
continue;
pEntity->m_pfnThink(pEntity);
}
}

49
game/server/milmoba/game.cpp
View File

@@ -1,49 +0,0 @@
#include "tier2/ifilesystem.h"
#include "materialsystem/imaterialsystem.h"
#include "enginebridge.h"
IFileSystem *filesystem;
IRenderContext *g_pRenderContext;
IGameWindow *g_pMainWindow;
class CFunnyGameBridge: public IEngineBridge
{
virtual void Init() override;
virtual void Tick( float fDelta ) override;
virtual void Frame( float fDelta ) override;
virtual void Shutdown() override;
virtual void ConnectInterface( const char *psz, void *pInterface ) override;
};
IEngineBridge *EngineBridge()
{
static CFunnyGameBridge s_bridge;
return &s_bridge;
}
EXPOSE_INTERFACE_FN(EngineBridge, IEngineBridge, ENGINE_BRIDGE_INTERFACE_VERSION)
void CFunnyGameBridge::Init()
{
}
void CFunnyGameBridge::Tick( float fDelta )
{
}
void CFunnyGameBridge::Frame( float fDelta )
{
}
void CFunnyGameBridge::Shutdown()
{
}
#define CONNECT_INTERFACE(szName, pGlobal) if (!V_strcmp(psz, szName)) { pGlobal = (typeof(pGlobal))pInterface; return; }
void CFunnyGameBridge::ConnectInterface( const char *psz, void *pInterface )
{
}

1
game/server/milmoba/player.cpp
View File

@@ -1 +0,0 @@

1
game/server/milmoba/scene.cpp
View File

@@ -1 +0,0 @@

4
game/server/milmoba/scene.h
View File

@@ -1,4 +0,0 @@
#ifndef GAME_SCENE_H
#define GAME_SCENE_H
#endif

20
game/shared/datamap.h
View File

@@ -15,19 +15,27 @@ enum fieldtype_t {
FIELD_VOID = 0,
FIELD_FLOAT,
FIELD_STRING,
FIELD_VECTOR2D,
FIELD_VECTOR,
FIELD_VECTOR4D,
FIELD_FLOAT2,
FIELD_FLOAT3,
FIELD_FLOAT4,
FIELD_QUATERNION,
FIELD_QUATERNION_QANGLE,
FIELD_COLOR255,
FIELD_COLOR1,
FIELD_INTEGER,
FIELD_BOOLEAN,
FIELD_MAT4x4,
FIELD_MATERIAL,
FIELD_TEXTURE,
FIELD_MODEL,
FIELD_SHADER_COLOR_FLOAT3,
FIELD_SHADER_COLOR_FLOAT4,
FIELD_SHADER_TEXTURE,
FIELD_END,
};
struct typedescription_t
@@ -49,6 +57,12 @@ struct datamap_t
int m_iNumFields;
};
#define DECLARE_CLASS_NOBASE( className ) \
typedef className ThisClass;
#define DECLARE_CLASS( className, baseName ) \
typedef baseName BaseClass; \
typedef className ThisClass;
#define DECLARE_DATADESC() \
datamap_t *GetBaseMap(); \
virtual datamap_t *GetDataMap() override; \