kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initializing Vulkan Context

Browse Source
This commit is contained in:
Kearwood Gilbert
2018-08-06 21:34:16 -07:00
parent db13a05a7e
commit 6f8a99f543
5 changed files with 268 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -89,6 +89,9 @@ add_subdirectory(hydra)
include_directories(hydra/include) include_directories(hydra/include)
target_link_libraries(kraken hydra) target_link_libraries(kraken hydra)
# ---- Vulkan ----
find_package(Vulkan REQUIRED)
target_link_libraries(kraken Vulkan::Vulkan)
# ---- OpenGL ---- # ---- OpenGL ----
find_package(OpenGL REQUIRED) find_package(OpenGL REQUIRED)

101
kraken/KRContext.cpp
View File

@@ -47,7 +47,9 @@ const char *KRContext::extension_names[KRENGINE_NUM_EXTENSIONS] = {
KRContext::log_callback *KRContext::s_log_callback = NULL; KRContext::log_callback *KRContext::s_log_callback = NULL;
void *KRContext::s_log_callback_user_data = NULL; void *KRContext::s_log_callback_user_data = NULL;
KRContext::KRContext() : m_streamer(*this) KRContext::KRContext()
: m_streamer(*this)
, m_vulkanInstance(VK_NULL_HANDLE)
{ {
m_streamingEnabled = false; m_streamingEnabled = false;
#ifdef __APPLE__ #ifdef __APPLE__
@@ -282,8 +284,11 @@ void KRContext::loadResource(const std::string &file_name, KRDataBlock *data) {
} else if(extension.compare("obj") == 0) { } else if(extension.compare("obj") == 0) {
KRResource::LoadObj(*this, file_name); KRResource::LoadObj(*this, file_name);
#if !TARGET_OS_IPHONE #if !TARGET_OS_IPHONE
/*
// FINDME, TODO, HACK! - Uncomment
} else if(extension.compare("fbx") == 0) { } else if(extension.compare("fbx") == 0) {
KRResource::LoadFbx(*this, file_name); KRResource::LoadFbx(*this, file_name);
*/
} else if(extension.compare("blend") == 0) { } else if(extension.compare("blend") == 0) {
KRResource::LoadBlenderScene(*this, file_name); KRResource::LoadBlenderScene(*this, file_name);
#endif #endif
@@ -387,20 +392,20 @@ void KRContext::getMemoryStats(long &free_memory)
void KRContext::doStreaming() void KRContext::doStreaming()
{ {
if(m_streamingEnabled) { if (m_streamingEnabled) {
/* /*
long free_memory = KRENGINE_GPU_MEM_TARGET; long free_memory = KRENGINE_GPU_MEM_TARGET;
long total_memory = KRENGINE_GPU_MEM_MAX; long total_memory = KRENGINE_GPU_MEM_MAX;
*/ */
/* /*
#if TARGET_OS_IPHONE #if TARGET_OS_IPHONE
// FINDME, TODO, HACK! - Experimental code, need to expose through engine parameters // FINDME, TODO, HACK! - Experimental code, need to expose through engine parameters
const long KRENGINE_RESERVE_MEMORY = 0x4000000; // 64MB const long KRENGINE_RESERVE_MEMORY = 0x4000000; // 64MB
getMemoryStats(free_memory); getMemoryStats(free_memory);
free_memory = KRCLAMP(free_memory - KRENGINE_RESERVE_MEMORY, 0, KRENGINE_GPU_MEM_TARGET); free_memory = KRCLAMP(free_memory - KRENGINE_RESERVE_MEMORY, 0, KRENGINE_GPU_MEM_TARGET);
total_memory = KRMIN(KRENGINE_GPU_MEM_MAX, free_memory * 3 / 4 + m_pTextureManager->getMemUsed() + m_pMeshManager->getMemUsed()); total_memory = KRMIN(KRENGINE_GPU_MEM_MAX, free_memory * 3 / 4 + m_pTextureManager->getMemUsed() + m_pMeshManager->getMemUsed());
#endif #endif
*/ */
/* /*
@@ -411,7 +416,7 @@ void KRContext::doStreaming()
free_memory = 0; free_memory = 0;
} }
*/ */
/* /*
// FINDME, TODO - Experimental code, need to expose through engine parameters // FINDME, TODO - Experimental code, need to expose through engine parameters
const long MEMORY_WARNING_THROTTLE2_FRAMES = 30; const long MEMORY_WARNING_THROTTLE2_FRAMES = 30;
@@ -421,31 +426,75 @@ void KRContext::doStreaming()
free_memory /= 2; free_memory /= 2;
} }
*/ */
/* /*
m_pMeshManager->doStreaming(total_memory, free_memory); m_pMeshManager->doStreaming(total_memory, free_memory);
m_pTextureManager->doStreaming(total_memory, free_memory); m_pTextureManager->doStreaming(total_memory, free_memory);
*/ */
long streaming_start_frame = m_current_frame; long streaming_start_frame = m_current_frame;
long memoryRemaining = KRENGINE_GPU_MEM_TARGET; long memoryRemaining = KRENGINE_GPU_MEM_TARGET;
long memoryRemainingThisFrame = KRENGINE_GPU_MEM_MAX - m_pTextureManager->getMemUsed() - m_pMeshManager->getMemUsed(); long memoryRemainingThisFrame = KRENGINE_GPU_MEM_MAX - m_pTextureManager->getMemUsed() - m_pMeshManager->getMemUsed();
long memoryRemainingThisFrameStart = memoryRemainingThisFrame; long memoryRemainingThisFrameStart = memoryRemainingThisFrame;
m_pMeshManager->doStreaming(memoryRemaining, memoryRemainingThisFrame); m_pMeshManager->doStreaming(memoryRemaining, memoryRemainingThisFrame);
m_pTextureManager->doStreaming(memoryRemaining, memoryRemainingThisFrame); m_pTextureManager->doStreaming(memoryRemaining, memoryRemainingThisFrame);
if(memoryRemainingThisFrame == memoryRemainingThisFrameStart && memoryRemainingThisFrame > 0) { if (memoryRemainingThisFrame == memoryRemainingThisFrameStart && memoryRemainingThisFrame > 0) {
m_last_fully_streamed_frame = streaming_start_frame; m_last_fully_streamed_frame = streaming_start_frame;
}
} }
}
} }
void KRContext::receivedMemoryWarning() void KRContext::receivedMemoryWarning()
{ {
m_last_memory_warning_frame = m_current_frame; m_last_memory_warning_frame = m_current_frame;
} }
void
KRContext::createDeviceContexts()
{
// initialize the VkApplicationInfo structure
VkApplicationInfo app_info = {};
app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
app_info.pNext = NULL;
app_info.pApplicationName = "Test"; // TODO - Change Me!
app_info.applicationVersion = 1;
app_info.pEngineName = "Kraken Engine";
app_info.engineVersion = 1;
app_info.apiVersion = VK_API_VERSION_1_0;
// initialize the VkInstanceCreateInfo structure
VkInstanceCreateInfo inst_info = {};
inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
inst_info.pNext = NULL;
inst_info.flags = 0;
inst_info.pApplicationInfo = &app_info;
inst_info.enabledExtensionCount = 0;
inst_info.ppEnabledExtensionNames = NULL;
inst_info.enabledLayerCount = 0;
inst_info.ppEnabledLayerNames = NULL;
VkResult res = vkCreateInstance(&inst_info, NULL, &m_vulkanInstance);
if (res != VK_SUCCESS) {
destroyDeviceContexts();
}
}
void
KRContext::destroyDeviceContexts()
{
if (m_vulkanInstance) != VK_NULL_HANDLE) {
vkDestroyInstance(m_vulkanInstance, NULL);
m_vulkanInstance = VK_NULL_HANDLE;
}
}
void
KRContext::activateStreamerContext()
{
}

281
kraken/KRContext.h
View File

@@ -1,140 +1,141 @@
// //
// KRContext.h // KRContext.h
// KREngine // KREngine
// //
// Created by Kearwood Gilbert on 12-04-12. // Created by Kearwood Gilbert on 12-04-12.
// Copyright (c) 2012 Kearwood Software. All rights reserved. // Copyright (c) 2012 Kearwood Software. All rights reserved.
// //
#ifndef KREngine_KRContext_h #ifndef KREngine_KRContext_h
#define KREngine_KRContext_h #define KREngine_KRContext_h
#include "KREngine-common.h" #include "KREngine-common.h"
#include "KRBundleManager.h" #include "KRBundleManager.h"
#include "KRSceneManager.h" #include "KRSceneManager.h"
#include "KRTextureManager.h" #include "KRTextureManager.h"
#include "KRMaterialManager.h" #include "KRMaterialManager.h"
#include "KRShaderManager.h" #include "KRShaderManager.h"
#include "KRMeshManager.h" #include "KRMeshManager.h"
#include "KRAnimationManager.h" #include "KRAnimationManager.h"
#include "KRAnimationCurveManager.h" #include "KRAnimationCurveManager.h"
#include "KRUnknownManager.h" #include "KRUnknownManager.h"
#include "KRStreamer.h" #include "KRStreamer.h"
class KRAudioManager; class KRAudioManager;
class KRContext { class KRContext {
public: public:
static int KRENGINE_MAX_SHADER_HANDLES; static int KRENGINE_MAX_SHADER_HANDLES;
static int KRENGINE_GPU_MEM_MAX; static int KRENGINE_GPU_MEM_MAX;
static int KRENGINE_GPU_MEM_TARGET; static int KRENGINE_GPU_MEM_TARGET;
static int KRENGINE_MAX_TEXTURE_DIM; static int KRENGINE_MAX_TEXTURE_DIM;
static int KRENGINE_MIN_TEXTURE_DIM; static int KRENGINE_MIN_TEXTURE_DIM;
static int KRENGINE_PRESTREAM_DISTANCE; static int KRENGINE_PRESTREAM_DISTANCE;
static int KRENGINE_SYS_ALLOCATION_GRANULARITY; static int KRENGINE_SYS_ALLOCATION_GRANULARITY;
static int KRENGINE_SYS_PAGE_SIZE; static int KRENGINE_SYS_PAGE_SIZE;
KRContext(); KRContext();
~KRContext(); ~KRContext();
void loadResource(const std::string &file_name, KRDataBlock *data); void loadResource(const std::string &file_name, KRDataBlock *data);
void loadResource(std::string path); void loadResource(std::string path);
KRBundleManager *getBundleManager(); KRBundleManager *getBundleManager();
KRSceneManager *getSceneManager(); KRSceneManager *getSceneManager();
KRTextureManager *getTextureManager(); KRTextureManager *getTextureManager();
KRMaterialManager *getMaterialManager(); KRMaterialManager *getMaterialManager();
KRShaderManager *getShaderManager(); KRShaderManager *getShaderManager();
KRMeshManager *getMeshManager(); KRMeshManager *getMeshManager();
KRAnimationManager *getAnimationManager(); KRAnimationManager *getAnimationManager();
KRAnimationCurveManager *getAnimationCurveManager(); KRAnimationCurveManager *getAnimationCurveManager();
KRAudioManager *getAudioManager(); KRAudioManager *getAudioManager();
KRUnknownManager *getUnknownManager(); KRUnknownManager *getUnknownManager();
KRCamera *createCamera(int width, int height); KRCamera *createCamera(int width, int height);
enum { enum {
KRENGINE_GL_EXT_texture_storage, KRENGINE_GL_EXT_texture_storage,
KRENGINE_NUM_EXTENSIONS KRENGINE_NUM_EXTENSIONS
}; };
static const char * extension_names[KRENGINE_NUM_EXTENSIONS]; static const char * extension_names[KRENGINE_NUM_EXTENSIONS];
static bool extension_available[KRENGINE_NUM_EXTENSIONS]; static bool extension_available[KRENGINE_NUM_EXTENSIONS];
void startFrame(float deltaTime); void startFrame(float deltaTime);
void endFrame(float deltaTime); void endFrame(float deltaTime);
long getCurrentFrame() const; long getCurrentFrame() const;
long getLastFullyStreamedFrame() const; long getLastFullyStreamedFrame() const;
float getAbsoluteTime() const; float getAbsoluteTime() const;
long getAbsoluteTimeMilliseconds(); long getAbsoluteTimeMilliseconds();
std::vector<KRResource *> getResources(); std::vector<KRResource *> getResources();
bool getStreamingEnabled(); bool getStreamingEnabled();
void setStreamingEnabled(bool enable); void setStreamingEnabled(bool enable);
#if TARGET_OS_IPHONE || TARGET_OS_MAC #if TARGET_OS_IPHONE || TARGET_OS_MAC
// XXX This doesn't belong here, and might not actually be needed at all // XXX This doesn't belong here, and might not actually be needed at all
void getMemoryStats(long &free_memory); void getMemoryStats(long &free_memory);
#endif #endif
typedef enum { typedef enum {
LOG_LEVEL_INFORMATION, LOG_LEVEL_INFORMATION,
LOG_LEVEL_WARNING, LOG_LEVEL_WARNING,
LOG_LEVEL_ERROR LOG_LEVEL_ERROR
} log_level; } log_level;
typedef void log_callback(void *userdata, const std::string &message, log_level level); typedef void log_callback(void *userdata, const std::string &message, log_level level);
static void SetLogCallback(log_callback *log_callback, void *user_data); static void SetLogCallback(log_callback *log_callback, void *user_data);
static void Log(log_level level, const std::string message_format, ...); static void Log(log_level level, const std::string message_format, ...);
void doStreaming(); void doStreaming();
void receivedMemoryWarning(); void receivedMemoryWarning();
static void activateStreamerContext(); static void activateStreamerContext();
static void activateRenderContext(); static void activateRenderContext();
#if TARGET_OS_MAC #if TARGET_OS_MAC
static void attachToView(void *view); static void attachToView(void *view);
#endif #endif
private: private:
KRBundleManager *m_pBundleManager; KRBundleManager *m_pBundleManager;
KRSceneManager *m_pSceneManager; KRSceneManager *m_pSceneManager;
KRTextureManager *m_pTextureManager; KRTextureManager *m_pTextureManager;
KRMaterialManager *m_pMaterialManager; KRMaterialManager *m_pMaterialManager;
KRShaderManager *m_pShaderManager; KRShaderManager *m_pShaderManager;
KRMeshManager *m_pMeshManager; KRMeshManager *m_pMeshManager;
KRAnimationManager *m_pAnimationManager; KRAnimationManager *m_pAnimationManager;
KRAnimationCurveManager *m_pAnimationCurveManager; KRAnimationCurveManager *m_pAnimationCurveManager;
KRAudioManager *m_pSoundManager; KRAudioManager *m_pSoundManager;
KRUnknownManager *m_pUnknownManager; KRUnknownManager *m_pUnknownManager;
void detectExtensions(); void detectExtensions();
bool m_bDetectedExtensions; bool m_bDetectedExtensions;
long m_current_frame; // TODO - Does this need to be atomic? long m_current_frame; // TODO - Does this need to be atomic?
long m_last_memory_warning_frame; // TODO - Does this need to be atomic? long m_last_memory_warning_frame; // TODO - Does this need to be atomic?
long m_last_fully_streamed_frame; // TODO - Does this need to be atomic? long m_last_fully_streamed_frame; // TODO - Does this need to be atomic?
float m_absolute_time; float m_absolute_time;
#ifdef __APPLE__ #ifdef __APPLE__
mach_timebase_info_data_t m_timebase_info; mach_timebase_info_data_t m_timebase_info;
#endif #endif
std::atomic<bool> m_streamingEnabled; std::atomic<bool> m_streamingEnabled;
static log_callback *s_log_callback; static log_callback *s_log_callback;
static void *s_log_callback_user_data; static void *s_log_callback_user_data;
KRStreamer m_streamer; KRStreamer m_streamer;
VkInstance m_vulkanInstance;
static void createDeviceContexts();
void destroyDeviceContexts(); void createDeviceContexts();
}; void destroyDeviceContexts();
};
#endif
#endif

2
kraken/KREngine-common.h
View File

@@ -103,6 +103,8 @@ using std::unordered_map;
using std::unordered_multimap; using std::unordered_multimap;
using std::hash; using std::hash;
#include <vulkan/vulkan.h>
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
#include <mutex> #include <mutex>

94
kraken/KRResource.h
View File

@@ -1,47 +1,47 @@
// //
// KRResource.h // KRResource.h
// KREngine // KREngine
// //
// Created by Kearwood Gilbert on 12-03-22. // Created by Kearwood Gilbert on 12-03-22.
// Copyright (c) 2012 Kearwood Software. All rights reserved. // Copyright (c) 2012 Kearwood Software. All rights reserved.
// //
#include "KREngine-common.h" #include "KREngine-common.h"
#include "KRContextObject.h" #include "KRContextObject.h"
#include "KRDataBlock.h" #include "KRDataBlock.h"
#ifndef KRRESOURCE_H #ifndef KRRESOURCE_H
#define KRRESOURCE_H #define KRRESOURCE_H
class KRResource : public KRContextObject class KRResource : public KRContextObject
{ {
public: public:
std::string getName(); std::string getName();
virtual std::string getExtension() = 0; virtual std::string getExtension() = 0;
virtual bool save(const std::string& path); virtual bool save(const std::string& path);
virtual bool save(KRDataBlock &data) = 0; virtual bool save(KRDataBlock &data) = 0;
static std::string GetFileExtension(const std::string& name); static std::string GetFileExtension(const std::string& name);
static std::string GetFileBase(const std::string& name); static std::string GetFileBase(const std::string& name);
static std::string GetFilePath(const std::string& name); static std::string GetFilePath(const std::string& name);
virtual ~KRResource(); virtual ~KRResource();
static std::vector<KRResource *> LoadObj(KRContext &context, const std::string& path); static std::vector<KRResource *> LoadObj(KRContext &context, const std::string& path);
#if !TARGET_OS_IPHONE #if !TARGET_OS_IPHONE
static void LoadFbx(KRContext &context, const std::string& path); // static void LoadFbx(KRContext &context, const std::string& path); TODO, FINDME, HACK! - Uncomment
static std::vector<KRResource *> LoadBlenderScene(KRContext &context, const std::string& path); static std::vector<KRResource *> LoadBlenderScene(KRContext &context, const std::string& path);
#endif #endif
protected: protected:
KRResource(KRContext &context, std::string name); KRResource(KRContext &context, std::string name);
private: private:
std::string m_name; std::string m_name;
}; };
#endif #endif