Renderer/pipeline setup

include/engine/engine.h

@@ -18,15 +18,11 @@
 #include <engine/component.h>
 #include <engine/object.h>
 #include <engine/scene.h>
-
 #include <engine/scene_manager.h>
+#include <engine/renderer/renderer.h>
 
-typedef struct engine_t
-{
-	void* window;
-	scene_manager_t* scene_manager;
-} engine_t;
 
+typedef struct engine_t engine_t;
 
 engine_t* engine_init(uint32_t screen_width, uint32_t screen_height, const char* window_name);
 void engine_terminate(engine_t* engine); 
@@ -38,7 +34,9 @@ void engine_update(engine_t* engine);
 
 
 
+void* engine_get_window(engine_t* engine);
 scene_manager_t* engine_get_scene_manager(engine_t* engine); 
+renderer_t* engine_get_renderer(engine_t* engine);
 
 
 #endif/*__ENGINE_H__*/

include/engine/material.h

@@ -2,7 +2,7 @@
 #define __MATERIAL_H__
 
 #include <engine/color.h>
-#include <utilities.h>
+#include <utilities/casting_utility.h>
 #include <stdint.h>
 
 #define Material_TYPE_ID ((uint64_t)(3))

include/engine/renderer/renderer.h

@@ -1,22 +1,16 @@
 
 #pragma once
-
-#include <GLFW/glfw3.h>
-#include <vulkan/vulkan.h>
-
-#include <tuple/header_config.h>
-#include <tuple/tuple.h>
-
 #include <stdint.h>
-#include <no_compile_header.h>
 
-typedef VkPhysicalDevice* pVkPhysicalDevice_t; 
-instantiate_tuple_t(uint32_t, pVkPhysicalDevice_t);
+typedef struct renderer_t renderer_t;
 
-VkInstance vk_create_instance(VkInstanceCreateInfo* create_info, VkAllocationCallbacks* host_memory_allocator); 
-tuple_t(uint32_t, pVkPhysicalDevice_t) vk_get_physical_devices(VkInstance instance);
+renderer_t* renderer_init();
+void renderer_terminate(renderer_t* renderer);
+void renderer_update(renderer_t* renderer);
 
-VkPhysicalDeviceProperties vk_get_physical_device_properties(VkPhysicalDevice physical_device);
-VkPhysicalDeviceFeatures vk_get_physical_device_features(VkPhysicalDevice physical_device);
-NOT_IMPLEMENTED VkPhysicalDeviceMemoryProperties vk_get_physical_device_memory_properties(VkPhysicalDevice physical_device);
-//NOT_IMPLEMENTED VkPhysicalDeviceQueueFamilyProperites vk_get_physical_device_queue_family_properties(VkPhysicalDevice physical_device);
+//Graphics API specifics
+void renderer_init_surface(renderer_t* renderer, void* surface);
+void* renderer_get_vulkan_instance(renderer_t* renderer);
+void* renderer_get_vulkan_device(renderer_t* renderer);
+void* renderer_get_vulkan_surface(renderer_t* renderer);
+void* renderer_get_vulkan_swapchain(renderer_t* renderer);

include/garbage_collector/garbage_collector.h

@@ -0,0 +1,31 @@
+
+#pragma once
+
+
+#include <tgc/tgc.h>
+
+extern tgc_t gc;
+
+#ifndef DEBUG
+#	define GC_START(stack_address) tgc_start(&gc, (void*)(stack_address))
+#	define GC_STOP() tgc_stop(&gc)
+#	define GC_RUN() tgc_run(&gc)
+#	define GC_PAUSE() tgc_pause(&gc)
+#	define GC_RESUME() tgc_resume(&gc)
+#	define GC_ALLOC(size) tgc_alloc(&gc, size)
+#	define GC_FREE(ptr) tgc_free(&gc, ptr)
+# 	warning "Using GC_ALLOC"
+#else
+#	include <stdlib.h>
+#	define GC_START(stack_address)
+#	define GC_STOP()
+#	define GC_RUN()
+#	define GC_PAUSE()
+#	define GC_RESUME()
+#	define GC_ALLOC(size) malloc(size)
+#	define GC_FREE(ptr) free(ptr)
+#	warning "Using MALLOC"
+#endif
+
+#define GC_NEW(type) (type*)GC_ALLOC(sizeof(type))
+#define GC_NEWV(type, count) (type*)GC_ALLOC(sizeof(type) * (count))

include/header_configuration_system/header_config_reset.h

@@ -1,47 +1,47 @@
-#ifdef HEADER_CONFIGURATION_SYSTEM_HEADER
+#if defined(HEADER_CONFIGURATION_SYSTEM_HEADER) && !defined(GLOBAL_HEADER)
 #	undef HEADER_CONFIGURATION_SYSTEM_HEADER
 #endif
 
-#ifdef HEADER
+#if defined(HEADER) && !defined(GLOBAL_HEADER)
 #	undef HEADER
 #endif
 
-#ifdef HPML_HEADER
+#if defined(HPML_HEADER) && !defined(GLOBAL_HEADER)
 #	undef HPML_HEADER
 #endif
 
-#ifdef HEADER_CONFIGURATION_SYSTEM_IMPLEMENTATION
+#if defined(HEADER_CONFIGURATION_SYSTEM_IMPLEMENTATION) && !defined(GLOBAL_IMPLEMENATION)
 #	undef HEADER_CONFIGURATION_SYSTEM_IMPLEMENTATION
 #endif
 
-#ifdef IMPLEMENTATION
+#if defined(IMPLEMENTATION) && !defined(GLOBAL_IMPLEMENATION)
 #	undef IMPLEMENTATION
 #endif
 
-#ifdef HPML_IMPLEMENTATION
+#if defined(HPML_IMPLEMENTATION) && !defined(GLOBAL_IMPLEMENATION)
 #	undef HPML_IMPLEMENTATION
 #endif
 
-#ifdef HEADER_CONFIGURATION_SYSTEM_DEBUG_MODE
+#if defined(HEADER_CONFIGURATION_SYSTEM_DEBUG_MODE) && !defined(GLOBAL_DEBUG)
 #	undef HEADER_CONFIGURATION_SYSTEM_DEBUG_MODE
 #endif
 
-#ifdef DEBUG_MODE
+#if defined(DEBUG_MODE) && !defined(GLOBAL_DEBUG)
 #	undef DEBUG_MODE
 #endif
 
-#ifdef DEBUG
+#if defined(DEBUG) && !defined(GLOBAL_DEBUG)
 #	undef DEBUG
 #endif
 
-#ifdef HEADER_CONFIGURATION_SYSTEM_RELEASE_MODE
+#if defined(HEADER_CONFIGURATION_SYSTEM_RELEASE_MODE) && !defined(GLOBAL_RELEASE)
 # 	undef HEADER_CONFIGURATION_SYSTEM_RELEASE_MODE
 #endif
 
-#ifdef RELEASE_MODE
+#if defined(RELEASE_MODE) && !defined(GLOBAL_RELEASE)
 #	undef RELEASE_MODE
 #endif
 
-#ifdef RELEASE
+#if defined(RELEASE) && !defined(GLOBAL_RELEASE)
 #	undef RELEASE
 #endif

include/string/string.h

@@ -0,0 +1,17 @@
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+const char* string(uint32_t length, const char* format, ...);
+const char* const* string_array(uint32_t count, ...);
+
+
+const char* string_bool(bool value); 
+const char* string_uint32(uint32_t value); 
+const char* string_int32(int32_t value); 
+const char* string_uint64(uint64_t value); 
+const char* string_int64(int64_t value);
+const char* string_float(float value); 
+const char* string_char(char value);

include/template_system.h

@@ -9,4 +9,15 @@
 #define template1(typename, T) template(typename, T)
 #define template2(typename, T1, T2) typename##_##T1##T2
 
+
+typedef char* pchar_t;
+typedef int* pint_t;
+typedef float* pfloat_t;
+typedef double* pdouble_t;
+
+typedef const char* pcchar_t;
+typedef const int* pcint_t; 
+typedef const float* pcfloat_t;
+typedef const double* pcdouble_t;
+
 #endif/*__HPML_TEMPLATE_SYSTEM_H__*/

include/tgc/tgc.h

@@ -0,0 +1,51 @@
+#ifndef TGC_H
+#define TGC_H
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <setjmp.h>
+
+enum {
+  TGC_MARK = 0x01,
+  TGC_ROOT = 0x02,
+  TGC_LEAF = 0x04
+};
+
+typedef struct {
+  void *ptr;
+  int flags;
+  size_t size, hash;
+  void (*dtor)(void*);
+} tgc_ptr_t;
+
+typedef struct {
+  void *bottom;
+  int paused;
+  uintptr_t minptr, maxptr;
+  tgc_ptr_t *items, *frees;
+  double loadfactor, sweepfactor;
+  size_t nitems, nslots, mitems, nfrees;
+} tgc_t;
+
+void tgc_start(tgc_t *gc, void *stk);
+void tgc_stop(tgc_t *gc);
+void tgc_pause(tgc_t *gc);
+void tgc_resume(tgc_t *gc);
+void tgc_run(tgc_t *gc);
+
+void *tgc_alloc(tgc_t *gc, size_t size);
+void *tgc_calloc(tgc_t *gc, size_t num, size_t size);
+void *tgc_realloc(tgc_t *gc, void *ptr, size_t size);
+void tgc_free(tgc_t *gc, void *ptr);
+
+void *tgc_alloc_opt(tgc_t *gc, size_t size, int flags, void(*dtor)(void*));
+void *tgc_calloc_opt(tgc_t *gc, size_t num, size_t size, int flags, void(*dtor)(void*));
+
+void tgc_set_dtor(tgc_t *gc, void *ptr, void(*dtor)(void*));
+void tgc_set_flags(tgc_t *gc, void *ptr, int flags);
+int tgc_get_flags(tgc_t *gc, void *ptr);
+void(*tgc_get_dtor(tgc_t *gc, void *ptr))(void*);
+size_t tgc_get_size(tgc_t *gc, void *ptr);
+
+#endif