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

.fpccfg

@@ -1,2 +1,8 @@
 [wasm32-unknown-wasi]
 sysroot = "/home/kotofyt/Downloads/wasi-sysroot-29.0/"
+
+[aarch64-apple-ios]
+sysroot = "/home/kotofyt/clones/yay/xcode/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
+
+[x86_64-apple-ios]
+sysroot = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"

build.cpp

@@ -5,6 +5,7 @@
 auto szTarget = Target_t::DefaultTarget().GetTriplet();
 auto szOutputDir = CUtlString("build/funnygame/%s/game", szTarget.GetString());
 
+ADD_DEPENDENCY_BUILD_FILE(cfg, "buildcfg.cpp");
 ADD_DEPENDENCY_BUILD_FILE(launcher, "launcher/build.cpp");
 ADD_DEPENDENCY_BUILD_FILE(engine, "engine/build.cpp");
 ADD_DEPENDENCY_BUILD_FILE(ms, "materialsystem/build.cpp");
@@ -18,18 +19,23 @@ ADD_DEPENDENCY_BUILD_FILE(client, "game/client/build.cpp");
 DECLARE_BUILD_STAGE(install_game)
 {
 	filesystem2->MakeDirectory(szOutputDir);
+	if ( GET_PROJECT_VALUE(config, "static") != "true" )
+	{
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(engine, "engine"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(MaterialSystem, "MaterialSystem"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(RenderSystemVulkan, "RenderSystemVulkan"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(tier0, "tier0"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(filesystem_std, "fs"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(shadercompiler, "fs"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(Server, "server"));
+		filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(Client, "client"));
+	}
 	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(launcher, "launcher"));
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(engine, "engine"));
+	filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "funnyassets/models");
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(MaterialSystem, "MaterialSystem"));
+	filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "funnyassets/meshes");
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(RenderSystemVulkan, "RenderSystemVulkan"));
+	filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "funnyassets/materials");
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(tier0, "tier0"));
+	filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "funnyassets/textures");
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(filesystem_std, "fs"));
+	filesystem2->CopyDirectory(CUtlString("%s/core/",szOutputDir.GetString()), "build/funnygame/assets/shaders");
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(shadercompiler, "fs"));
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(Server, "server"));
-	filesystem2->CopyFile(szOutputDir, GET_PROJECT_OBJECT(Client, "client"));
-	filesystem2->CopyDirectory(CUtlString("%s/core",szOutputDir.GetString()), "funnyassets/meshes");
-	filesystem2->CopyDirectory(CUtlString("%s/core",szOutputDir.GetString()), "funnyassets/textures");
-	filesystem2->CopyDirectory(CUtlString("%s/core",szOutputDir.GetString()), "build/funnygame/assets/shaders");
 	if (Target_t::DefaultTarget().kernel == TARGET_KERNEL_WINDOWS)
 	{
 		filesystem2->CopyFile(szOutputDir, EXTERNAL "windows/libgcc_s_seh-1.dll");

buildcfg.cpp

@@ -0,0 +1,15 @@
+#include "helper.h"
+
+DECLARE_BUILD_STAGE(config)
+{
+	if (Target_t::DefaultTarget().kernel == TARGET_KERNEL_IOS)
+	{
+		ADD_OUTPUT_VALUE("static", "true");
+	}
+	else
+	{
+		ADD_OUTPUT_VALUE("static", "false");
+	}
+	ADD_OUTPUT_VALUE("static", "true");
+	return 0;
+}

engine/build.cpp

@@ -4,6 +4,7 @@
 #include "tier1/utlstring.h"
 
 #define FUNNYSTDLIB "../external/funnystdlib/"
+ADD_DEPENDENCY_BUILD_FILE(cfg, "../buildcfg.cpp");
 ADD_DEPENDENCY_BUILD_FILE(MaterialSystem, "../materialsystem/build.cpp")
 ADD_DEPENDENCY_BUILD_FILE(tier0, FUNNYSTDLIB"tier0/build.cpp");
 ADD_DEPENDENCY_BUILD_FILE(tier1, FUNNYSTDLIB"tier1/build.cpp");
@@ -32,13 +33,19 @@ DECLARE_BUILD_STAGE(engine)
 	compileProject.bFPIC = true;
 	ldProject = ccompiler->Compile(&compileProject);
 
-	ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
-
+	{
-	ldProject.libraryObjects = {
+		ldProject.linkType = ELINK_STATIC_LIBRARY;
-		GET_PROJECT_LIBRARY(tier0, "tier0"),
+	}
-	};
+	else
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	{
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier2, "tier2")});
+		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)
 	{

funnyassets/materials/cube.fmat

@@ -1,4 +1,4 @@
 {
-	"shader": "mesh_raster.shader",
+	"shader": "funny_basic_pbr",
-	"albedo": "bricks.png"
+	"AlbedoTexture": "game/core/textures/bricks.png"
 }

funnyassets/materials/error.fmat

@@ -0,0 +1,3 @@
+{
+	"shader": "funny_error",
+}

funnyassets/models/cube.fmdl

@@ -1,7 +1,4 @@
-[
 {
-	"model": "cube.fmesh",
+	"mesh": "cube.fmesh",
-	"material": "cube.fmat",
+	"material": "cube.fmat"
-	"physics": "cube.fmesh"
 }
-]

funnyassets/shaders/funny_error.shader

@@ -0,0 +1,9 @@
+#include "macros.hlsl"
+
+BRDF
+{
+	float4 brdfMain()
+	{
+		return float4(1);
+	}
+}

funnyassets/shaders/macros.hlsl

@@ -15,4 +15,10 @@
 #define PS namespace PixelShader_DO_NOT_USE
 #endif
 
+#ifdef BRDF_SHADER
+#define BRDF using namespace BRDFShader; namespace BRDFShader 
+#else
+#define BRDF namespace BRDFShader_DO_NOT_USE
+#endif
+
 #endif

funnyassets/shaders/mesh_trace.shader

@@ -0,0 +1 @@
+#include "macros.hlsl"

funnyassets/shaders/ray_trace.hlsl

@@ -0,0 +1,30 @@
+#ifndef RAY_TRACE_H
+#define RAY_TRACE_H
+
+#ifdef SOFTWARE_RAY_TRACING
+struct funnyAccelerationStructure
+{
+
+}
+#else
+struct funnyAccelerationStructure
+{
+	RaytracingAccelerationStructure accel;
+}
+#endif
+
+struct funnyHitObject
+{
+	static funnyHitObject TraceRay<T>(
+		funnyAccelerationStructure AccelerationStructure,
+		uint RayFlags,
+		uint InstanceInclusionMask,
+		uint RayContributionToHitGroupIndex,
+		uint MultiplierForGeometryContributionToHitGroupIndex,
+		uint MissShaderIndex,
+		RayDesc Ray,
+		inout T Payload
+	);
+};
+
+#endif

game/client/assetmgr.cpp

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

game/client/assetmgr.h

@@ -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

game/client/baseentity.cpp

@@ -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()

game/client/baseentity.h

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

game/client/build.cpp

@@ -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 = {
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
-		GET_PROJECT_LIBRARY(tier0, "tier0"),
+	{
-	};
+		ldProject.linkType = ELINK_STATIC_LIBRARY;
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	}
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier2, "tier2")});
+	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)
 	{

game/client/materials.cpp

@@ -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;
+}

game/client/materials.h

@@ -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

game/client/milmoba/materials.cpp

@@ -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")

game/client/milmoba/player.cpp

@@ -1,58 +1,10 @@
-#include "../baseentity.h"
+#include "player.h"
-#include "../worldrender.h"
+#include "cglm/cglm.h"
-#include "materialsystem/imaterialsystem.h"
+#include "assetmgr.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];
-};
 
 void C_MOBAPlayer::Precache()
 {
-	IVertexBuffer *pBuffer;
+	g_pAssetManager->LoadModel("game/core/models/cube.fmdl");
-	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});
-	}
 }
 
 
@@ -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)

game/client/milmoba/player.h

@@ -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;
+};

game/client/worldrender.cpp

@@ -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);
+				MULTISAMPLE_TYPE_4_SAMPLES);
-		g_pMainWindow->SetOutputImage(m_pOutputImage);
+		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);

game/server/baseentity.cpp

@@ -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()

game/server/build.cpp

@@ -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;
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
-	ldProject.libraryObjects = {
+	{
-		GET_PROJECT_LIBRARY(tier0, "tier0"),
+		ldProject.linkType = ELINK_STATIC_LIBRARY;
-	};
+	}
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	else 
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier2, "tier2")});
+	{
+		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)
 	{

game/server/datamap.h

@@ -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

game/server/milmoba/baseentity.cpp

@@ -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()

game/server/milmoba/baseentity.h

@@ -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

game/server/milmoba/build.cpp

@@ -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;
-}

game/server/milmoba/datamap.h

@@ -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

game/server/milmoba/entitysystem.cpp

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

game/server/milmoba/game.cpp

@@ -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 )
-{
-}
-

game/server/milmoba/player.cpp

@@ -1 +0,0 @@
-

game/server/milmoba/scene.cpp

@@ -1 +0,0 @@
-

game/server/milmoba/scene.h

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

game/shared/datamap.h

@@ -15,19 +15,27 @@ enum fieldtype_t {
 	FIELD_VOID = 0,
 	FIELD_FLOAT,
 	FIELD_STRING,
-	FIELD_VECTOR2D,
+	FIELD_FLOAT2,
-	FIELD_VECTOR,
+	FIELD_FLOAT3,
-	FIELD_VECTOR4D,
+	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; \

launcher/build.cpp

@@ -3,6 +3,15 @@
 #include "c.h"
 #include "ld.h"
 #include "tier1/utlstring.h"
+#include "appletool.h"
+
+ADD_DEPENDENCY_BUILD_FILE(cfg, "../buildcfg.cpp");
+ADD_DEPENDENCY_BUILD_FILE(engine, "../engine/build.cpp");
+ADD_DEPENDENCY_BUILD_FILE(ms, "../materialsystem/build.cpp");
+ADD_DEPENDENCY_BUILD_FILE(fs, "../external/funnystdlib/stdfilesystems/build.cpp");
+ADD_DEPENDENCY_BUILD_FILE(tier0, "../external/funnystdlib/tier0/build.cpp");
+ADD_DEPENDENCY_BUILD_FILE(server, "../game/server/build.cpp");
+ADD_DEPENDENCY_BUILD_FILE(client, "../game/client/build.cpp");
 
 DECLARE_BUILD_STAGE(launcher)
 {
@@ -11,10 +20,36 @@ DECLARE_BUILD_STAGE(launcher)
 
 	compileProject.m_szName = "launcher";
 	compileProject.files = {"launcher.cpp"};
+	compileProject.includeDirectories = {"../external/SDL/include"};
 	ldProject = ccompiler->Compile(&compileProject);
 	ldProject.linkType = ELINK_EXECUTABLE;
+	if (compileProject.m_target.kernel == TARGET_KERNEL_IOS)
+	{
+		ldProject.frameworkDirectories = {"../external/ios"};
+		ldProject.frameworks = {"SDL3"};
+	}
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
+	{
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(engine, "engine")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(MaterialSystem, "MaterialSystem")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(RenderSystemVulkan, "RenderSystemVulkan")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(tier0, "tier0")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(filesystem_std, "fs")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(shadercompiler, "fs")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(Server, "server")});
+		ldProject.objects.AppendTail({GET_PROJECT_OBJECT(Client, "client")});
+	}
 
 	CUtlString outputProject = linker->Link(&ldProject);
+	if (compileProject.m_target.kernel == TARGET_KERNEL_IOS)
+	{
+		AppleManifest_t manifest = {};
+		manifest.SetPackageName("funnygame");
+		manifest.SetPackageID("com.kotofyt.funnygame");
+		manifest.SetPackageExecutable(outputProject);
+		V_printf("%s\n", manifest.m_szPackageName.GetString());
+		CUtlString szIpa = AppleTool()->BuildPackage( manifest, manifest.BuildManifest() );
+	}
 	ADD_OUTPUT_OBJECT("launcher", outputProject);
 	return 0;
 };

launcher/launcher.cpp

@@ -52,9 +52,7 @@ int main( int argc, char **argv ) {
 #ifdef __APPLE__
 	uint32_t pathSize = sizeof(szLauncherPath);
 	int pathResult = _NSGetExecutablePath(szLauncherPath, &pathSize);
-	printf("%s\n",szLauncherPath);
 	char *szLauncherPath2 = dirname(szLauncherPath);
-	printf("%s\n",szLauncherPath2);
 	snprintf(szEnginePath, MAX_PATH, "%s/libengine.dylib", szLauncherPath2);
 	snprintf(szTier0Path, MAX_PATH, "%s/libtier0.dylib", szLauncherPath2);
 #endif

materialsystem/build.cpp

@@ -5,6 +5,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");
@@ -46,15 +47,23 @@ DECLARE_BUILD_STAGE(MaterialSystem)
 	};
 	compileProject.bFPIC = true;
 	ldProject = ccompiler->Compile(&compileProject);
-	ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
-	ldProject.libraryObjects = {
+	{
-		GET_PROJECT_LIBRARY(tier0, "tier0"),
+		ldProject.linkType = ELINK_STATIC_LIBRARY;
-	};
+	}
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	else
+	{
+		ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
+		ldProject.libraryObjects = {
+			GET_PROJECT_LIBRARY(tier0, "tier0"),
+		};
+		ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	}
 
 	if (ldProject.m_target.kernel == TARGET_KERNEL_WINDOWS)
 	{
 		ldProject.libraryDirectories.AppendTail(EXTERNAL"windows");
+		ldProject.libraries.AppendTail("winpthread-1");
 	};
 
 	CUtlString outputProject = linker->Link(&ldProject);
@@ -79,16 +88,25 @@ DECLARE_BUILD_STAGE(RenderSystemVulkan)
 		EXTERNAL"Vulkan-Headers/include",
 		EXTERNAL"Vulkan-Utility-Libraries/include",
 		EXTERNAL"VulkanMemoryAllocator/include",
-		EXTERNAL"volk"
+		EXTERNAL"volk",
+		EXTERNAL,
 	};
 	compileProject.bFPIC = true;
 	ldProject = ccompiler->Compile(&compileProject);
 	ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
-	ldProject.libraryObjects = {
+	if ( GET_PROJECT_VALUE(config, "static") == "true" )
-		GET_PROJECT_LIBRARY(tier0, "tier0"),
+	{
-	};
+		ldProject.linkType = ELINK_STATIC_LIBRARY;
-	ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+	}
-	ldProject.libraries.AppendTail("SDL3");
+	else 
+	{
+		ldProject.linkType = ELINK_DYNAMIC_LIBRARY;
+		ldProject.libraryObjects = {
+			GET_PROJECT_LIBRARY(tier0, "tier0"),
+		};
+		ldProject.objects.AppendTail({GET_PROJECT_LIBRARY(tier1, "tier1")});
+		ldProject.libraries.AppendTail("SDL3");
+	}
 	if (ldProject.m_target.kernel == TARGET_KERNEL_WINDOWS)
 	{
 		ldProject.libraryDirectories.AppendTail(EXTERNAL"windows");

materialsystem/stb.c

@@ -1,2 +1,3 @@
 #define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_THREAD_LOCALS
 #include "stb/stb_image.h"

materialsystem/vulkan/commandbuffer.cpp

@@ -208,6 +208,7 @@ void CVkCommandBuffer::SortDependencies()
 	}
 
 
+	/*
 	for (auto &pCommand: m_commands)
 	{
 		for ( auto dependency: pCommand->m_dependencies)
@@ -262,6 +263,7 @@ void CVkCommandBuffer::SortDependencies()
 			}
 		}
 	}
+	*/
 }
 
 

materialsystem/vulkan/commands.h

@@ -74,6 +74,11 @@ BEGIN_VULKAN_COMMAND(SetViewport)
 	float fDepthMax = 1;
 END_VULKAN_COMMAND(SetViewport)
 
+BEGIN_VULKAN_COMMAND(ResolveImage)
+	VkFrameObject_t stInputImage;
+	VkFrameObject_t stOutputImage;
+END_VULKAN_COMMAND(ResolveImage)
+
 BEGIN_VULKAN_COMMAND(CopyBufferToImage)
 	IBuffer *pBuffer;
 	VkFrameObject_t stOutputImage;

materialsystem/vulkan/commands/draw.cpp

@@ -122,6 +122,35 @@ DECLARE_VULKAN_COMMAND(SetViewport)
 	};
 	vkCmdSetViewportWithCount(hCommandBuffer, 1, &v);
 }
+DECLARE_VULKAN_COMMAND(ResolveImage)
+{
+	CVkImage *pInput = (CVkImage*)VulkanGetObject(stInputImage, iCurrentFrame);
+	CVkImage *pOutput = (CVkImage*)VulkanGetObject(stOutputImage, iCurrentFrame);
+	VkImageResolve2 r = {
+		.sType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,
+		.srcSubresource = {
+			.aspectMask = pInput->m_range.aspectMask,
+			.layerCount = 1,
+		},
+		.srcOffset = {0,0,0},
+		.dstSubresource = {
+			.aspectMask = pOutput->m_range.aspectMask,
+			.layerCount = 1,
+		},
+		.dstOffset = {0,0,0},
+		.extent = {pInput->m_nWidth, pInput->m_nHeight, 1}
+	};
+	VkResolveImageInfo2 i = {
+		.sType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2,
+		.srcImage = pInput->m_image,
+		.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+		.dstImage = pOutput->m_image,
+		.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+		.regionCount = 1,
+		.pRegions = &r,
+	};
+	vkCmdResolveImage2(hCommandBuffer, &i);
+}
 DECLARE_VULKAN_COMMAND(CopyBufferToImage)
 {
 	VkBufferImageCopy2 r = {

materialsystem/vulkan/rendercommandlist.cpp

@@ -9,11 +9,13 @@ CVkRenderCommandList::~CVkRenderCommandList()
 
 void CVkRenderCommandList::ResetRendering()
 {
-	for ( auto m: m_materials )
+	for ( auto m: m_pCommandBuffers )
 	{
-		m_pCommandBufferManager->FreeCommandBufferWithCommands(m.m_pCommandBuffer);
+		m_pCommandBufferManager->FreeCommandBufferWithCommands(m);
 	}
+	m_pPostRaster = NULL;
 	m_materials = {};
+	m_pCommandBuffers = {};
 }
 
 void CVkRenderCommandList::SetRenderTarget( uint32_t uIndex, IImage *pImage )
@@ -162,6 +164,14 @@ void CVkRenderCommandList::ResolveImage( IImage *pOriginal, IImage *pResolved )
 {
 	SwitchRenderingStage(RENDERING_STAGE_POST_RASTER);
 
+	CVkResolveImageCommand *pCmd = CREATE_COMMAND(m_pCommandBufferManager, ResolveImage);
+	pCmd->stInputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
+	pCmd->stInputImage.m_pSingle = pOriginal;
+	pCmd->stOutputImage.m_eObjectType = FRAME_OBJECT_TYPE_SINGLE;
+	pCmd->stOutputImage.m_pSingle = pResolved;
+	pCmd->AddDependency(pOriginal, DEPENDENCY_MODE_IMAGE_SOURCE);
+	pCmd->AddDependency(pResolved, DEPENDENCY_MODE_IMAGE_DESTINATION);
+	m_pPostRaster->AddCommand(pCmd);
 }
 
 
@@ -172,25 +182,43 @@ void CVkRenderCommandList::StartRecording()
 
 void CVkRenderCommandList::EndRecording()
 {
-	for ( auto m: m_materials)
+	SwitchRenderingStage(RENDERING_STAGE_FINISHED);
-	{
-		CVkEndCommand *pEndCommand = CREATE_COMMAND(m_pCommandBufferManager, End);
-		m.m_pCommandBuffer->AddCommand(pEndCommand);
-		m.m_pCommandBuffer->Render();
-	}
 }
 
 void CVkRenderCommandList::Submit()
 {
-	for ( auto m: m_materials)
+	for ( auto m: m_pCommandBuffers)
 	{
-		m.m_pCommandBuffer->Submit();
+		m->Submit();
 	}
 }
 
 void CVkRenderCommandList::SwitchRenderingStage( EVulkanRenderingStage eStage )
 {
-
+	if (eStage != RENDERING_STAGE_RASTER)
+	{
+		for ( auto m: m_materials)
+		{
+			CVkEndCommand *pEndCommand = CREATE_COMMAND(m_pCommandBufferManager, End);
+			m.m_pCommandBuffer->AddCommand(pEndCommand);
+			m.m_pCommandBuffer->Render();
+			m_pCommandBuffers.AppendTail(m.m_pCommandBuffer);
+		}
+		m_materials = {};
+	};
+	if (eStage == RENDERING_STAGE_POST_RASTER)
+	{
+		m_pPostRaster = m_pCommandBufferManager->CreateCommandBuffer();
+		m_pPostRaster->Reset();
+	}
+	else 
+	{
+		if (m_pPostRaster)
+		{
+			m_pPostRaster->Render();
+			m_pCommandBuffers.AppendTail(m_pPostRaster);
+		}
+	}
 }
 
 VulkanRenderOutput_t *CVkRenderCommandList::FindOrCreateRenderOutput( uint32_t uIndex )

materialsystem/vulkan/rendercontext.cpp

@@ -255,7 +255,10 @@ CVkBuffer::CVkBuffer( uint32_t nSize, VkBufferUsageFlags2 eUsage, uint32_t nAlig
 	VkBufferDeviceAddressInfo stAddress = {};
 
 	stUsage.sType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
-	stUsage.usage = eUsage | VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
+	stUsage.usage = eUsage 
+		| VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT
+		| VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT
+		| VK_BUFFER_USAGE_2_TRANSFER_DST_BIT;
 	if (eUsage & VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT)
 	{
 		m_eDescriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
@@ -391,7 +394,7 @@ uint32_t CVkTextureArray::CreateTexture( uint32_t i, const char *szPath )
 	int uHeight = 0;
 	int uChannels = 0;
 	unsigned char *pImg = stbi_load_from_memory(data.GetMemory(), data.GetSize(), &uWidth, &uHeight, &uChannels, 4);
-	IBuffer *pBuffer = m_pRenderContext->CreateStorageBuffer(uWidth*uHeight*uChannels);
+	IBuffer *pBuffer = m_pRenderContext->CreateStorageBuffer(uWidth*uHeight*4);
 	pBuffer->Lock();
 	void *pData = pBuffer->Map();
 	V_memcpy(pData, pImg, uWidth*uHeight*uChannels);
@@ -557,7 +560,9 @@ IImage *CVkRenderContext::CreateRenderTarget( uint32_t x, uint32_t y, EImageForm
 }
 IImage *CVkRenderContext::CreateTexture( uint32_t x, uint32_t y, EImageFormat eFormat, EMultisampleType eMultisampleType )
 {
-	return new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT);
+	CVkImage *pImage = new CVkImage(x, y, 1, eFormat, eMultisampleType, IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT);
+	pImage->m_ePreferredLayout = VK_IMAGE_LAYOUT_GENERAL;
+	return pImage;
 }
 
 IImage *CVkRenderContext::CreateStorageImage( uint32_t x, uint32_t y, EImageFormat eFormat, EMultisampleType eMultisampleType )
@@ -826,7 +831,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	CUtlVector<uint32_t> uImageIndexes = {};
 	CUtlVector<uint32_t> uSwapchainImageIndexes = {};
 	CUtlVector<VulkanWindow_t> recreatedWindows = {};
-	vkDeviceWaitIdle(s_vkDevice);
 
 	for ( auto &m: m_pMaterials)
 	{
@@ -849,7 +853,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	{
 		m_renderWindows.AppendTail(s);
 	}
-	vkDeviceWaitIdle(s_vkDevice);
 
 	for ( auto &s: m_renderWindows)
 	{
@@ -875,6 +878,7 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	s_pPresentCommandBuffer = m_pCommandBufferManager->CreateCommandBuffer();
 	s_pPresentCommandBuffer->Reset();
 
+	double a = Plat_GetTime();
 	i = 0;
 	for ( auto &s: m_renderWindows )
 	{
@@ -937,7 +941,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
 		s.m_uCurrentFrame = (s.m_uCurrentFrame + 1) % FRAMES_IN_FLIGHT;
 	}
 	m_pCommandBufferManager->RenderingFinished();
-	vkDeviceWaitIdle(s_vkDevice);
 
 	for (auto &a: m_scheduledRemovalBuffers)
 	{
@@ -950,7 +953,6 @@ void CVkRenderContext::Frame( float fDeltaTime )
 	m_scheduledRemovalLists = {};
 	m_scheduledRemovalBuffers = {};
 	m_pCommandBufferManager->FreeCommandBufferWithCommands(s_pPresentCommandBuffer);
-	vkDeviceWaitIdle(s_vkDevice);
 
 }
 

materialsystem/vulkan/vulkan_state.h

@@ -422,12 +422,14 @@ private:
 
 	CUtlVector<VulkanRenderOutput_t> m_pOutput = {};
 	CUtlVector<VulkanMaterialCommandBuffer_t> m_materials = {};
-	IVkCommandBuffer *m_pPostRaster;
+	IVkCommandBuffer *m_pPostRaster = NULL;
 
 	IVkCommandBuffer *m_pCurrentMaterialBuffer = NULL;
 
 	uint32_t m_uWidth;
 	uint32_t m_uHeight;
+	CUtlVector<IVkCommandBuffer*> m_pCommandBuffers = {};
+	CUtlVector<IVkCommandBuffer*> m_pScheduledDestroyPostRaster = {};
 };
 
 

shadercompiler/slang/vulkan_spirv.cpp

@@ -63,6 +63,9 @@ void CSlangVulkanSpirvShaderCompiler::CompileShaderStage( EShaderStage eStage, c
 	case SHADER_STAGE_PIXEL:
 		eSlangStage = SLANG_STAGE_PIXEL;
 		break;
+	case SHADER_STAGE_CALLABLE:
+		eSlangStage = SLANG_STAGE_CALLABLE;
+		break;
 	default:
 		break;
 	}
@@ -70,6 +73,8 @@ void CSlangVulkanSpirvShaderCompiler::CompileShaderStage( EShaderStage eStage, c
 	pProgramLayout = pModule->getLayout();
 	uint32_t uCount = pProgramLayout->getParameterCount();
 
+	// we want to get all inputs
+	// just for the sake of making vulkan simple
 	CUtlVector<VulkanDescriptor_t> inputs;
 	VulkanDescriptor_t input = {};
 	for ( uint32_t u = 0; u < uCount; u++ )
@@ -86,7 +91,6 @@ trygetkind:
 		case slang::TypeReflection::Kind::ConstantBuffer:
 			input.eDescriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
 			break;
-		case slang::TypeReflection::Kind::Resource:
 			V_printf("%s: %i\n", pType->getName(), pType->getResourceShape());
 			switch(pType->getResourceShape())
 			{
@@ -122,16 +126,34 @@ trygetkind:
 		V_printf("%i\n", input.uCount);
 		inputs.AppendTail(input);
 	}
-	
+
 
 	pModule->findAndCheckEntryPoint(szMain, eSlangStage, &pEntryPoint, &m_pDiagnostics);
+
+	// stage was not defined
+	if (pEntryPoint == NULL)
+	{
+		// fool it
+		m_pDiagnostics = NULL;
+		return;
+	}
 	CheckDiagnostics();
 
 	pEntryPoint->link(&pLinked, &m_pDiagnostics);
 	CheckDiagnostics();
+	if (pLinked == NULL)
+	{
+		pEntryPoint->release();
+		return;
+	}
 
 	pLinked->getEntryPointCode(0, 0, &pBinary, &m_pDiagnostics);
 	CheckDiagnostics();
+	if (pBinary == NULL)
+	{
+		pEntryPoint->release();
+		return;
+	}
 
 	pShaderObject = pShader->AllocateShader();
 	pShaderObject->m_eBackend = SHADER_BACKEND_SPIRV_VULKAN;
@@ -145,6 +167,13 @@ trygetkind:
 	pShaderObject->m_nMetadataLump = pShader->AllocateLump(sizeof(VulkanInputMetaData_t));
 	V_memcpy(pShader->GetLumpPtr(pShaderObject->m_nDataLump), pBinary->getBufferPointer(), pBinary->getBufferSize());
 	V_memcpy(pShader->GetLumpPtr(pShaderObject->m_nMetadataLump), &stMetadata, sizeof(VulkanInputMetaData_t));
+	if (eStage == SHADER_STAGE_CALLABLE)
+	{
+		IFileHandle *ph = filesystem->Open("a.txt", FILEMODE_WRITE);
+		filesystem->Write(ph, pBinary->getBufferPointer(), pBinary->getBufferSize());
+		filesystem->Close(ph);
+
+	}
 
 	pEntryPoint->release();
 }
@@ -196,6 +225,10 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi
 			szMainName = "psMain";
 			stStageMacroDesc = { "PS_SHADER", "Enabled" };
 			break;
+		case SHADER_STAGE_CALLABLE:
+			szMainName = "brdfMain";
+			stStageMacroDesc = { "BRDF_SHADER", "Enabled" };
+			break;
 		default:
 			break;
 		}
@@ -212,7 +245,8 @@ void CSlangVulkanSpirvShaderCompiler::CompileShader( const char *szInput, CCompi
 	
 		CompileShaderStage((EShaderStage)i, szMainName, pSession, pModule, pShader);
 		pModule->release();
-		pSession->release();
+		// ah yes free(): corrupted unsorted chunks
+		//pSession->release();
 	}
 
 	V_free((void*)szShaderSource);
@@ -224,6 +258,7 @@ void CSlangVulkanSpirvShaderCompiler::CheckDiagnostics()
 	{
 		V_printf("%s\n",(const char*)m_pDiagnostics->getBufferPointer());
 	}
+	m_pDiagnostics = NULL;
 };
 
 void CSlangVulkanSpirvShaderCompiler::Init()