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

introduces ios support? still needs metal

Browse Source
This commit is contained in:
kotofyt
2025-06-29 01:21:55 +03:00
parent af4f0c3cad
commit cdeaac7c0c
79 changed files with 2176 additions and 1349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
public/baseentity.h
View File

@@ -61,8 +61,7 @@ CEntityRegistry __entity_##name##_registry(#name, #class, __entity_alloc_##name)
//-----------------------------------------------------------------------------
// Base client entity class.
// It recieves pure server data, which has to be interpolated by the client to
// get smoother image.
// It uses server data directly.
//-----------------------------------------------------------------------------
class C_BaseEntity
{

3
public/brush.h
View File

@@ -5,6 +5,7 @@
#include "rendering.h"
#include "baseentity.h"
#include "physics.h"
#include "mesh.h"
//-----------------------------------------------------------------------------
// Basic triangle structure which is used in brush entities.
@@ -51,8 +52,6 @@ private:
IVertexBuffer *vertexBuffer;
IIndexBuffer *indexBuffer;
IMesh *mesh;
IMaterial material;
ITexture *pAlbedo;
};
#endif

5
public/console.h
View File

@@ -13,15 +13,20 @@ typedef void(*ConCommandFn)(int argc, char **argv);
interface IConsole
{
public:
// Variables
static void RegisterVar( ConVar *cvar );
static void UnRegisterVar( ConVar *cvar );
static ConVar *FindVar( const char *pName );
// Commands
static void RegisterCommand( ConCommand *cvar );
static void UnRegisterCommand( ConCommand *cvar );
static ConCommand *FindCommand( const char *pName );
// Command buffer
static void Execute( void );
static CUtlVector<CUtlVector<CUtlString>> ParseCommandLine( CUtlString psz );
static void AddCommand( const char *psz );
static void InsertCommand( const char *psz );
private:

21
public/input.h
View File

@@ -3,6 +3,11 @@
#include "tier0/platform.h"
//-----------------------------------------------------------------------------
// Keys include mouse buttons and gamepad buttons as well.
// KEY_NONE and AXIS_NONE are garbage, so don't rely on them
//-----------------------------------------------------------------------------
enum EKeyEventType
{
KEY_EVENT_TYPE_DOWN,
@@ -81,13 +86,24 @@ enum EInputKey
KEY_X,
KEY_Y,
KEY_Z,
KEY_MAX,
KEY_NUM_KEYS = KEY_MAX - 1,
};
enum EInputAxis
{
AXIS_NONE,
AXIS_MOUSE_X,
AXIS_MOUSE_Y,
AXIS_MOUSE_SCROLL,
AXIS_MAX,
AXIS_NUM_AXIS = AXIS_MAX - 1,
};
enum EMouseMode
{
MOUSE_MODE_GAME,
MOUSE_MODE_MENU,F
};
interface IInput
@@ -95,9 +111,12 @@ interface IInput
public:
static void Init( void );
static void KeyEvent( EInputKey key, EKeyEventType event );
static void AxisEvent( unsigned char axis, float fX, float fY );
static void AxisEvent( EInputAxis axis, float fValue );
static void SetMouseMode( EMouseMode mode );
static void Frame( void );
static void Deinit( void );
};
extern float g_fAxisValues[AXIS_NUM_AXIS];
#endif

5
public/math3d.h
View File

@@ -4,5 +4,10 @@
#include "tier0/minmax_off.h"
#include "cglm/cglm.h"
#include "cglm/affine.h"
#include "cglm/mat4.h"
#include "cglm/mat3.h"
#include "cglm/mat2.h"
#include "tier0/minmax.h"
#define PX_GLM_VEC3(v) (px_vec3){v[0], v[1], v[2]}
#endif

31
public/mesh.h Normal file
View File

@@ -0,0 +1,31 @@
#include "rendering.h"
//----------------------------------------------------------------------------
// Mesh handler for the rendering
//----------------------------------------------------------------------------
abstract_class IMesh
{
public:
virtual void SetVertexBuffer( IVertexBuffer *pBuffer ) = 0;
virtual void SetIndexBuffer( IIndexBuffer *pBuffer ) = 0;
virtual void SetPosition( vec3 position ) = 0;
virtual void SetRotationEuler( vec3 angle ) = 0;
virtual void SetRotationQuat( vec4 quaternion) = 0;
virtual void SetMatrix( mat4 matrix ) = 0;
virtual void SetScale( vec3 scale ) = 0;
virtual void Draw() = 0;
};
interface IMeshRendering: public IRenderingPipelineStep
{
public:
virtual IMesh *CreateMesh();
};
interface IModelManager
{
public:
virtual void LoadModel( const char *szPath );
};

26
public/physics.h
View File

@@ -4,6 +4,7 @@
#include "tier0/lib.h"
#include "stdint.h"
#include "tier1/utlvector.h"
#include "math3d.h"
typedef void Collider;
@@ -23,10 +24,25 @@ typedef struct u128 {
extern funnyphysics *px;
struct PxCastResult_t
{
bool bHit;
float fTime;
vec3 position;
vec3 normal;
vec3 normal2;
};
interface IPxWorld
{
public:
static PxCastResult_t BoxCast( vec3 size, vec3 origin, vec3 destination, vec3 rotation = (vec3){0,0,0} );
};
class CPxCollider
{
public:
virtual void Spawn( float fFriction = 0.5 ) = 0;
virtual void Spawn( float fFriction = 0.0 ) = 0;
virtual void Destroy( void );
Collider *m_pCollider;
};
@@ -34,7 +50,7 @@ public:
class CPxBallMesh: public CPxCollider
{
public:
virtual void Spawn( float fFriction = 0.5 ) override;
virtual void Spawn( float fFriction = 0.0 ) override;
virtual void Destroy( void ) override;
float m_fRadius;
};
@@ -42,7 +58,7 @@ public:
class CPxBoxMesh: public CPxCollider
{
public:
virtual void Spawn( float fFriction = 0.5 ) override;
virtual void Spawn( float fFriction = 0.0 ) override;
virtual void Destroy( void ) override;
float m_fRadius[3];
};
@@ -50,7 +66,7 @@ public:
class CPxTriangleMesh: public CPxCollider
{
public:
virtual void Spawn( float fFriction = 0.5 ) override;
virtual void Spawn( float fFriction = 0.0 ) override;
virtual void Destroy( void ) override;
};
@@ -58,6 +74,8 @@ class CPxRigidKinematicPosition
{
public:
void Spawn( CPxCollider *pCollider, px_matrix matrix, px_rigidbody_params params );
void SetPosition( px_vec3 position );
void SetPositionTeleport( px_vec3 position );
px_vec3 GetPosition( void );
px_matrix GetMatrix ( void );
void Destroy( void );

455
public/rendering.h
View File

@@ -5,109 +5,234 @@
#include "tier0/platform.h"
#include "tier1/utlbuffer.h"
#include "baseentity.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
extern mat4 g_cameraView;
enum EImageFormat
{
IMAGE_FORMAT_R8,
IMAGE_FORMAT_R8G8,
IMAGE_FORMAT_R8G8B8,
IMAGE_FORMAT_R8G8B8A8,
IMAGE_FORMAT_R16,
IMAGE_FORMAT_R16G16,
IMAGE_FORMAT_R16G16B16,
IMAGE_FORMAT_R16G16B16A16,
IMAGE_FORMAT_R32,
IMAGE_FORMAT_R32G32,
IMAGE_FORMAT_R32G32B32,
IMAGE_FORMAT_R32G32B32A32,
IMAGE_FORMAT_DEPTH,
IMAGE_FORMAT_RENDERING = IMAGE_FORMAT_R8G8B8A8,
};
enum EImageUsage
{
IMAGE_USAGE_COLOR_ATTACHMENT = 0x1,
IMAGE_USAGE_DEPTH_ATTACHMENT = 0x2,
IMAGE_USAGE_STORAGE = 0x4,
};
enum EVertexFormat
{
VERTEX_FORMAT_X16,
VERTEX_FORMAT_X16Y16,
VERTEX_FORMAT_X16Y16Z16,
VERTEX_FORMAT_X16Y16Z16W16,
VERTEX_FORMAT_X32,
VERTEX_FORMAT_X32Y32,
VERTEX_FORMAT_X32Y32Z32,
VERTEX_FORMAT_X32Y32Z32W32,
};
enum EMSAAMode
{
MSAA_MODE_DISABLED,
MSAA_MODE_MIN,
MSAA_MODE_MAX,
MSAA_MODE_AVERAGE,
};
enum EDepthMode
{
DEPTH_MODE_DISABLED,
DEPTH_MODE_EQUAL,
DEPTH_MODE_NOT_EQUAL,
DEPTH_MODE_LESS,
DEPTH_MODE_LESS_EQUAL,
DEPTH_MODE_GREATER,
DEPTH_MODE_GREATER_EQUAL,
};
enum EShaderInputType
{
SHADER_INPUT_TYPE_STORAGE_BUFFER,
SHADER_INPUT_TYPE_UNIFORM_BUFFER,
SHADER_INPUT_TYPE_IMAGE,
SHADER_INPUT_TYPE_TLAS,
// All available textures are binded
SHADER_INPUT_TYPE_TEXTURES,
};
enum EShaderType
{
SHADER_TYPE_VERTEX,
SHADER_TYPE_GEOMETRY,
SHADER_TYPE_FRAGMENT,
SHADER_TYPE_COMPUTE,
SHADER_TYPE_RAY_GEN,
SHADER_TYPE_CLOSEST_HIT,
SHADER_TYPE_MISS,
SHADER_TYPE_INTERSECTION,
SHADER_TYPE_ANY_HIT,
};
enum EBarrierMemoryPermissions
{
BARRIER_MEMORY_PERMISSIONS_VERTEX_BUFFER_READ = 0x1,
BARRIER_MEMORY_PERMISSIONS_INDEX_BUFFER_READ = 0x2,
BARRIER_MEMORY_PERMISSIONS_UNIFORM_BUFFER_READ = 0x4,
BARRIER_MEMORY_PERMISSIONS_SHADER_READ = 0x8,
BARRIER_MEMORY_PERMISSIONS_SHADER_WRITE = 0x10,
BARRIER_MEMORY_PERMISSIONS_COLOR_READ = 0x20,
BARRIER_MEMORY_PERMISSIONS_COLOR_WRITE = 0x40,
BARRIER_MEMORY_PERMISSIONS_DEPTH_READ = 0x80,
BARRIER_MEMORY_PERMISSIONS_DEPTH_WRITE = 0x100,
BARRIER_MEMORY_PERMISSIONS_COPY_READ = 0x200,
BARRIER_MEMORY_PERMISSIONS_COPY_WRITE = 0x400,
};
enum EBarrierStage
{
BARRIER_STAGE_TOP,
BARRIER_STAGE_VERTEX_INPUT,
BARRIER_STAGE_VERTEX_SHADER,
BARRIER_STAGE_GEOMETRY_SHADER,
BARRIER_STAGE_FRAGMENT_SHADER,
BARRIER_STAGE_COMPUTE_SHADER,
BARRIER_STAGE_RAY_TRACING_SHADER,
BARRIER_STAGE_BOTTOM,
};
enum EAttachmentLoadMode
{
ATTACHMENT_LOAD_MODE_DONT_CARE,
ATTACHMENT_LOAD_MODE_CLEAR,
ATTACHMENT_LOAD_MODE_LOAD,
};
enum EAttachmentStoreMode
{
ATTACHMENT_STORE_MODE_DONT_CARE,
ATTACHMENT_STORE_MODE_STORE,
};
enum EPipelineType
{
PIPELINE_TYPE_RASTERIZATION,
PIPELINE_TYPE_COMPUTE,
PIPELINE_TYPE_RAY_TRACING,
};
interface IVideo
{
public:
static void Init();
static void CreatePipelines( void );
static void Frame( float fDelta );
};
abstract_class IVertexBuffer
abstract_class IBuffer
{
public:
virtual void *Map() = 0;
virtual void Unmap() = 0;
};
abstract_class IIndexBuffer
typedef IBuffer IStorageBuffer;
typedef IBuffer IUniformBuffer;
typedef IBuffer IVertexBuffer;
typedef IBuffer IIndexBuffer;
abstract_class IImage
{
public:
virtual void *Map() = 0;
virtual void Unmap() = 0;
};
enum EMaterialType
{
IMATERIAL_ERROR = 0,
IMATERIAL_PBR = 1,
IMATERIAL_FULLBRIGHT = 2,
};
struct MaterialProperties_t
{
EMaterialType type;
vec3 albedoColor;
const char *szAlbedoTexture;
const char *szNormalsTexture;
const char *szRoughnessTexture;
const char *szMetalnessTexture;
vec2 uvScaling;
};
struct Material_t
{
uint32_t shader;
uint32_t albedo;
uint32_t normal;
uint32_t roughness;
uint32_t metalness;
vec3 albedoColor;
};
abstract_class IMaterial
{
public:
Material_t m;
};
interface IRenderer
{
public:
static IVertexBuffer *CreateVertexBuffer( uint32_t uSize );
static IIndexBuffer *CreateIndexBuffer( uint32_t uSize );
static IMaterial *LoadMaterial( const char *szName );
static void SetMaterial( IMaterial *pMaterial );
EImageFormat format;
};
//----------------------------------------------------------------------------
// Mesh handler for the rendering
// Bottom level acceleration structure for ray tracing.
//----------------------------------------------------------------------------
abstract_class IMesh
abstract_class IBLAS
{
public:
virtual void SetPosition( vec3 position ) = 0;
virtual void SetRotationEuler( vec3 angle ) = 0;
virtual void SetRotationQuat( vec4 quaternion) = 0;
virtual void SetMatrix( mat4 matrix ) = 0;
virtual void SetScale( vec3 scale ) = 0;
virtual void SetVertexBuffer( IVertexBuffer *pBuffer ) = 0;
virtual void SetIndexBuffer( IIndexBuffer *pBuffer ) = 0;
virtual void SetMaterial( IMaterial *pMaterial ) = 0;
virtual void Draw() = 0;
virtual void Build() = 0;
virtual void Update() = 0;
};
interface IMeshRenderer
//----------------------------------------------------------------------------
// Bottom level acceleration structure with triangle geometry.
//----------------------------------------------------------------------------
abstract_class IBLASMesh: public IBLAS
{
public:
static void Init();
static void Frame( float fDelta );
static IMesh *CreateMesh();
static void Destroy( IMesh *pModel );
virtual void SetMesh( IVertexBuffer *pVertex, IIndexBuffer *pIndex ) = 0;
};
//----------------------------------------------------------------------------
// Bottom level acceleration structure with AABB geometry.
//----------------------------------------------------------------------------
abstract_class IBLASAABB: public IBLAS
{
public:
virtual void SetBoundaries( vec4 size );
};
//----------------------------------------------------------------------------
// Top level acceleration structure for handling worlds
//----------------------------------------------------------------------------
abstract_class ITLAS
{
public:
virtual void AddInstance( IBLAS *pBLAS, mat4 matrix, uint32_t data ) = 0;
virtual void ResetInstances() = 0;
};
struct ShaderInput_t
{
EShaderInputType type;
uint32_t binding;
};
struct Shader_t
{
const char *szPath;
EShaderType type;
};
abstract_class IPipeline
{
public:
EPipelineType type;
};
typedef IPipeline IGraphicsPipeline;
typedef IPipeline IComputePipeline;
typedef IPipeline IRayTracingPipeline;
//----------------------------------------------------------------------------
// Texture handle
//----------------------------------------------------------------------------
abstract_class ITexture
{
public:
@@ -115,19 +240,195 @@ public:
uint32_t id;
};
//----------------------------------------------------------------------------
// Manages loaded textures
//----------------------------------------------------------------------------
interface ITextureManager
{
public:
static uint32_t GetTexture(ITexture *pTexture);
static uint32_t GetTextureID(ITexture *pTexture);
static ITexture *LoadTexture( void *pData, uint32_t X, uint32_t Y, uint32_t numChannels );
static ITexture *LoadTexture( const char *szName );
};
interface IPostProcessRenderer
struct BufferBarrier_t
{
public:
static void Init();
static void Frame( float fDelta );
EBarrierMemoryPermissions in;
EBarrierMemoryPermissions out;
IBuffer *pBuffer;
};
struct ImageBarrier_t
{
EBarrierMemoryPermissions in;
EBarrierMemoryPermissions out;
IBuffer *pBuffer;
};
struct VertexAttribute_t
{
uint32_t offset;
uint32_t binding;
EVertexFormat format;
};
struct RenderingColorAttachment_t
{
IImage *pOutput;
IImage *pTemporary;
EAttachmentLoadMode loadMode;
EAttachmentStoreMode storeMode;
EMSAAMode msaaMode;
vec4 clearColor;
};
struct RenderingDepthAttachment_t
{
IImage *pOutput;
IImage *pTemporary;
EAttachmentLoadMode loadMode;
EAttachmentStoreMode storeMode;
EMSAAMode msaaMode;
float clearValue;
};
//----------------------------------------------------------------------------
// Manages all buffers and pipelines.
// It is meant to be used in render pipelines
//----------------------------------------------------------------------------
interface IRenderer
{
public:
static IStorageBuffer *CreateStorageBuffer( uint32_t uSize );
static IUniformBuffer *CreateUniformBuffer( uint32_t uSize );
static IVertexBuffer *CreateVertexBuffer( uint32_t uSize );
static IIndexBuffer *CreateIndexBuffer( uint32_t uSize );
static IImage *CreateImage( EImageFormat format, uint32_t usage, uint32_t nWidth, uint32_t nHeight, uint32_t nSamples = 1 );
static void DestroyBuffer( IBuffer *pBuffer );
static void DestroyImage( IImage *pImage );
static void SetConstants( uint32_t nSize, uint32_t nOffset, void *pData );
static void Barrier( EBarrierStage stageIn, uint32_t stageOut, CUtlVector<BufferBarrier_t> buffers, CUtlVector<ImageBarrier_t> images );
static void BindData( uint32_t binding, IBuffer *pBuffer, IImage* pImage);
static void BindPipeline( IPipeline *pPipeline );
static void Begin( uint32_t nWidth, uint32_t nHeight, CUtlVector<RenderingColorAttachment_t> attachments, RenderingDepthAttachment_t depth );
static void ResetState();
static void SetDepthMode( EDepthMode mode );
static void Draw( IVertexBuffer *pVertex, IIndexBuffer *pIndex );
static void Dispatch( uint32_t x, uint32_t y, uint32_t z );
static void TraceRays( uint32_t x, uint32_t y, uint32_t z );
static void End();
static IGraphicsPipeline *CreateGraphicsPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize,
CUtlVector<EImageFormat> outputFormats
);
static IComputePipeline *CreateComputePipeline(
Shader_t szShader,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize
);
static IRayTracingPipeline *CreateRayTracingPipeline(
CUtlVector<Shader_t> shaders,
CUtlVector<ShaderInput_t> inputs,
uint32_t nConstantsSize
);
};
abstract_class IRenderingPipelineStep
{
public:
virtual void Init() = 0;
virtual void Frame( float fDelta ) = 0;
virtual void Deinit() = 0;
};
struct RenderingStep_t
{
IRenderingPipelineStep *pPipeline;
const char *szName;
};
extern CUtlVector<RenderingStep_t> g_StepPrepass;
extern CUtlVector<RenderingStep_t> g_StepMeshRendering;
extern CUtlVector<RenderingStep_t> g_StepShading;
extern CUtlVector<RenderingStep_t> g_StepPostProcessing;
extern CUtlVector<RenderingStep_t> g_StepUI;
typedef IRenderingPipelineStep*(*CreateRenderStepFn)();
class CRenderingStep
{
public:
CRenderingStep();
CRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CPrepassRenderingStep: public CRenderingStep
{
public:
CPrepassRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CMeshRenderingStep: public CRenderingStep
{
public:
CMeshRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CShadingRenderingStep: public CRenderingStep
{
public:
CShadingRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CPostProcessingRenderingStep: public CRenderingStep
{
public:
CPostProcessingRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
class CUIRenderingStep: public CRenderingStep
{
public:
CUIRenderingStep(const char *szStepName, CreateRenderStepFn pfn);
};
#define DECLARE_MESH_PREPASS_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
return new class; \
}; \
CPrepassRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_MESH_RENDERING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
return new class; \
}; \
CMeshRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_MESH_SHADING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
return new class; \
}; \
CShadingRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_POST_PROCESSING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
return new class; \
}; \
CPostProcessingRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#define DECLARE_UI_RENDERING_STAGE(class, name) \
IRenderingPipelineStep *__rendering_stage_##name() \
{ \
return new class; \
}; \
CUIRenderingStep __renering_##name##_registry(#name, __rendering_stage_##name);
#endif

6
public/tier0/lib.h
View File

@@ -44,6 +44,12 @@
#define V_strtok strtok
#define V_strxfrm strxfrm
#ifdef __WIN32__
#define V_stricmp stricmp
#else
#define V_stricmp strcasecmp
#endif
//-----------------------------------------------------------------------------
// stdio.h
//-----------------------------------------------------------------------------

2
public/tier0/platform.h
View File

@@ -57,6 +57,6 @@ PLATFORM_INTERFACE void *Plat_GetProc( void *lib, const char *psz );
PLATFORM_INTERFACE void Plat_UnloadLibrary( void *psz );
PLATFORM_INTERFACE double Plat_GetTime( void );
PLATFORM_INTERFACE void Plat_Exit( int status );
#endif

2
public/tier1/commandline.h
View File

@@ -9,7 +9,7 @@ interface ICommandLine
public:
static void CreateCommandLine( int argc, char **argv );
static bool CheckParam( char *psz );
static bool CheckParam( const char *psz );
static char *ParamValue( const char* psz );
static void AddParam( char *psz );

104
public/vk_video.h
View File

@@ -1,104 +0,0 @@
#ifndef VK_VIDEO_H
#define VK_VIDEO_H
#include "rendering.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "vulkan/vulkan.h"
#include "vulkan/vulkan_core.h"
#ifndef VULKAN_RENDERING_IMPL
#error "Not a vulkan rendering implementation. Do not use this file!"
#endif
#include "vk_mem_alloc.h"
struct vk_framedata_t {
VkSemaphore draw;
VkSemaphore present;
VkFence fence;
};
struct vk_shader_t
{
void Create( const char *szPath, VkShaderStageFlagBits shaderStage );
void Create( CUtlBuffer<uint8_t> &spirv, VkShaderStageFlagBits shaderStage );
void Destroy( void );
VkShaderModule m_shaderModule = NULL;
VkPipelineShaderStageCreateInfo m_stageCreateInfo;
};
struct vk_tripipeline_t
{
void Create(
CUtlVector<vk_shader_t> &shaders,
CUtlVector<VkDescriptorSetLayoutBinding> &bindings,
uint32_t pushConstantsSize,
CUtlVector<VkFormat> formats
/* the rest of the stuff is set by the dynamic state */
/* literally */
);
void Destroy();
CUtlVector<vk_shader_t> m_shaders;
VkDescriptorSetLayout m_descriptorSetLayout;
VkPipelineLayout m_layout;
VkPipeline m_pipeline;
};
struct vk_comppipeline_t
{
void Create(
vk_shader_t &shader,
CUtlVector<VkDescriptorSetLayoutBinding> &bindings,
uint32_t pushConstantsSize
);
void Destroy();
VkDescriptorSetLayout m_descriptorSetLayout;
VkPipelineLayout m_layout;
VkPipeline m_pipeline;
};
struct vk_buffer_t
{
void Create(size_t size, VkBufferUsageFlags usage);
void Destroy();
void *Map(size_t offset, size_t size);
void Unmap();
void CopyTo(struct vk_image2d_t *image);
void CopyTo(struct vk_buffer_t *buffer);
size_t m_nSize;
VkBuffer m_buffer;
VmaAllocation m_memory;
VkDeviceAddress m_address;
};
struct vk_image2d_t
{
void Create(size_t x, size_t y, VkFormat format, VkImageUsageFlags usage, VkSampleCountFlagBits samples);
void Destroy();
void CopyTo(struct vk_image2d_t *image);
void CopyTo(struct vk_buffer_t *buffer);
uint32_t m_X;
uint32_t m_Y;
VkFormat m_format;
VkImage m_image;
VkImageView m_imageView;
VmaAllocation m_memory;
};
interface IVulkan
{
public:
static void Init();
static void Frame();
static void Deinit();
};
#endif