From e485261e53f0696d5fa176f963f9626da4677c73 Mon Sep 17 00:00:00 2001 From: Kearwood Gilbert Date: Sat, 5 Aug 2023 16:37:16 -0700 Subject: [PATCH] Refactor - rename KRDataBlock to mimir::Block --- kraken/CMakeLists.txt | 2 +- kraken/KRAnimation.cpp | 6 ++- kraken/KRAnimation.h | 6 +-- kraken/KRAnimationCurve.cpp | 12 +++--- kraken/KRAnimationCurve.h | 10 ++--- kraken/KRAnimationCurveManager.cpp | 4 +- kraken/KRAnimationCurveManager.h | 6 +-- kraken/KRAnimationManager.cpp | 4 +- kraken/KRAnimationManager.h | 6 +-- kraken/KRAudioBuffer.h | 4 +- kraken/KRAudioManager.cpp | 18 ++++---- kraken/KRAudioManager.h | 12 +++--- kraken/KRAudioSample.cpp | 10 +++-- kraken/KRAudioSample.h | 8 ++-- kraken/KRBundle.cpp | 16 ++++--- kraken/KRBundle.h | 10 ++--- kraken/KRBundleManager.cpp | 4 +- kraken/KRBundleManager.h | 6 +-- kraken/KRCamera.cpp | 4 +- kraken/KRCamera.h | 2 +- kraken/KRContext.cpp | 8 ++-- kraken/KRContext.h | 2 +- kraken/KRDevice.cpp | 8 ++-- kraken/KRDevice.h | 10 +++-- kraken/KRMaterial.cpp | 4 +- kraken/KRMaterial.h | 2 +- kraken/KRMaterialManager.cpp | 6 ++- kraken/KRMaterialManager.h | 4 +- kraken/KRMesh.cpp | 18 ++++---- kraken/KRMesh.h | 16 +++---- kraken/KRMeshManager.cpp | 12 +++--- kraken/KRMeshManager.h | 24 +++++------ kraken/KRPipelineManager.h | 2 +- kraken/KRResource+blend.cpp | 4 +- kraken/KRResource+obj.cpp | 4 +- kraken/KRResource.cpp | 8 ++-- kraken/KRResource.h | 4 +- kraken/KRResourceManager.h | 4 +- kraken/KRSamplerManager.h | 2 +- kraken/KRScene.cpp | 6 ++- kraken/KRScene.h | 4 +- kraken/KRSceneManager.cpp | 6 ++- kraken/KRSceneManager.h | 6 +-- kraken/KRShader.cpp | 10 +++-- kraken/KRShader.h | 10 ++--- kraken/KRShaderManager.cpp | 12 +++--- kraken/KRShaderManager.h | 6 +-- kraken/KRSource.cpp | 10 +++-- kraken/KRSource.h | 10 ++--- kraken/KRSourceManager.cpp | 6 ++- kraken/KRSourceManager.h | 6 +-- kraken/KRTexture.cpp | 2 +- kraken/KRTexture.h | 4 +- kraken/KRTexture2D.cpp | 6 ++- kraken/KRTexture2D.h | 8 ++-- kraken/KRTextureAnimated.cpp | 2 +- kraken/KRTextureAnimated.h | 4 +- kraken/KRTextureCube.cpp | 4 +- kraken/KRTextureCube.h | 2 +- kraken/KRTextureKTX.cpp | 18 ++++---- kraken/KRTextureKTX.h | 8 ++-- kraken/KRTextureKTX2.cpp | 4 +- kraken/KRTextureKTX2.h | 2 +- kraken/KRTextureManager.cpp | 4 +- kraken/KRTextureManager.h | 6 +-- kraken/KRTexturePVR.cpp | 16 ++++--- kraken/KRTexturePVR.h | 4 +- kraken/KRTextureTGA.cpp | 8 ++-- kraken/KRTextureTGA.h | 4 +- kraken/KRUnknown.cpp | 10 +++-- kraken/KRUnknown.h | 10 ++--- kraken/KRUnknownManager.cpp | 6 ++- kraken/KRUnknownManager.h | 6 +-- kraken/{KRDataBlock.cpp => block.cpp} | 61 +++++++++++++++------------ kraken/{KRDataBlock.h => block.h} | 24 ++++++----- 75 files changed, 339 insertions(+), 268 deletions(-) rename kraken/{KRDataBlock.cpp => block.cpp} (93%) rename kraken/{KRDataBlock.h => block.h} (91%) diff --git a/kraken/CMakeLists.txt b/kraken/CMakeLists.txt index e294d90..389e18e 100644 --- a/kraken/CMakeLists.txt +++ b/kraken/CMakeLists.txt @@ -3,6 +3,7 @@ add_subdirectory(public) set(KRAKEN_PUBLIC_HEADERS "${KRAKEN_PUBLIC_HEADERS}" PARENT_SCOPE) # Private Implementation +add_sources(block.cpp) add_sources(kraken.cpp) add_sources(KRAmbientZone.cpp) add_sources(KRAnimation.cpp) @@ -41,7 +42,6 @@ IF(APPLE) ENDIF() ENDIF (APPLE) add_sources(KRContextObject.cpp) -add_sources(KRDataBlock.cpp) add_sources(KRDirectionalLight.cpp) IF(APPLE) add_sources(KRDSP_vDSP.cpp) diff --git a/kraken/KRAnimation.cpp b/kraken/KRAnimation.cpp index cf7b036..4e9d7f8 100755 --- a/kraken/KRAnimation.cpp +++ b/kraken/KRAnimation.cpp @@ -35,6 +35,8 @@ #include "KRAnimationCurve.h" #include "KREngine-common.h" +using namespace mimir; + KRAnimation::KRAnimation(KRContext& context, std::string name) : KRResource(context, name) { m_auto_play = false; @@ -61,7 +63,7 @@ void KRAnimation::addLayer(KRAnimationLayer* layer) m_layers[layer->getName()] = layer; } -bool KRAnimation::save(KRDataBlock& data) +bool KRAnimation::save(Block& data) { tinyxml2::XMLDocument doc; tinyxml2::XMLElement* animation_node = doc.NewElement("animation"); @@ -82,7 +84,7 @@ bool KRAnimation::save(KRDataBlock& data) return true; } -KRAnimation* KRAnimation::Load(KRContext& context, const std::string& name, KRDataBlock* data) +KRAnimation* KRAnimation::Load(KRContext& context, const std::string& name, Block* data) { std::string xml_string = data->getString(); diff --git a/kraken/KRAnimation.h b/kraken/KRAnimation.h index a606c02..ff04e73 100755 --- a/kraken/KRAnimation.h +++ b/kraken/KRAnimation.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" #include "KRAnimationLayer.h" @@ -46,9 +46,9 @@ public: virtual ~KRAnimation(); virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - static KRAnimation* Load(KRContext& context, const std::string& name, KRDataBlock* data); + static KRAnimation* Load(KRContext& context, const std::string& name, mimir::Block* data); void addLayer(KRAnimationLayer* layer); unordered_map& getLayers(); diff --git a/kraken/KRAnimationCurve.cpp b/kraken/KRAnimationCurve.cpp index a1c72bb..bb02a23 100755 --- a/kraken/KRAnimationCurve.cpp +++ b/kraken/KRAnimationCurve.cpp @@ -31,11 +31,13 @@ #include "KRContext.h" #include "KRAnimationCurve.h" -#include "KRDataBlock.h" +#include "block.h" + +using namespace mimir; KRAnimationCurve::KRAnimationCurve(KRContext& context, const std::string& name) : KRResource(context, name) { - m_pData = new KRDataBlock(); + m_pData = new Block(); m_pData->expand(sizeof(animation_curve_header)); m_pData->lock(); animation_curve_header* header = (animation_curve_header*)m_pData->getStart(); @@ -51,7 +53,7 @@ KRAnimationCurve::~KRAnimationCurve() m_pData->unload(); delete m_pData; } -bool KRAnimationCurve::load(KRDataBlock* data) +bool KRAnimationCurve::load(Block* data) { m_pData->unload(); delete m_pData; @@ -69,13 +71,13 @@ bool KRAnimationCurve::save(const std::string& path) return m_pData->save(path); } -bool KRAnimationCurve::save(KRDataBlock& data) +bool KRAnimationCurve::save(Block& data) { data.append(*m_pData); return true; } -KRAnimationCurve* KRAnimationCurve::Load(KRContext& context, const std::string& name, KRDataBlock* data) +KRAnimationCurve* KRAnimationCurve::Load(KRContext& context, const std::string& name, Block* data) { KRAnimationCurve* new_animation_curve = new KRAnimationCurve(context, name); if (new_animation_curve->load(data)) { diff --git a/kraken/KRAnimationCurve.h b/kraken/KRAnimationCurve.h index 27fc57c..f25c882 100755 --- a/kraken/KRAnimationCurve.h +++ b/kraken/KRAnimationCurve.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" class KRAnimationCurve : public KRResource @@ -45,8 +45,8 @@ public: virtual std::string getExtension(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); - virtual bool load(KRDataBlock* data); + virtual bool save(mimir::Block& data); + virtual bool load(mimir::Block* data); float getFrameRate(); void setFrameRate(float frame_rate); @@ -59,7 +59,7 @@ public: void setValue(int frame_number, float value); - static KRAnimationCurve* Load(KRContext& context, const std::string& name, KRDataBlock* data); + static KRAnimationCurve* Load(KRContext& context, const std::string& name, mimir::Block* data); bool valueChanges(float start_time, float duration); bool valueChanges(int start_frame, int frame_count); @@ -71,7 +71,7 @@ public: void _unlockData(); private: - KRDataBlock* m_pData; + mimir::Block* m_pData; typedef struct { diff --git a/kraken/KRAnimationCurveManager.cpp b/kraken/KRAnimationCurveManager.cpp index 142d632..9342956 100755 --- a/kraken/KRAnimationCurveManager.cpp +++ b/kraken/KRAnimationCurveManager.cpp @@ -50,7 +50,7 @@ void KRAnimationCurveManager::deleteAnimationCurve(KRAnimationCurve* curve) delete curve; } -KRResource* KRAnimationCurveManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRAnimationCurveManager::loadResource(const std::string& name, const std::string& extension, mimir::Block* data) { if (extension.compare("kranimationcurve") == 0) { return loadAnimationCurve(name, data); @@ -65,7 +65,7 @@ KRResource* KRAnimationCurveManager::getResource(const std::string& name, const return nullptr; } -KRAnimationCurve* KRAnimationCurveManager::loadAnimationCurve(const std::string& name, KRDataBlock* data) +KRAnimationCurve* KRAnimationCurveManager::loadAnimationCurve(const std::string& name, mimir::Block* data) { KRAnimationCurve* pAnimationCurve = KRAnimationCurve::Load(*m_pContext, name, data); if (pAnimationCurve) { diff --git a/kraken/KRAnimationCurveManager.h b/kraken/KRAnimationCurveManager.h index 961ccd5..4417664 100755 --- a/kraken/KRAnimationCurveManager.h +++ b/kraken/KRAnimationCurveManager.h @@ -37,7 +37,7 @@ #include "KRAnimationCurve.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" using std::map; @@ -47,10 +47,10 @@ public: KRAnimationCurveManager(KRContext& context); virtual ~KRAnimationCurveManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; - KRAnimationCurve* loadAnimationCurve(const std::string& name, KRDataBlock* data); + KRAnimationCurve* loadAnimationCurve(const std::string& name, mimir::Block* data); KRAnimationCurve* getAnimationCurve(const std::string& name); void addAnimationCurve(KRAnimationCurve* new_animation_curve); unordered_map& getAnimationCurves(); diff --git a/kraken/KRAnimationManager.cpp b/kraken/KRAnimationManager.cpp index 8c3487a..aff779f 100755 --- a/kraken/KRAnimationManager.cpp +++ b/kraken/KRAnimationManager.cpp @@ -82,7 +82,7 @@ void KRAnimationManager::endFrame(float deltaTime) } -KRResource* KRAnimationManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRAnimationManager::loadResource(const std::string& name, const std::string& extension, mimir::Block* data) { if (extension.compare("kranimation") == 0) { return loadAnimation(name.c_str(), data); @@ -97,7 +97,7 @@ KRResource* KRAnimationManager::getResource(const std::string& name, const std:: return nullptr; } -KRAnimation* KRAnimationManager::loadAnimation(const char* szName, KRDataBlock* data) +KRAnimation* KRAnimationManager::loadAnimation(const char* szName, mimir::Block* data) { KRAnimation* pAnimation = KRAnimation::Load(*m_pContext, szName, data); addAnimation(pAnimation); diff --git a/kraken/KRAnimationManager.h b/kraken/KRAnimationManager.h index 212a010..c5ae75c 100755 --- a/kraken/KRAnimationManager.h +++ b/kraken/KRAnimationManager.h @@ -37,7 +37,7 @@ #include "KRAnimation.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" @@ -47,10 +47,10 @@ public: KRAnimationManager(KRContext& context); virtual ~KRAnimationManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; - KRAnimation* loadAnimation(const char* szName, KRDataBlock* data); + KRAnimation* loadAnimation(const char* szName, mimir::Block* data); KRAnimation* getAnimation(const char* szName); void addAnimation(KRAnimation* new_animation); unordered_map& getAnimations(); diff --git a/kraken/KRAudioBuffer.h b/kraken/KRAudioBuffer.h index c26b2b0..ee6c173 100755 --- a/kraken/KRAudioBuffer.h +++ b/kraken/KRAudioBuffer.h @@ -32,7 +32,7 @@ #pragma once #include "KREngine-common.h" -#include "KRDataBlock.h" +#include "block.h" class KRAudioManager; class KRAudioSample; @@ -56,7 +56,7 @@ private: int m_frameCount; int m_frameRate; int m_bytesPerFrame; - KRDataBlock* m_pData; + mimir::Block* m_pData; KRAudioSample* m_audioSample; }; diff --git a/kraken/KRAudioManager.cpp b/kraken/KRAudioManager.cpp index 4452e38..f70f269 100755 --- a/kraken/KRAudioManager.cpp +++ b/kraken/KRAudioManager.cpp @@ -32,12 +32,14 @@ #include "KRAudioManager.h" #include "KRAudioSample.h" #include "KREngine-common.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRAudioBuffer.h" #include "KRContext.h" #include "KRCollider.h" #include "KRDSP.h" +using namespace mimir; + KRAudioManager::KRAudioManager(KRContext& context) : KRResourceManager(context) , m_initialized(false) @@ -1199,7 +1201,7 @@ void KRAudioManager::destroy() cleanupAudio(); - for (std::vector::iterator itr = m_bufferPoolIdle.begin(); itr != m_bufferPoolIdle.end(); itr++) { + for (std::vector::iterator itr = m_bufferPoolIdle.begin(); itr != m_bufferPoolIdle.end(); itr++) { delete* itr; } m_bufferPoolIdle.clear(); @@ -1257,7 +1259,7 @@ void KRAudioManager::add(KRAudioSample* sound) } } -KRResource* KRAudioManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRAudioManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("mtl") == 0 || extension.compare("mp3") == 0 || @@ -1276,7 +1278,7 @@ KRResource* KRAudioManager::getResource(const std::string& name, const std::stri return nullptr; } -KRAudioSample* KRAudioManager::load(const std::string& name, const std::string& extension, KRDataBlock* data) +KRAudioSample* KRAudioManager::load(const std::string& name, const std::string& extension, Block* data) { KRAudioSample* Sound = new KRAudioSample(getContext(), name, extension, data); if (Sound) add(Sound); @@ -1290,23 +1292,23 @@ KRAudioSample* KRAudioManager::get(const std::string& name) return m_sounds[lower_name]; } -KRDataBlock* KRAudioManager::getBufferData(int size) +Block* KRAudioManager::getBufferData(int size) { - KRDataBlock* data; + Block* data; // Note: We only store and recycle buffers with a size of CIRCA_AUDIO_MAX_BUFFER_SIZE if (size == KRENGINE_AUDIO_MAX_BUFFER_SIZE && m_bufferPoolIdle.size() > 0) { // Recycle a buffer from the pool data = m_bufferPoolIdle.back(); m_bufferPoolIdle.pop_back(); } else { - data = new KRDataBlock(); + data = new Block(); data->expand(size); } data->lock(); return data; } -void KRAudioManager::recycleBufferData(KRDataBlock* data) +void KRAudioManager::recycleBufferData(Block* data) { if (data != NULL) { data->unlock(); diff --git a/kraken/KRAudioManager.h b/kraken/KRAudioManager.h index cb0ecd6..ad47dce 100755 --- a/kraken/KRAudioManager.h +++ b/kraken/KRAudioManager.h @@ -36,7 +36,7 @@ #include "KRResourceManager.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRAudioSource.h" #include "KRDSP.h" @@ -100,14 +100,14 @@ public: virtual ~KRAudioManager(); void destroy(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; unordered_map& getSounds(); void add(KRAudioSample* Sound); - KRAudioSample* load(const std::string& name, const std::string& extension, KRDataBlock* data); + KRAudioSample* load(const std::string& name, const std::string& extension, mimir::Block* data); KRAudioSample* get(const std::string& name); // Listener position and orientation @@ -132,8 +132,8 @@ public: void makeCurrentContext(); - KRDataBlock* getBufferData(int size); - void recycleBufferData(KRDataBlock* data); + mimir::Block* getBufferData(int size); + void recycleBufferData(mimir::Block* data); void activateAudioSource(KRAudioSource* audioSource); void deactivateAudioSource(KRAudioSource* audioSource); @@ -180,7 +180,7 @@ private: unordered_map m_sounds; - std::vector m_bufferPoolIdle; + std::vector m_bufferPoolIdle; std::vector m_bufferCache; diff --git a/kraken/KRAudioSample.cpp b/kraken/KRAudioSample.cpp index 51a44f5..4ea0faf 100755 --- a/kraken/KRAudioSample.cpp +++ b/kraken/KRAudioSample.cpp @@ -31,14 +31,16 @@ #include "KRAudioSample.h" #include "KRAudioManager.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRAudioBuffer.h" #include "KRContext.h" #include "KRDSP.h" +using namespace mimir; + KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string extension) : KRResource(context, name) { - m_pData = new KRDataBlock(); + m_pData = new Block(); m_extension = extension; #ifdef __APPLE__ @@ -54,7 +56,7 @@ KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string e m_last_frame_used = 0; } -KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string extension, KRDataBlock* data) : KRResource(context, name) +KRAudioSample::KRAudioSample(KRContext& context, std::string name, std::string extension, Block* data) : KRResource(context, name) { m_pData = data; m_extension = extension; @@ -329,7 +331,7 @@ std::string KRAudioSample::getExtension() return m_extension; } -bool KRAudioSample::save(KRDataBlock& data) +bool KRAudioSample::save(Block& data) { data.append(*m_pData); return true; diff --git a/kraken/KRAudioSample.h b/kraken/KRAudioSample.h index 001ae22..d4f3941 100755 --- a/kraken/KRAudioSample.h +++ b/kraken/KRAudioSample.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" class KRAudioBuffer; @@ -43,12 +43,12 @@ class KRAudioSample : public KRResource public: KRAudioSample(KRContext& context, std::string name, std::string extension); - KRAudioSample(KRContext& context, std::string name, std::string extension, KRDataBlock* data); + KRAudioSample(KRContext& context, std::string name, std::string extension, mimir::Block* data); virtual ~KRAudioSample(); virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); float getDuration(); KRAudioBuffer* getBuffer(int index); @@ -66,7 +66,7 @@ private: __int64_t m_last_frame_used; std::string m_extension; - KRDataBlock* m_pData; + mimir::Block* m_pData; #ifdef __APPLE__ // Apple Audio Toolbox diff --git a/kraken/KRBundle.cpp b/kraken/KRBundle.cpp index 725e9d5..d0f45a4 100755 --- a/kraken/KRBundle.cpp +++ b/kraken/KRBundle.cpp @@ -33,6 +33,8 @@ #include "KRContext.h" #include "KREngine-common.h" +using namespace mimir; + const int KRENGINE_KRBUNDLE_HEADER_SIZE = 512; typedef struct _tar_header @@ -49,7 +51,7 @@ typedef struct _tar_header } tar_header_type; -KRBundle::KRBundle(KRContext& context, std::string name, KRDataBlock* pData) : KRResource(context, name) +KRBundle::KRBundle(KRContext& context, std::string name, Block* pData) : KRResource(context, name) { m_pData = pData; @@ -61,7 +63,7 @@ KRBundle::KRBundle(KRContext& context, std::string name, KRDataBlock* pData) : K file_pos += 512; // Skip past the header to the file contents if (file_header.file_name[0] != '\0' && file_header.file_name[0] != '.') { // We ignore the last two records in the tar file, which are zero'ed out tar_header structures - KRDataBlock* pFileData = pData->getSubBlock((int)file_pos, (int)file_size); + Block* pFileData = pData->getSubBlock((int)file_pos, (int)file_size); context.loadResource(file_header.file_name, pFileData); } file_pos += RoundUpSize(file_size); @@ -71,7 +73,7 @@ KRBundle::KRBundle(KRContext& context, std::string name, KRDataBlock* pData) : K KRBundle::KRBundle(KRContext& context, std::string name) : KRResource(context, name) { // Create an empty krbundle (tar) file, initialized with two zero-ed out file headers, which terminate it. - m_pData = new KRDataBlock(); + m_pData = new Block(); m_pData->expand(KRENGINE_KRBUNDLE_HEADER_SIZE * 2); m_pData->lock(); memset(m_pData->getStart(), 0, m_pData->getSize()); @@ -106,7 +108,7 @@ bool KRBundle::save(const std::string& path) return m_pData->save(path); } -bool KRBundle::save(KRDataBlock& data) +bool KRBundle::save(Block& data) { if (m_pData->getSize() > KRENGINE_KRBUNDLE_HEADER_SIZE * 2) { // Only output krbundles that contain files @@ -115,10 +117,10 @@ bool KRBundle::save(KRDataBlock& data) return true; } -KRDataBlock* KRBundle::append(KRResource& resource) +Block* KRBundle::append(KRResource& resource) { // Serialize resource to binary representation - KRDataBlock resource_data; + Block resource_data; resource.save(resource_data); std::string file_name = resource.getName() + "." + resource.getExtension(); @@ -165,6 +167,6 @@ KRDataBlock* KRBundle::append(KRResource& resource) m_pData->unlock(); - KRDataBlock* pFileData = m_pData->getSubBlock((int)resource_data_start, (int)resource_data.getSize()); + Block* pFileData = m_pData->getSubBlock((int)resource_data_start, (int)resource_data.getSize()); return pFileData; } diff --git a/kraken/KRBundle.h b/kraken/KRBundle.h index 924b5d5..5adc54c 100755 --- a/kraken/KRBundle.h +++ b/kraken/KRBundle.h @@ -32,21 +32,21 @@ #include "KREngine-common.h" #include "KRResource.h" -#include "KRDataBlock.h" +#include "block.h" class KRBundle : public KRResource { public: - KRBundle(KRContext& context, std::string name, KRDataBlock* pData); + KRBundle(KRContext& context, std::string name, mimir::Block* pData); KRBundle(KRContext& context, std::string name); virtual ~KRBundle(); virtual std::string getExtension(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - KRDataBlock* append(KRResource& resource); + mimir::Block* append(KRResource& resource); private: - KRDataBlock* m_pData; + mimir::Block* m_pData; static size_t RoundUpSize(size_t s); }; diff --git a/kraken/KRBundleManager.cpp b/kraken/KRBundleManager.cpp index 00c4145..277d2c9 100755 --- a/kraken/KRBundleManager.cpp +++ b/kraken/KRBundleManager.cpp @@ -46,7 +46,7 @@ KRBundleManager::~KRBundleManager() m_bundles.clear(); } -KRResource* KRBundleManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRBundleManager::loadResource(const std::string& name, const std::string& extension, mimir::Block* data) { if (extension.compare("krbundle") == 0) { return loadBundle(name.c_str(), data); @@ -61,7 +61,7 @@ KRResource* KRBundleManager::getResource(const std::string& name, const std::str return nullptr; } -KRBundle* KRBundleManager::loadBundle(const char* szName, KRDataBlock* pData) +KRBundle* KRBundleManager::loadBundle(const char* szName, mimir::Block* pData) { KRBundle* pBundle = new KRBundle(*m_pContext, szName, pData); m_bundles[szName] = pBundle; diff --git a/kraken/KRBundleManager.h b/kraken/KRBundleManager.h index 5450a71..5c8054d 100755 --- a/kraken/KRBundleManager.h +++ b/kraken/KRBundleManager.h @@ -35,7 +35,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRContext; class KRBundle; @@ -46,10 +46,10 @@ public: KRBundleManager(KRContext& context); ~KRBundleManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; - KRBundle* loadBundle(const char* szName, KRDataBlock* pData); + KRBundle* loadBundle(const char* szName, mimir::Block* pData); KRBundle* getBundle(const char* szName); KRBundle* createBundle(const char* szName); diff --git a/kraken/KRCamera.cpp b/kraken/KRCamera.cpp index 49966b7..be8df58 100755 --- a/kraken/KRCamera.cpp +++ b/kraken/KRCamera.cpp @@ -35,6 +35,8 @@ #include "KRRenderPass.h" #include "KRPipeline.h" +using namespace mimir; + /* static */ void KRCamera::InitNodeInfo(KrNodeInfo* nodeInfo) { @@ -778,7 +780,7 @@ void KRCamera::renderPost(VkCommandBuffer& commandBuffer, KRSurface& surface) } else { if (m_debug_text_vertices.getSize() > 0) { - m_debug_text_vertices = KRDataBlock(); + m_debug_text_vertices = Block(); } } } diff --git a/kraken/KRCamera.h b/kraken/KRCamera.h index e3252da..9460841 100755 --- a/kraken/KRCamera.h +++ b/kraken/KRCamera.h @@ -111,7 +111,7 @@ private: float v; } DebugTextVertexData; - KRDataBlock m_debug_text_vertices; + mimir::Block m_debug_text_vertices; KRMeshManager::KRVBOData m_debug_text_vbo_data; // std::string getDebugText(); diff --git a/kraken/KRContext.cpp b/kraken/KRContext.cpp index 8acd6ff..74c6197 100755 --- a/kraken/KRContext.cpp +++ b/kraken/KRContext.cpp @@ -48,6 +48,8 @@ #include #endif +using namespace mimir; + // TODO - Make values dynamic after Vulkan conversion: int KRContext::KRENGINE_MAX_PIPELINE_HANDLES = 4000; int KRContext::KRENGINE_GPU_MEM_MAX = 256000000; @@ -325,7 +327,7 @@ std::vector KRContext::getResources() return resources; } -KRResource* KRContext::loadResource(const std::string& file_name, KRDataBlock* data) +KRResource* KRContext::loadResource(const std::string& file_name, Block* data) { std::string name = KRResource::GetFileBase(file_name); std::string extension = KRResource::GetFileExtension(file_name); @@ -394,7 +396,7 @@ KrResult KRContext::loadResource(const KrLoadResourceInfo* loadResourceInfo) if (loadResourceInfo->resourceHandle < 0 || loadResourceInfo->resourceHandle >= m_resourceMapSize) { return KR_ERROR_OUT_OF_BOUNDS; } - KRDataBlock* data = new KRDataBlock(); + Block* data = new Block(); if (!data->load(loadResourceInfo->pResourcePath)) { KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KRContext::loadResource - Failed to open file: %s", loadResourceInfo->pResourcePath); delete data; @@ -457,7 +459,7 @@ KrResult KRContext::unmapResource(const KrUnmapResourceInfo* unmapResourceInfo) KrResult KRContext::getResourceData(const KrGetResourceDataInfo* getResourceDataInfo, KrGetResourceDataCallback callback) { // TODO - This will be asynchronous... The function will always succeed, but the asynchronous result could report a failure - KRDataBlock data; + Block data; KrGetResourceDataResult result = {}; KRResource* resource = nullptr; diff --git a/kraken/KRContext.h b/kraken/KRContext.h index abe5753..7756c3e 100755 --- a/kraken/KRContext.h +++ b/kraken/KRContext.h @@ -122,7 +122,7 @@ public: } // -=-=-=- End: Helper functions for Public API Entry Points - KRResource* loadResource(const std::string& file_name, KRDataBlock* data); + KRResource* loadResource(const std::string& file_name, mimir::Block* data); KRBundleManager* getBundleManager(); diff --git a/kraken/KRDevice.cpp b/kraken/KRDevice.cpp index b24346a..28cc8cb 100644 --- a/kraken/KRDevice.cpp +++ b/kraken/KRDevice.cpp @@ -32,6 +32,8 @@ #include "KRDevice.h" #include "KRDeviceManager.h" +using namespace mimir; + KRDevice::KRDevice(KRContext& context, const VkPhysicalDevice& device) : KRContextObject(context) , m_device(device) @@ -713,14 +715,14 @@ void KRDevice::streamStart() } } -void KRDevice::streamUpload(KRDataBlock& data, VkBuffer destination) +void KRDevice::streamUpload(Block& data, VkBuffer destination) { data.lock(); streamUpload(data.getStart(), data.getSize(), destination); data.unlock(); } -void KRDevice::graphicsUpload(VkCommandBuffer& commandBuffer, KRDataBlock& data, VkBuffer destination) +void KRDevice::graphicsUpload(VkCommandBuffer& commandBuffer, Block& data, VkBuffer destination) { data.lock(); graphicsUpload(commandBuffer, data.getStart(), data.getSize(), destination); @@ -779,7 +781,7 @@ void KRDevice::streamUpload(void* data, size_t size, Vector3i dimensions, VkImag streamUploadImpl(size, dimensions, destination, 0, 1); } -void KRDevice::streamUpload(KRDataBlock& data, VkImage destination, size_t offset, size_t size, Vector3i dimensions, uint32_t baseMipLevel, uint32_t levelCount) +void KRDevice::streamUpload(Block& data, VkImage destination, size_t offset, size_t size, Vector3i dimensions, uint32_t baseMipLevel, uint32_t levelCount) { checkFlushStreamBuffer(size); diff --git a/kraken/KRDevice.h b/kraken/KRDevice.h index ca658f2..9096bd6 100644 --- a/kraken/KRDevice.h +++ b/kraken/KRDevice.h @@ -34,7 +34,9 @@ #pragma once -class KRDataBlock; +namespace mimir { +class Block; +} class KRDevice : public KRContextObject { @@ -69,13 +71,13 @@ public: KrResult selectPresentMode(VkSurfaceKHR& surface, VkPresentModeKHR& selectedPresentMode) const; void streamStart(); - void streamUpload(KRDataBlock& data, VkBuffer destination); - void streamUpload(KRDataBlock& data, VkImage destination, size_t offset, size_t size, Vector3i dimensions, uint32_t baseMipLevel, uint32_t levelCount); + void streamUpload(mimir::Block& data, VkBuffer destination); + void streamUpload(mimir::Block& data, VkImage destination, size_t offset, size_t size, Vector3i dimensions, uint32_t baseMipLevel, uint32_t levelCount); void streamUpload(void* data, size_t size, VkBuffer destination); void streamUpload(void* data, size_t size, Vector3i dimensions, VkImage destination); void streamEnd(); - void graphicsUpload(VkCommandBuffer& commandBuffer, KRDataBlock& data, VkBuffer destination); + void graphicsUpload(VkCommandBuffer& commandBuffer, mimir::Block& data, VkBuffer destination); void graphicsUpload(VkCommandBuffer& commandBuffer, void* data, size_t size, VkBuffer destination); void createDescriptorSets(const std::vector& layouts, std::vector& descriptorSets); diff --git a/kraken/KRMaterial.cpp b/kraken/KRMaterial.cpp index fc2eb9d..37ccdf0 100755 --- a/kraken/KRMaterial.cpp +++ b/kraken/KRMaterial.cpp @@ -36,6 +36,8 @@ #include "KRContext.h" +using namespace mimir; + KRMaterial::KRMaterial(KRContext& context, const char* szName) : KRResource(context, szName) { m_name = szName; @@ -83,7 +85,7 @@ bool KRMaterial::needsVertexTangents() return m_normalMap.size() > 0; } -bool KRMaterial::save(KRDataBlock& data) +bool KRMaterial::save(Block& data) { std::stringstream stream; stream.precision(std::numeric_limits::digits10); diff --git a/kraken/KRMaterial.h b/kraken/KRMaterial.h index b9c6ce5..afbe14c 100755 --- a/kraken/KRMaterial.h +++ b/kraken/KRMaterial.h @@ -65,7 +65,7 @@ public: virtual ~KRMaterial(); virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); void setAmbientMap(std::string texture_name, Vector2 texture_scale, Vector2 texture_offset); diff --git a/kraken/KRMaterialManager.cpp b/kraken/KRMaterialManager.cpp index b75f781..d90fdd3 100755 --- a/kraken/KRMaterialManager.cpp +++ b/kraken/KRMaterialManager.cpp @@ -32,6 +32,8 @@ #include "KREngine-common.h" #include "KRMaterialManager.h" +using namespace mimir; + KRMaterialManager::KRMaterialManager(KRContext& context, KRTextureManager* pTextureManager, KRPipelineManager* pPipelineManager) : KRResourceManager(context) { @@ -44,7 +46,7 @@ KRMaterialManager::~KRMaterialManager() } -KRResource* KRMaterialManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRMaterialManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("mtl") == 0) { return load(name.c_str(), data); @@ -95,7 +97,7 @@ void KRMaterialManager::add(KRMaterial* new_material) m_materials[lowerName] = new_material; } -KRMaterial* KRMaterialManager::load(const char* szName, KRDataBlock* data) +KRMaterial* KRMaterialManager::load(const char* szName, Block* data) { KRMaterial* pMaterial = NULL; char szSymbol[16][256]; diff --git a/kraken/KRMaterialManager.h b/kraken/KRMaterialManager.h index f4af7b6..93e6355 100755 --- a/kraken/KRMaterialManager.h +++ b/kraken/KRMaterialManager.h @@ -49,10 +49,10 @@ public: KRMaterialManager(KRContext& context, KRTextureManager* pTextureManager, KRPipelineManager* pPipelineManager); virtual ~KRMaterialManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; - KRMaterial* load(const char* szName, KRDataBlock* data); + KRMaterial* load(const char* szName, mimir::Block* data); void add(KRMaterial* new_material); KRMaterial* getMaterial(const std::string& name); diff --git a/kraken/KRMesh.cpp b/kraken/KRMesh.cpp index 76d88ed..b171dce 100755 --- a/kraken/KRMesh.cpp +++ b/kraken/KRMesh.cpp @@ -39,6 +39,8 @@ #include "KRContext.h" #include "../3rdparty/forsyth/forsyth.h" +using namespace mimir; + KRMesh::KRMesh(KRContext& context, std::string name) : KRResource(context, name) { setName(name); @@ -50,7 +52,7 @@ KRMesh::KRMesh(KRContext& context, std::string name) : KRResource(context, name) m_constant = false; } -KRMesh::KRMesh(KRContext& context, std::string name, KRDataBlock* data) : KRResource(context, name) +KRMesh::KRMesh(KRContext& context, std::string name, Block* data) : KRResource(context, name) { setName(name); @@ -149,13 +151,13 @@ bool KRMesh::save(const std::string& path) return m_pData->save(path); } -bool KRMesh::save(KRDataBlock& data) +bool KRMesh::save(Block& data) { data.append(*m_pData); return true; } -void KRMesh::loadPack(KRDataBlock* data) +void KRMesh::loadPack(Block* data) { releaseData(); @@ -377,8 +379,8 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t) getIndexedRange(index_group++, start_index_offset, start_vertex_offset, index_count, vertex_count); if ((int)mesh.vertex_data_blocks.size() <= vbo_index) { - KRDataBlock* vertex_data_block = m_pData->getSubBlock(vertex_data_offset + start_vertex_offset * m_vertex_size, vertex_count * m_vertex_size); - KRDataBlock* index_data_block = m_pData->getSubBlock(index_data_offset + start_index_offset * 2, index_count * 2); + Block* vertex_data_block = m_pData->getSubBlock(vertex_data_offset + start_vertex_offset * m_vertex_size, vertex_count * m_vertex_size); + Block* index_data_block = m_pData->getSubBlock(index_data_offset + start_index_offset * 2, index_count * 2); mesh.vbo_data_blocks.emplace_back(std::make_shared(getContext().getMeshManager(), vertex_data_block, index_data_block, vertex_attrib_flags, true, t #if KRENGINE_DEBUG_GPU_LABELS , m_lodBaseName.c_str() @@ -406,8 +408,8 @@ void KRMesh::createDataBlocks(KRMeshManager::KRVBOData::vbo_type t) int vertex_size = m_vertex_size; if ((int)mesh.vertex_data_blocks.size() <= vbo_index) { - KRDataBlock* index_data_block = NULL; - KRDataBlock* vertex_data_block = m_pData->getSubBlock(vertex_data_offset + iBuffer * MAX_VBO_SIZE * vertex_size, vertex_size * cBufferVertexes); + Block* index_data_block = NULL; + Block* vertex_data_block = m_pData->getSubBlock(vertex_data_offset + iBuffer * MAX_VBO_SIZE * vertex_size, vertex_size * cBufferVertexes); mesh.vbo_data_blocks.emplace_back(std::make_shared(getContext().getMeshManager(), vertex_data_block, index_data_block, vertex_attrib_flags, true, t #if KRENGINE_DEBUG_GPU_LABELS , m_lodBaseName.c_str() @@ -619,7 +621,7 @@ void KRMesh::LoadData(const KRMesh::mesh_info& mi, bool calculate_normals, bool size_t vertex_count = mi.vertices.size(); size_t bone_count = mi.bone_names.size(); size_t new_file_size = sizeof(pack_header) + sizeof(pack_material) * submesh_count + sizeof(pack_bone) * bone_count + KRALIGN(2 * index_count) + KRALIGN(8 * index_base_count) + vertex_size * vertex_count; - m_pData = new KRDataBlock(); + m_pData = new Block(); m_pMetaData = m_pData; m_pData->expand(new_file_size); m_pData->lock(); diff --git a/kraken/KRMesh.h b/kraken/KRMesh.h index 086f596..62d107a 100755 --- a/kraken/KRMesh.h +++ b/kraken/KRMesh.h @@ -71,7 +71,7 @@ class KRMesh : public KRResource public: static void parseName(const std::string& name, std::string& lodBaseName, int& lodCoverage); - KRMesh(KRContext& context, std::string name, KRDataBlock* data); + KRMesh(KRContext& context, std::string name, mimir::Block* data); KRMesh(KRContext& context, std::string name); virtual ~KRMesh(); @@ -124,10 +124,10 @@ public: virtual std::string getExtension(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); void LoadData(const mesh_info& mi, bool calculate_normals, bool calculate_tangents); - void loadPack(KRDataBlock* data); + void loadPack(mimir::Block* data); void convertToIndexed(); void optimize(); @@ -160,8 +160,8 @@ public: int start_vertex; int vertex_count; char szMaterialName[KRENGINE_MAX_NAME_LENGTH]; - vector vertex_data_blocks; - vector index_data_blocks; + vector vertex_data_blocks; + vector index_data_blocks; // KRMeshManager depends on the address of KRVBOData's being constant // after allocation, enforced by deleted copy constructors. // As std::vector requires copy constuctors, we wrap these in shared_ptr. @@ -239,9 +239,9 @@ protected: bool m_constant; // TRUE if this should be always loaded and should not be passed through the streamer private: - KRDataBlock* m_pData; - KRDataBlock* m_pMetaData; - KRDataBlock* m_pIndexBaseData; + mimir::Block* m_pData; + mimir::Block* m_pMetaData; + mimir::Block* m_pIndexBaseData; void getSubmeshes(); void getMaterials(); diff --git a/kraken/KRMeshManager.cpp b/kraken/KRMeshManager.cpp index 0b15a67..d7d1b4b 100755 --- a/kraken/KRMeshManager.cpp +++ b/kraken/KRMeshManager.cpp @@ -38,6 +38,8 @@ #include "KRMeshQuad.h" #include "KRMeshSphere.h" +using namespace mimir; + KRMeshManager::KRMeshManager(KRContext& context) : KRResourceManager(context) , m_currentVBO(NULL) @@ -117,7 +119,7 @@ KRMeshManager::~KRMeshManager() m_models.clear(); } -KRResource* KRMeshManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRMeshManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("krmesh") == 0) { return loadModel(name.c_str(), data); @@ -140,7 +142,7 @@ KRResource* KRMeshManager::getResource(const std::string& name, const std::strin return nullptr; } -KRMesh* KRMeshManager::loadModel(const char* szName, KRDataBlock* pData) +KRMesh* KRMeshManager::loadModel(const char* szName, Block* pData) { KRMesh* pModel = new KRMesh(*m_pContext, szName, pData); addModel(pModel); @@ -326,7 +328,7 @@ long KRMeshManager::getMemUsed() long KRMeshManager::getMemActive() { long mem_active = 0; - for (unordered_map::iterator itr = m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) { + for (unordered_map::iterator itr = m_vbosActive.begin(); itr != m_vbosActive.end(); itr++) { mem_active += (*itr).second->getSize(); } return mem_active; @@ -475,7 +477,7 @@ KRMeshManager::KRVBOData::KRVBOData() memset(m_allocations, 0, sizeof(AllocationInfo) * KRENGINE_MAX_GPU_COUNT); } -KRMeshManager::KRVBOData::KRVBOData(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t +KRMeshManager::KRVBOData::KRVBOData(KRMeshManager* manager, Block* data, Block* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t #if KRENGINE_DEBUG_GPU_LABELS , const char* debug_label #endif @@ -492,7 +494,7 @@ KRMeshManager::KRVBOData::KRVBOData(KRMeshManager* manager, KRDataBlock* data, K ); } -void KRMeshManager::KRVBOData::init(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t +void KRMeshManager::KRVBOData::init(KRMeshManager* manager, Block* data, Block* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t #if KRENGINE_DEBUG_GPU_LABELS , const char* debug_label #endif diff --git a/kraken/KRMeshManager.h b/kraken/KRMeshManager.h index 0344a60..24e8165 100755 --- a/kraken/KRMeshManager.h +++ b/kraken/KRMeshManager.h @@ -35,7 +35,7 @@ #include "KRResourceManager.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRNode.h" class KRContext; @@ -51,13 +51,13 @@ public: void init(); virtual ~KRMeshManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; void startFrame(float deltaTime); void endFrame(float deltaTime); - KRMesh* loadModel(const char* szName, KRDataBlock* pData); + KRMesh* loadModel(const char* szName, mimir::Block* pData); std::vector getModel(const char* szName); KRMesh* getMaxLODModel(const char* szName); void addModel(KRMesh* model); @@ -84,12 +84,12 @@ public: } vbo_type; KRVBOData(); - KRVBOData(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t + KRVBOData(KRMeshManager* manager, mimir::Block* data, mimir::Block* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t #if KRENGINE_DEBUG_GPU_LABELS , const char* debug_label #endif ); - void init(KRMeshManager* manager, KRDataBlock* data, KRDataBlock* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t + void init(KRMeshManager* manager, mimir::Block* data, mimir::Block* index_data, int vertex_attrib_flags, bool static_vbo, vbo_type t #if KRENGINE_DEBUG_GPU_LABELS , const char* debug_label #endif @@ -97,8 +97,8 @@ public: ~KRVBOData(); - KRDataBlock* m_data; - KRDataBlock* m_index_data; + mimir::Block* m_data; + mimir::Block* m_index_data; bool isVBOLoaded() { @@ -211,9 +211,9 @@ public: void doStreaming(long& memoryRemaining, long& memoryRemainingThisFrame); private: - KRDataBlock KRENGINE_VBO_3D_CUBE_VERTICES; + mimir::Block KRENGINE_VBO_3D_CUBE_VERTICES; __int32_t KRENGINE_VBO_3D_CUBE_ATTRIBS; - KRDataBlock KRENGINE_VBO_2D_SQUARE_VERTICES; + mimir::Block KRENGINE_VBO_2D_SQUARE_VERTICES; __int32_t KRENGINE_VBO_2D_SQUARE_ATTRIBS; unordered_multimap m_models; // Multiple models with the same name/key may be inserted, representing multiple LOD levels of the model @@ -221,12 +221,12 @@ private: long m_vboMemUsed; KRVBOData* m_currentVBO; - unordered_map m_vbosActive; + unordered_map m_vbosActive; std::vector > m_activeVBOs_streamer; std::vector > m_activeVBOs_streamer_copy; - KRDataBlock m_randomParticleVertexData; - KRDataBlock m_volumetricLightingVertexData; + mimir::Block m_randomParticleVertexData; + mimir::Block m_volumetricLightingVertexData; long m_memoryTransferredThisFrame; diff --git a/kraken/KRPipelineManager.h b/kraken/KRPipelineManager.h index c4b0854..c158b66 100644 --- a/kraken/KRPipelineManager.h +++ b/kraken/KRPipelineManager.h @@ -34,7 +34,7 @@ #include "KREngine-common.h" #include "KRCamera.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRNode.h" #include "KRSurface.h" #include "KRMesh.h" diff --git a/kraken/KRResource+blend.cpp b/kraken/KRResource+blend.cpp index d2dc57b..539706c 100755 --- a/kraken/KRResource+blend.cpp +++ b/kraken/KRResource+blend.cpp @@ -35,12 +35,14 @@ #include "KRScene.h" #include "KRResource+blend.h" +using namespace mimir; + KRScene* KRResource::LoadBlenderScene(KRContext& context, const std::string& path) { KRScene* pScene = new KRScene(context, KRResource::GetFileBase(path)); - KRDataBlock data; + Block data; if (data.load(path)) { //KRBlendFile blend_file = KRBlendFile(pFile); diff --git a/kraken/KRResource+obj.cpp b/kraken/KRResource+obj.cpp index ee72d62..bdf1bba 100755 --- a/kraken/KRResource+obj.cpp +++ b/kraken/KRResource+obj.cpp @@ -34,6 +34,8 @@ #include "KRResource.h" #include "KRMesh.h" +using namespace mimir; + KRMesh* KRResource::LoadObj(KRContext& context, const std::string& path) { KRMesh* new_mesh = new KRMesh(context, KRResource::GetFileBase(path)); @@ -42,7 +44,7 @@ KRMesh* KRResource::LoadObj(KRContext& context, const std::string& path) std::vector material_names_t; - KRDataBlock data; + Block data; char szSymbol[500][256]; diff --git a/kraken/KRResource.cpp b/kraken/KRResource.cpp index edc04fc..fe3294f 100755 --- a/kraken/KRResource.cpp +++ b/kraken/KRResource.cpp @@ -34,6 +34,8 @@ #include "KRBundle.h" #include "KRContext.h" +using namespace mimir; + KRResource::KRResource(KRContext& context, std::string name) : KRContextObject(context) { m_name = name; @@ -89,7 +91,7 @@ std::string KRResource::GetFilePath(const std::string& name) bool KRResource::save(const std::string& path) { - KRDataBlock data; + Block data; if (save(data)) { return data.save(path); } else { @@ -99,11 +101,11 @@ bool KRResource::save(const std::string& path) KrResult KRResource::moveToBundle(KRBundle* bundle) { - KRDataBlock* data = bundle->append(*this); + Block* data = bundle->append(*this); if (data == nullptr) { return KR_ERROR_UNEXPECTED; } - // TODO(kearwood) - We must re-attach the KRResource to the returned KRDataBlock + // TODO(kearwood) - We must re-attach the KRResource to the returned Block delete data; return KR_SUCCESS; } diff --git a/kraken/KRResource.h b/kraken/KRResource.h index 9e94f57..26b9f28 100755 --- a/kraken/KRResource.h +++ b/kraken/KRResource.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRBundle; class KRScene; @@ -44,7 +44,7 @@ public: std::string getName(); virtual std::string getExtension() = 0; virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data) = 0; + virtual bool save(mimir::Block& data) = 0; KrResult moveToBundle(KRBundle* bundle); diff --git a/kraken/KRResourceManager.h b/kraken/KRResourceManager.h index 5c5e39c..28fb558 100644 --- a/kraken/KRResourceManager.h +++ b/kraken/KRResourceManager.h @@ -35,7 +35,7 @@ #include "KRResource.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRResourceManager : public KRContextObject { @@ -43,6 +43,6 @@ public: KRResourceManager(KRContext& context); virtual ~KRResourceManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) = 0; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) = 0; virtual KRResource* getResource(const std::string& name, const std::string& extension) = 0; }; diff --git a/kraken/KRSamplerManager.h b/kraken/KRSamplerManager.h index 5224458..72ebdfc 100644 --- a/kraken/KRSamplerManager.h +++ b/kraken/KRSamplerManager.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" -#include "KRDataBlock.h" +#include "block.h" using std::map; using std::vector; diff --git a/kraken/KRScene.cpp b/kraken/KRScene.cpp index 4700da0..99196c4 100755 --- a/kraken/KRScene.cpp +++ b/kraken/KRScene.cpp @@ -40,6 +40,8 @@ #include "KRPointLight.h" #include "KRAudioManager.h" +using namespace mimir; + const long KRENGINE_OCCLUSION_TEST_EXPIRY = 10; KRScene::KRScene(KRContext& context, std::string name) : KRResource(context, name) @@ -383,7 +385,7 @@ KRNode* KRScene::getRootNode() return m_pRootNode; } -bool KRScene::save(KRDataBlock& data) +bool KRScene::save(Block& data) { tinyxml2::XMLDocument doc; tinyxml2::XMLElement* scene_node = doc.NewElement("scene"); @@ -397,7 +399,7 @@ bool KRScene::save(KRDataBlock& data) return true; } -KRScene* KRScene::Load(KRContext& context, const std::string& name, KRDataBlock* data) +KRScene* KRScene::Load(KRContext& context, const std::string& name, Block* data) { std::string xml_string = data->getString(); delete data; diff --git a/kraken/KRScene.h b/kraken/KRScene.h index a585937..abe3dbd 100755 --- a/kraken/KRScene.h +++ b/kraken/KRScene.h @@ -57,9 +57,9 @@ public: virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - static KRScene* Load(KRContext& context, const std::string& name, KRDataBlock* data); + static KRScene* Load(KRContext& context, const std::string& name, mimir::Block* data); KRNode* getRootNode(); KRLight* getFirstLight(); diff --git a/kraken/KRSceneManager.cpp b/kraken/KRSceneManager.cpp index 706a4c3..1ad442a 100755 --- a/kraken/KRSceneManager.cpp +++ b/kraken/KRSceneManager.cpp @@ -32,6 +32,8 @@ #include "KRSceneManager.h" #include "KRScene.h" +using namespace mimir; + KRSceneManager::KRSceneManager(KRContext& context) : KRResourceManager(context) {} @@ -43,7 +45,7 @@ KRSceneManager::~KRSceneManager() m_scenes.clear(); } -KRResource* KRSceneManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRSceneManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("krscene") == 0) { return loadScene(name, data); @@ -59,7 +61,7 @@ KRResource* KRSceneManager::getResource(const std::string& name, const std::stri return nullptr; } -KRScene* KRSceneManager::loadScene(const std::string& name, KRDataBlock* data) +KRScene* KRSceneManager::loadScene(const std::string& name, Block* data) { std::lock_guard lock(m_mutex); std::string lowerName = name; diff --git a/kraken/KRSceneManager.h b/kraken/KRSceneManager.h index f007eca..5a9e4dd 100755 --- a/kraken/KRSceneManager.h +++ b/kraken/KRSceneManager.h @@ -35,7 +35,7 @@ #include "KRResourceManager.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRScene; @@ -45,13 +45,13 @@ public: KRSceneManager(KRContext& context); virtual ~KRSceneManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; KRScene* createScene(const std::string& name); void add(KRScene* scene); - KRScene* loadScene(const std::string& name, KRDataBlock* data); + KRScene* loadScene(const std::string& name, mimir::Block* data); KRScene* getScene(const std::string& name); KRScene* getFirstScene(); diff --git a/kraken/KRShader.cpp b/kraken/KRShader.cpp index 4efb1e3..032c151 100644 --- a/kraken/KRShader.cpp +++ b/kraken/KRShader.cpp @@ -32,6 +32,8 @@ #include "KRShader.h" #include "spirv_reflect.h" +using namespace mimir; + ShaderStage getShaderStageFromExtension(const char* extension) { if (strcmp(extension, "vert") == 0) { @@ -104,7 +106,7 @@ VkShaderStageFlagBits getShaderStageFlagBitsFromShaderStage(ShaderStage stage) KRShader::KRShader(KRContext& context, std::string name, std::string extension) : KRResource(context, name) { - m_pData = new KRDataBlock(); + m_pData = new Block(); m_extension = extension; m_subExtension = KRResource::GetFileExtension(name); m_stage = getShaderStageFromExtension(m_subExtension.c_str()); @@ -113,7 +115,7 @@ KRShader::KRShader(KRContext& context, std::string name, std::string extension) getReflection(); } -KRShader::KRShader(KRContext& context, std::string name, std::string extension, KRDataBlock* data) : KRResource(context, name) +KRShader::KRShader(KRContext& context, std::string name, std::string extension, Block* data) : KRResource(context, name) { m_pData = data; m_extension = extension; @@ -138,13 +140,13 @@ std::string& KRShader::getSubExtension() return m_subExtension; } -bool KRShader::save(KRDataBlock& data) +bool KRShader::save(Block& data) { data.append(*m_pData); return true; } -KRDataBlock* KRShader::getData() +Block* KRShader::getData() { return m_pData; } diff --git a/kraken/KRShader.h b/kraken/KRShader.h index 94c64c5..57c9cf7 100644 --- a/kraken/KRShader.h +++ b/kraken/KRShader.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" #include "spirv_reflect.h" @@ -66,7 +66,7 @@ class KRShader : public KRResource { public: KRShader(KRContext& context, std::string name, std::string extension); - KRShader(KRContext& context, std::string name, std::string extension, KRDataBlock* data); + KRShader(KRContext& context, std::string name, std::string extension, mimir::Block* data); virtual ~KRShader(); virtual std::string getExtension(); @@ -74,9 +74,9 @@ public: bool createShaderModule(VkDevice& device, VkShaderModule& module); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - KRDataBlock* getData(); + mimir::Block* getData(); const SpvReflectShaderModule* getReflection(); ShaderStage getShaderStage() const; VkShaderStageFlagBits getShaderStageFlagBits() const; @@ -86,7 +86,7 @@ private: std::string m_extension; std::string m_subExtension; - KRDataBlock* m_pData; + mimir::Block* m_pData; SpvReflectShaderModule m_reflection; bool m_reflectionValid; diff --git a/kraken/KRShaderManager.cpp b/kraken/KRShaderManager.cpp index 34cba3c..a33ec00 100644 --- a/kraken/KRShaderManager.cpp +++ b/kraken/KRShaderManager.cpp @@ -36,6 +36,8 @@ #include "KRUnknownManager.h" #include "KRUnknown.h" +using namespace mimir; + KRShaderManager::KRShaderManager(KRContext& context) : KRResourceManager(context) , m_initializedGlslang(false) , m_includer(&context) @@ -55,7 +57,7 @@ KRShaderManager::~KRShaderManager() } } -KRResource* KRShaderManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRShaderManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("spv") == 0) { return load(name, extension, data); @@ -98,7 +100,7 @@ void KRShaderManager::add(KRShader* shader) } } -KRShader* KRShaderManager::load(const std::string& name, const std::string& extension, KRDataBlock* data) +KRShader* KRShaderManager::load(const std::string& name, const std::string& extension, Block* data) { KRShader* shader = new KRShader(getContext(), name, extension, data); if (shader) add(shader); @@ -347,7 +349,7 @@ bool KRShaderManager::compileAll(KRBundle* outputBundle, KRUnknown* logResource) break; } if (!shader_name.empty()) { - KRDataBlock* data = new KRDataBlock(); + Block* data = new Block(); data->append(static_cast(spirv.data()), spirv.size() * sizeof(unsigned int)); KRShader* shader = new KRShader(getContext(), shader_name, "spv", data); add(shader); @@ -393,7 +395,7 @@ glslang::TShader::Includer::IncludeResult* KRShaderManager::Includer::includeLoc if (!source) { return nullptr; } - KRDataBlock* data = source->getData(); + Block* data = source->getData(); data->lock(); const char* sourceString = static_cast(data->getStart()); return new IncludeResult(std::string(headerName), sourceString, data->getSize(), static_cast(data)); @@ -401,6 +403,6 @@ glslang::TShader::Includer::IncludeResult* KRShaderManager::Includer::includeLoc void KRShaderManager::Includer::releaseInclude(IncludeResult* includeResult) { - KRDataBlock* data = static_cast(includeResult->userData); + Block* data = static_cast(includeResult->userData); data->unlock(); } diff --git a/kraken/KRShaderManager.h b/kraken/KRShaderManager.h index dd8e15b..932f7b3 100644 --- a/kraken/KRShaderManager.h +++ b/kraken/KRShaderManager.h @@ -37,7 +37,7 @@ #include "KRShader.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRUnknown; @@ -47,12 +47,12 @@ public: KRShaderManager(KRContext& context); virtual ~KRShaderManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; void add(KRShader* shader); - KRShader* load(const std::string& name, const std::string& extension, KRDataBlock* data); + KRShader* load(const std::string& name, const std::string& extension, mimir::Block* data); KRShader* get(const std::string& name, const std::string& extension); bool compileAll(KRBundle* outputBundle, KRUnknown* logResource); diff --git a/kraken/KRSource.cpp b/kraken/KRSource.cpp index b94a93c..2c7b406 100644 --- a/kraken/KRSource.cpp +++ b/kraken/KRSource.cpp @@ -31,13 +31,15 @@ #include "KRSource.h" +using namespace mimir; + KRSource::KRSource(KRContext& context, std::string name, std::string extension) : KRResource(context, name) { - m_pData = new KRDataBlock(); + m_pData = new Block(); m_extension = extension; } -KRSource::KRSource(KRContext& context, std::string name, std::string extension, KRDataBlock* data) : KRResource(context, name) +KRSource::KRSource(KRContext& context, std::string name, std::string extension, Block* data) : KRResource(context, name) { m_pData = data; m_extension = extension; @@ -53,13 +55,13 @@ std::string KRSource::getExtension() return m_extension; } -bool KRSource::save(KRDataBlock& data) +bool KRSource::save(Block& data) { data.append(*m_pData); return true; } -KRDataBlock* KRSource::getData() +Block* KRSource::getData() { return m_pData; } diff --git a/kraken/KRSource.h b/kraken/KRSource.h index 52e6c00..1a87044 100644 --- a/kraken/KRSource.h +++ b/kraken/KRSource.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" class KRSource : public KRResource @@ -41,17 +41,17 @@ class KRSource : public KRResource public: KRSource(KRContext& context, std::string name, std::string extension); - KRSource(KRContext& context, std::string name, std::string extension, KRDataBlock* data); + KRSource(KRContext& context, std::string name, std::string extension, mimir::Block* data); virtual ~KRSource(); virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - KRDataBlock* getData(); + mimir::Block* getData(); private: std::string m_extension; - KRDataBlock* m_pData; + mimir::Block* m_pData; }; diff --git a/kraken/KRSourceManager.cpp b/kraken/KRSourceManager.cpp index 4db226b..c20c09f 100644 --- a/kraken/KRSourceManager.cpp +++ b/kraken/KRSourceManager.cpp @@ -33,6 +33,8 @@ #include "KREngine-common.h" #include "KRShader.h" +using namespace mimir; + KRSourceManager::KRSourceManager(KRContext& context) : KRResourceManager(context) { @@ -75,7 +77,7 @@ void KRSourceManager::add(KRSource* source) } } -KRResource* KRSourceManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRSourceManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (getShaderStageFromExtension(extension.c_str()) != ShaderStage::Invalid || extension.compare("glsl") == 0 || @@ -95,7 +97,7 @@ KRResource* KRSourceManager::getResource(const std::string& name, const std::str return nullptr; } -KRSource* KRSourceManager::load(const std::string& name, const std::string& extension, KRDataBlock* data) +KRSource* KRSourceManager::load(const std::string& name, const std::string& extension, Block* data) { KRSource* source = new KRSource(getContext(), name, extension, data); if (source) add(source); diff --git a/kraken/KRSourceManager.h b/kraken/KRSourceManager.h index f3765d1..0390023 100644 --- a/kraken/KRSourceManager.h +++ b/kraken/KRSourceManager.h @@ -36,7 +36,7 @@ #include "KRResourceManager.h" #include "KRSource.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRSourceManager : public KRResourceManager { @@ -44,12 +44,12 @@ public: KRSourceManager(KRContext& context); virtual ~KRSourceManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; void add(KRSource* source); - KRSource* load(const std::string& name, const std::string& extension, KRDataBlock* data); + KRSource* load(const std::string& name, const std::string& extension, mimir::Block* data); KRSource* get(const std::string& name, const std::string& extension); const unordered_map& get(const std::string& extension); diff --git a/kraken/KRTexture.cpp b/kraken/KRTexture.cpp index 2a9a67a..53cb4d2 100755 --- a/kraken/KRTexture.cpp +++ b/kraken/KRTexture.cpp @@ -31,7 +31,7 @@ #include "KREngine-common.h" #include "KRTexture.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRContext.h" #include "KRTextureManager.h" diff --git a/kraken/KRTexture.h b/kraken/KRTexture.h index 7ce46ac..998abb7 100755 --- a/kraken/KRTexture.h +++ b/kraken/KRTexture.h @@ -35,7 +35,9 @@ #include "KRContextObject.h" #include "KRResource.h" -class KRDataBlock; +namespace mimir { + class Block; +} class KRCamera; class KRDeviceManager; class KRDevice; diff --git a/kraken/KRTexture2D.cpp b/kraken/KRTexture2D.cpp index 9805cd1..b9a4317 100755 --- a/kraken/KRTexture2D.cpp +++ b/kraken/KRTexture2D.cpp @@ -33,7 +33,9 @@ #include "KRTexture2D.h" #include "KRTextureManager.h" -KRTexture2D::KRTexture2D(KRContext& context, KRDataBlock* data, std::string name) : KRTexture(context, name) +using namespace mimir; + +KRTexture2D::KRTexture2D(KRContext& context, Block* data, std::string name) : KRTexture(context, name) { m_pData = data; } @@ -114,7 +116,7 @@ bool KRTexture2D::save(const std::string& path) } } -bool KRTexture2D::save(KRDataBlock& data) +bool KRTexture2D::save(Block& data) { if (m_pData) { data.append(*m_pData); diff --git a/kraken/KRTexture2D.h b/kraken/KRTexture2D.h index bcf92ea..11f91cc 100755 --- a/kraken/KRTexture2D.h +++ b/kraken/KRTexture2D.h @@ -32,7 +32,7 @@ #pragma once #include "KREngine-common.h" -#include "KRDataBlock.h" +#include "block.h" using std::list; @@ -43,16 +43,16 @@ class KRDevice; class KRTexture2D : public KRTexture { public: - KRTexture2D(KRContext& context, KRDataBlock* data, std::string name); + KRTexture2D(KRContext& context, mimir::Block* data, std::string name); virtual ~KRTexture2D(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); virtual bool uploadTexture(KRDevice& device, VkImage& image, int lod_max_dim, int& current_lod_max_dim, bool premultiply_alpha = false) = 0; virtual Vector2i getDimensions() const = 0; protected: - KRDataBlock* m_pData; + mimir::Block* m_pData; bool createGPUTexture(int lod_max_dim) override; }; diff --git a/kraken/KRTextureAnimated.cpp b/kraken/KRTextureAnimated.cpp index 94e4606..2368bc1 100755 --- a/kraken/KRTextureAnimated.cpp +++ b/kraken/KRTextureAnimated.cpp @@ -143,7 +143,7 @@ bool KRTextureAnimated::save(const std::string& path) return true; // Animated textures are just references; there are no files to output } -bool KRTextureAnimated::save(KRDataBlock& data) +bool KRTextureAnimated::save(Block& data) { return true; // Animated textures are just references; there are no files to output } diff --git a/kraken/KRTextureAnimated.h b/kraken/KRTextureAnimated.h index 143f49c..95a649a 100755 --- a/kraken/KRTextureAnimated.h +++ b/kraken/KRTextureAnimated.h @@ -34,6 +34,8 @@ #include "KRTexture.h" #include "KRTexture2D.h" +using namespace mimir; + class KRTextureAnimated : public KRTexture { public: @@ -41,7 +43,7 @@ public: virtual ~KRTextureAnimated(); virtual std::string getExtension(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); + virtual bool save(Block& data); virtual long getMemRequiredForSize(int max_dim); virtual void resetPoolExpiry(float lodCoverage, texture_usage_t textureUsage); diff --git a/kraken/KRTextureCube.cpp b/kraken/KRTextureCube.cpp index 93b6f93..459ed2b 100755 --- a/kraken/KRTextureCube.cpp +++ b/kraken/KRTextureCube.cpp @@ -33,6 +33,8 @@ #include "KRTexture2D.h" #include "KRContext.h" +using namespace mimir; + KRTextureCube::KRTextureCube(KRContext& context, std::string name) : KRTexture(context, name) { @@ -163,7 +165,7 @@ bool KRTextureCube::save(const std::string& path) return true; // Cube maps are just references; there are no files to output } -bool KRTextureCube::save(KRDataBlock& data) +bool KRTextureCube::save(Block& data) { return true; // Cube maps are just references; there are no files to output } diff --git a/kraken/KRTextureCube.h b/kraken/KRTextureCube.h index d3fb194..5de7b60 100755 --- a/kraken/KRTextureCube.h +++ b/kraken/KRTextureCube.h @@ -42,7 +42,7 @@ public: virtual ~KRTextureCube(); virtual std::string getExtension(); virtual bool save(const std::string& path); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); virtual long getMemRequiredForSize(int max_dim); virtual void resetPoolExpiry(float lodCoverage, texture_usage_t textureUsage); diff --git a/kraken/KRTextureKTX.cpp b/kraken/KRTextureKTX.cpp index c102cb5..784305c 100755 --- a/kraken/KRTextureKTX.cpp +++ b/kraken/KRTextureKTX.cpp @@ -38,7 +38,7 @@ __uint8_t _KTXFileIdentifier[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A }; -KRTextureKTX::KRTextureKTX(KRContext& context, KRDataBlock* data, std::string name) : KRTexture2D(context, data, name) +KRTextureKTX::KRTextureKTX(KRContext& context, Block* data, std::string name) : KRTexture2D(context, data, name) { m_pData->copy(&m_header, 0, sizeof(KTXHeader)); if (memcmp(_KTXFileIdentifier, m_header.identifier, 12) != 0) { @@ -84,7 +84,7 @@ KRTextureKTX::KRTextureKTX(KRContext& context, KRDataBlock* data, std::string na m_min_lod_max_dim = KRMAX(width, height); } -KRTextureKTX::KRTextureKTX(KRContext& context, std::string name, unsigned int internal_format, unsigned int base_internal_format, int width, int height, const std::list& blocks) : KRTexture2D(context, new KRDataBlock(), name) +KRTextureKTX::KRTextureKTX(KRContext& context, std::string name, unsigned int internal_format, unsigned int base_internal_format, int width, int height, const std::list& blocks) : KRTexture2D(context, new Block(), name) { memcpy(m_header.identifier, _KTXFileIdentifier, 12); m_header.endianness = 0x04030201; @@ -103,7 +103,7 @@ KRTextureKTX::KRTextureKTX(KRContext& context, std::string name, unsigned int in m_pData->append(&m_header, sizeof(m_header)); for (auto block_itr = blocks.begin(); block_itr != blocks.end(); block_itr++) { - KRDataBlock* source_block = *block_itr; + Block* source_block = *block_itr; __uint32_t block_size = (__uint32_t)source_block->getSize(); m_pData->append(&block_size, 4); m_pData->append(*source_block); @@ -118,8 +118,8 @@ KRTextureKTX::KRTextureKTX(KRContext& context, std::string name, unsigned int in KRTextureKTX::~KRTextureKTX() { - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; delete block; } m_blocks.clear(); @@ -370,8 +370,8 @@ long KRTextureKTX::getMemRequiredForSize(int max_dim) int height = m_header.pixelHeight; long memoryRequired = 0; - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; if (width <= target_dim && height <= target_dim) { memoryRequired += (long)block->getSize(); } @@ -408,8 +408,8 @@ bool KRTextureKTX::uploadTexture(KRDevice& device, VkImage& image, int lod_max_d // Upload texture data int destination_level = 0; int source_level = 0; - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; if (width <= target_dim && height <= target_dim) { if (width > current_lod_max_dim) { diff --git a/kraken/KRTextureKTX.h b/kraken/KRTextureKTX.h index 798c622..d7f30ec 100755 --- a/kraken/KRTextureKTX.h +++ b/kraken/KRTextureKTX.h @@ -33,11 +33,13 @@ #include "KRTexture2D.h" +using namespace mimir; + class KRTextureKTX : public KRTexture2D { public: - KRTextureKTX(KRContext& context, KRDataBlock* data, std::string name); - KRTextureKTX(KRContext& context, std::string name, unsigned int internal_format, unsigned int base_internal_format, int width, int height, const std::list& blocks); + KRTextureKTX(KRContext& context, Block* data, std::string name); + KRTextureKTX(KRContext& context, std::string name, unsigned int internal_format, unsigned int base_internal_format, int width, int height, const std::list& blocks); virtual ~KRTextureKTX(); virtual std::string getExtension(); @@ -50,7 +52,7 @@ public: protected: - std::list m_blocks; + std::list m_blocks; typedef struct _KTXHeader { diff --git a/kraken/KRTextureKTX2.cpp b/kraken/KRTextureKTX2.cpp index b06a8bb..a476108 100644 --- a/kraken/KRTextureKTX2.cpp +++ b/kraken/KRTextureKTX2.cpp @@ -34,11 +34,13 @@ #include "KREngine-common.h" +using namespace mimir; + __uint8_t _KTX2FileIdentifier[12] = { 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x32, 0x30, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A }; -KRTextureKTX2::KRTextureKTX2(KRContext& context, KRDataBlock* data, std::string name) : KRTexture2D(context, data, name) +KRTextureKTX2::KRTextureKTX2(KRContext& context, Block* data, std::string name) : KRTexture2D(context, data, name) { m_pData->copy(&m_header, 0, sizeof(KTX2Header)); if (memcmp(_KTX2FileIdentifier, m_header.identifier, 12) != 0) { diff --git a/kraken/KRTextureKTX2.h b/kraken/KRTextureKTX2.h index ce8ff3e..0f93ee6 100644 --- a/kraken/KRTextureKTX2.h +++ b/kraken/KRTextureKTX2.h @@ -36,7 +36,7 @@ class KRTextureKTX2 : public KRTexture2D { public: - KRTextureKTX2(KRContext& context, KRDataBlock* data, std::string name); + KRTextureKTX2(KRContext& context, mimir::Block* data, std::string name); virtual ~KRTextureKTX2(); virtual std::string getExtension(); diff --git a/kraken/KRTextureManager.cpp b/kraken/KRTextureManager.cpp index 749a99d..a524584 100755 --- a/kraken/KRTextureManager.cpp +++ b/kraken/KRTextureManager.cpp @@ -68,7 +68,7 @@ void KRTextureManager::setMaxAnisotropy(float max_anisotropy) m_maxAnisotropy = max_anisotropy; } -KRResource* KRTextureManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRTextureManager::loadResource(const std::string& name, const std::string& extension, Block* data) { if (extension.compare("pvr") == 0 || extension.compare("ktx") == 0 || @@ -95,7 +95,7 @@ KRResource* KRTextureManager::getResource(const std::string& name, const std::st return nullptr; } -KRTexture* KRTextureManager::loadTexture(const char* szName, const char* szExtension, KRDataBlock* data) +KRTexture* KRTextureManager::loadTexture(const char* szName, const char* szExtension, Block* data) { KRTexture* pTexture = NULL; diff --git a/kraken/KRTextureManager.h b/kraken/KRTextureManager.h index 5f5bd1e..06b8472 100755 --- a/kraken/KRTextureManager.h +++ b/kraken/KRTextureManager.h @@ -38,7 +38,7 @@ #include "KRTexture.h" #include "KRContextObject.h" #include "KREngine-common.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRContext.h" #include "KRStreamerThread.h" @@ -49,12 +49,12 @@ public: virtual ~KRTextureManager(); void destroy(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; bool selectTexture(unsigned int target, int iTextureUnit, int iTextureHandle); - KRTexture* loadTexture(const char* szName, const char* szExtension, KRDataBlock* data); + KRTexture* loadTexture(const char* szName, const char* szExtension, mimir::Block* data); KRTexture* getTextureCube(const char* szName); KRTexture* getTexture(const std::string& name); diff --git a/kraken/KRTexturePVR.cpp b/kraken/KRTexturePVR.cpp index f1e43d9..03cc40f 100755 --- a/kraken/KRTexturePVR.cpp +++ b/kraken/KRTexturePVR.cpp @@ -34,6 +34,8 @@ #include "KREngine-common.h" +using namespace mimir; + #define PVR_TEXTURE_FLAG_TYPE_MASK 0xff @@ -62,7 +64,7 @@ typedef struct _PVRTexHeader uint32_t numSurfs; } PVRTexHeader; -KRTexturePVR::KRTexturePVR(KRContext& context, KRDataBlock* data, std::string name) : KRTexture2D(context, data, name) +KRTexturePVR::KRTexturePVR(KRContext& context, Block* data, std::string name) : KRTexture2D(context, data, name) { #if TARGET_OS_IPHONE @@ -139,8 +141,8 @@ KRTexturePVR::KRTexturePVR(KRContext& context, KRDataBlock* data, std::string na KRTexturePVR::~KRTexturePVR() { - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; delete block; } m_blocks.clear(); @@ -179,8 +181,8 @@ long KRTexturePVR::getMemRequiredForSize(int max_dim) int height = m_iHeight; long memoryRequired = 0; - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; if (width <= target_dim && height <= target_dim) { memoryRequired += (long)block->getSize(); } @@ -216,8 +218,8 @@ bool KRTexturePVR::uploadTexture(KRDevice& device, VkImage& image, int lod_max_d // Upload texture data int destination_level = 0; int source_level = 0; - for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { - KRDataBlock* block = *itr; + for (std::list::iterator itr = m_blocks.begin(); itr != m_blocks.end(); itr++) { + Block* block = *itr; if (width <= target_dim && height <= target_dim) { if (width > current_lod_max_dim) { diff --git a/kraken/KRTexturePVR.h b/kraken/KRTexturePVR.h index f641af3..5061876 100755 --- a/kraken/KRTexturePVR.h +++ b/kraken/KRTexturePVR.h @@ -36,7 +36,7 @@ class KRTexturePVR : public KRTexture2D { public: - KRTexturePVR(KRContext& context, KRDataBlock* data, std::string name); + KRTexturePVR(KRContext& context, mimir::Block* data, std::string name); virtual ~KRTexturePVR(); virtual std::string getExtension(); @@ -54,5 +54,5 @@ protected: unsigned int m_internalFormat; bool m_bHasAlpha; - std::list m_blocks; + std::list m_blocks; }; diff --git a/kraken/KRTextureTGA.cpp b/kraken/KRTextureTGA.cpp index 332cb09..d001893 100755 --- a/kraken/KRTextureTGA.cpp +++ b/kraken/KRTextureTGA.cpp @@ -70,7 +70,7 @@ typedef struct #endif -KRTextureTGA::KRTextureTGA(KRContext& context, KRDataBlock* data, std::string name) : KRTexture2D(context, data, name) +KRTextureTGA::KRTextureTGA(KRContext& context, Block* data, std::string name) : KRTexture2D(context, data, name) { data->lock(); TGA_HEADER* pHeader = (TGA_HEADER*)data->getStart(); @@ -329,7 +329,7 @@ KRTexture* KRTextureTGA::compress(bool premultiply_alpha) m_pData->lock(); - std::list blocks; + std::list blocks; getContext().getTextureManager()->_setActiveTexture(0); @@ -370,7 +370,7 @@ KRTexture* KRTextureTGA::compress(bool premultiply_alpha) while(lod_width > 1) { GLDEBUG(glGetTexLevelParameteriv(GL_TEXTURE_2D, lod_level, GL_TEXTURE_WIDTH, &lod_width)); GLDEBUG(glGetTexLevelParameteriv(GL_TEXTURE_2D, lod_level, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &compressed_size)); - KRDataBlock *new_block = new KRDataBlock(); + Block *new_block = new Block(); new_block->expand(compressed_size); new_block->lock(); GLDEBUG(glGetCompressedTexImage(GL_TEXTURE_2D, lod_level, new_block->getStart())); @@ -390,7 +390,7 @@ KRTexture* KRTextureTGA::compress(bool premultiply_alpha) m_pData->unlock(); for(auto block_itr = blocks.begin(); block_itr != blocks.end(); block_itr++) { - KRDataBlock *block = *block_itr; + Block *block = *block_itr; delete block; } diff --git a/kraken/KRTextureTGA.h b/kraken/KRTextureTGA.h index 5f597f5..e978e05 100755 --- a/kraken/KRTextureTGA.h +++ b/kraken/KRTextureTGA.h @@ -33,10 +33,12 @@ #include "KRTexture2D.h" +using namespace mimir; + class KRTextureTGA : public KRTexture2D { public: - KRTextureTGA(KRContext& context, KRDataBlock* data, std::string name); + KRTextureTGA(KRContext& context, Block* data, std::string name); virtual ~KRTextureTGA(); virtual std::string getExtension(); diff --git a/kraken/KRUnknown.cpp b/kraken/KRUnknown.cpp index 2441208..83d2732 100755 --- a/kraken/KRUnknown.cpp +++ b/kraken/KRUnknown.cpp @@ -31,13 +31,15 @@ #include "KRUnknown.h" +using namespace mimir; + KRUnknown::KRUnknown(KRContext& context, std::string name, std::string extension) : KRResource(context, name) { - m_pData = new KRDataBlock(); + m_pData = new Block(); m_extension = extension; } -KRUnknown::KRUnknown(KRContext& context, std::string name, std::string extension, KRDataBlock* data) : KRResource(context, name) +KRUnknown::KRUnknown(KRContext& context, std::string name, std::string extension, Block* data) : KRResource(context, name) { m_pData = data; m_extension = extension; @@ -53,13 +55,13 @@ std::string KRUnknown::getExtension() return m_extension; } -bool KRUnknown::save(KRDataBlock& data) +bool KRUnknown::save(Block& data) { data.append(*m_pData); return true; } -KRDataBlock* KRUnknown::getData() +Block* KRUnknown::getData() { return m_pData; } diff --git a/kraken/KRUnknown.h b/kraken/KRUnknown.h index ba21a7d..179e865 100755 --- a/kraken/KRUnknown.h +++ b/kraken/KRUnknown.h @@ -33,7 +33,7 @@ #include "KREngine-common.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" #include "KRResource.h" class KRUnknown : public KRResource @@ -41,17 +41,17 @@ class KRUnknown : public KRResource public: KRUnknown(KRContext& context, std::string name, std::string extension); - KRUnknown(KRContext& context, std::string name, std::string extension, KRDataBlock* data); + KRUnknown(KRContext& context, std::string name, std::string extension, mimir::Block* data); virtual ~KRUnknown(); virtual std::string getExtension(); - virtual bool save(KRDataBlock& data); + virtual bool save(mimir::Block& data); - KRDataBlock* getData(); + mimir::Block* getData(); private: std::string m_extension; - KRDataBlock* m_pData; + mimir::Block* m_pData; }; diff --git a/kraken/KRUnknownManager.cpp b/kraken/KRUnknownManager.cpp index fc8a0ba..4032b18 100755 --- a/kraken/KRUnknownManager.cpp +++ b/kraken/KRUnknownManager.cpp @@ -32,6 +32,8 @@ #include "KRUnknownManager.h" #include "KREngine-common.h" +using namespace mimir; + KRUnknownManager::KRUnknownManager(KRContext& context) : KRResourceManager(context) { @@ -75,7 +77,7 @@ void KRUnknownManager::add(KRUnknown* unknown) } -KRResource* KRUnknownManager::loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) +KRResource* KRUnknownManager::loadResource(const std::string& name, const std::string& extension, Block* data) { // KRUnknown's can have any extension return load(name, extension, data); @@ -87,7 +89,7 @@ KRResource* KRUnknownManager::getResource(const std::string& name, const std::st return get(name, extension); } -KRUnknown* KRUnknownManager::load(const std::string& name, const std::string& extension, KRDataBlock* data) +KRUnknown* KRUnknownManager::load(const std::string& name, const std::string& extension, Block* data) { KRUnknown* unknown = new KRUnknown(getContext(), name, extension, data); if (unknown) add(unknown); diff --git a/kraken/KRUnknownManager.h b/kraken/KRUnknownManager.h index b81c53f..e24e239 100755 --- a/kraken/KRUnknownManager.h +++ b/kraken/KRUnknownManager.h @@ -37,7 +37,7 @@ #include "KRUnknown.h" #include "KRContextObject.h" -#include "KRDataBlock.h" +#include "block.h" class KRUnknownManager : public KRResourceManager { @@ -45,12 +45,12 @@ public: KRUnknownManager(KRContext& context); virtual ~KRUnknownManager(); - virtual KRResource* loadResource(const std::string& name, const std::string& extension, KRDataBlock* data) override; + virtual KRResource* loadResource(const std::string& name, const std::string& extension, mimir::Block* data) override; virtual KRResource* getResource(const std::string& name, const std::string& extension) override; void add(KRUnknown* unknown); - KRUnknown* load(const std::string& name, const std::string& extension, KRDataBlock* data); + KRUnknown* load(const std::string& name, const std::string& extension, mimir::Block* data); KRUnknown* get(const std::string& name, const std::string& extension); diff --git a/kraken/KRDataBlock.cpp b/kraken/block.cpp similarity index 93% rename from kraken/KRDataBlock.cpp rename to kraken/block.cpp index f912575..cc7833f 100755 --- a/kraken/KRDataBlock.cpp +++ b/kraken/block.cpp @@ -1,5 +1,5 @@ // -// KRDataBlock.cpp +// block.cpp // Kraken Engine // // Copyright 2023 Kearwood Gilbert. All rights reserved. @@ -29,7 +29,7 @@ // or implied, of Kearwood Gilbert. // -#include "KRDataBlock.h" +#include "block.h" #include "KREngine-common.h" #include "KRResource.h" #include "KRContext.h" @@ -40,6 +40,7 @@ #include #endif +#define KRENGINE_MIN_MMAP 32768 #define KRAKEN_MEM_ROUND_DOWN_PAGE(x) ((x) & ~(KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY - 1)) #define KRAKEN_MEM_ROUND_UP_PAGE(x) ((((x) - 1) & ~(KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY - 1)) + KRContext::KRENGINE_SYS_ALLOCATION_GRANULARITY) @@ -47,7 +48,9 @@ int m_mapCount = 0; size_t m_mapSize = 0; size_t m_mapOverhead = 0; -KRDataBlock::KRDataBlock() +namespace mimir { + +Block::Block() { m_data = NULL; m_data_size = 0; @@ -66,7 +69,7 @@ KRDataBlock::KRDataBlock() m_bReadOnly = false; } -KRDataBlock::KRDataBlock(void* data, size_t size) +Block::Block(void* data, size_t size) { m_data = NULL; m_data_size = 0; @@ -86,13 +89,13 @@ KRDataBlock::KRDataBlock(void* data, size_t size) load(data, size); } -KRDataBlock::~KRDataBlock() +Block::~Block() { unload(); } // Unload a file, releasing any mmap'ed file handles or malloc'ed ram that was in use -void KRDataBlock::unload() +void Block::unload() { assert(m_lockCount == 0); @@ -130,7 +133,7 @@ void KRDataBlock::unload() } // Encapsulate a pointer. Note - The pointer will not be free'ed -bool KRDataBlock::load(void* data, size_t size) +bool Block::load(void* data, size_t size) { unload(); m_data = data; @@ -141,7 +144,7 @@ bool KRDataBlock::load(void* data, size_t size) } // Load a file into memory using mmap. The data pointer will be protected as read-only until append() or expand() is called -bool KRDataBlock::load(const std::string& path) +bool Block::load(const std::string& path) { bool success = false; unload(); @@ -180,10 +183,10 @@ bool KRDataBlock::load(const std::string& path) return success; } -// Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object. -KRDataBlock* KRDataBlock::getSubBlock(int start, int length) +// Create a Block encapsulating a sub-region of this block. The caller is responsible to free the object. +Block* Block::getSubBlock(int start, int length) { - KRDataBlock* new_block = new KRDataBlock(); + Block* new_block = new Block(); new_block->m_data_size = length; #if defined(_WIN32) || defined(_WIN64) @@ -206,27 +209,27 @@ KRDataBlock* KRDataBlock::getSubBlock(int start, int length) } // Return a pointer to the start of the data block -void* KRDataBlock::getStart() +void* Block::getStart() { assertLocked(); return m_data; } // Return a pointer to the byte after the end of the data block -void* KRDataBlock::getEnd() +void* Block::getEnd() { assertLocked(); return (unsigned char*)m_data + m_data_size; } // Return the size of the data block. Use append() or expand() to make the data block larger -size_t KRDataBlock::getSize() const +size_t Block::getSize() const { return m_data_size; } // Expand the data block, and switch it to read-write mode. Note - this may result in a mmap'ed file being copied to malloc'ed ram and then closed -void KRDataBlock::expand(size_t size) +void Block::expand(size_t size) { #if defined(_WIN32) || defined(_WIN64) if (m_data == NULL && m_hPackFile == INVALID_HANDLE_VALUE) { @@ -265,7 +268,7 @@ void KRDataBlock::expand(size_t size) } // Append data to the end of the block, increasing the size of the block and making it read-write. -void KRDataBlock::append(void* data, size_t size) +void Block::append(void* data, size_t size) { // Expand the data block expand(size); @@ -278,13 +281,13 @@ void KRDataBlock::append(void* data, size_t size) // Copy the entire data block to the destination pointer -void KRDataBlock::copy(void* dest) +void Block::copy(void* dest) { copy(dest, 0, (int)m_data_size); } // Copy a range of data to the destination pointer -void KRDataBlock::copy(void* dest, int start, int count) +void Block::copy(void* dest, int start, int count) { #if defined(_WIN32) || defined(_WIN64) if (m_lockCount == 0 && m_hPackFile != INVALID_HANDLE_VALUE) { @@ -321,7 +324,7 @@ void KRDataBlock::copy(void* dest, int start, int count) } // Append data to the end of the block, increasing the size of the block and making it read-write. -void KRDataBlock::append(KRDataBlock & data) +void Block::append(Block & data) { data.lock(); append(data.getStart(), data.getSize()); @@ -329,7 +332,7 @@ void KRDataBlock::append(KRDataBlock & data) } // Append string to the end of the block, increasing the size of the block and making it read-write. The resulting datablock includes a terminating character -void KRDataBlock::append(const std::string & s) +void Block::append(const std::string & s) { const char* szText = s.c_str(); size_t text_length = strlen(szText); @@ -349,7 +352,7 @@ void KRDataBlock::append(const std::string & s) } // Save the data to a file. -bool KRDataBlock::save(const std::string & path) +bool Block::save(const std::string & path) { #if defined(_WIN32) || defined(_WIN64) bool success = true; @@ -429,9 +432,9 @@ bool KRDataBlock::save(const std::string & path) } // Get contents as a string -std::string KRDataBlock::getString() +std::string Block::getString() { - KRDataBlock b; + Block b; b.append(*this); b.append((void*)"\0", 1); // Ensure data is null terminated, to read as a string safely b.lock(); @@ -471,7 +474,7 @@ void ReportWindowsLastError(LPCTSTR lpszFunction) #endif // Lock the memory, forcing it to be loaded into a contiguous block of address space -void KRDataBlock::lock() +void Block::lock() { if (m_lockCount == 0) { @@ -503,7 +506,7 @@ void KRDataBlock::lock() } assert(m_mmapData != NULL); #elif defined(__APPLE__) || defined(ANDROID) - //fprintf(stderr, "KRDataBlock::lock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount); + //fprintf(stderr, "Block::lock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount); // Round m_data_offset down to the next memory page, as required by mmap if ((m_mmapData = mmap(0, m_data_size + alignment_offset, m_bReadOnly ? PROT_READ : PROT_WRITE, MAP_SHARED, m_fdPackFile, m_data_offset - alignment_offset)) == (caddr_t)-1) { @@ -551,7 +554,7 @@ m_lockCount++; } // Unlock the memory, releasing the address space for use by other allocations -void KRDataBlock::unlock() +void Block::unlock() { // We expect that the data block was previously locked assertLocked(); @@ -571,7 +574,7 @@ void KRDataBlock::unlock() free(m_data); m_data = NULL; } else { - //fprintf(stderr, "KRDataBlock::unlock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount); + //fprintf(stderr, "Block::unlock - \"%s\" (%i)\n", m_fileOwnerDataBlock->m_fileName.c_str(), m_lockCount); #if defined(_WIN32) || defined(_WIN64) if (m_mmapData != NULL) { UnmapViewOfFile(m_mmapData); @@ -599,7 +602,9 @@ m_lockCount--; } // Assert if not locked -void KRDataBlock::assertLocked() +void Block::assertLocked() { assert(m_lockCount > 0); } + +} // namespace mimir diff --git a/kraken/KRDataBlock.h b/kraken/block.h similarity index 91% rename from kraken/KRDataBlock.h rename to kraken/block.h index 1bc0db8..3f7a9e0 100755 --- a/kraken/KRDataBlock.h +++ b/kraken/block.h @@ -1,5 +1,5 @@ // -// KRDataBlock.h +// block.h // Kraken Engine // // Copyright 2023 Kearwood Gilbert. All rights reserved. @@ -31,20 +31,20 @@ #pragma once +#include #include "KREngine-common.h" #if defined(_WIN32) || defined(_WIN64) #include #endif -#define KRENGINE_MIN_MMAP 32768 - -class KRDataBlock +namespace mimir { +class Block { public: - KRDataBlock(); - KRDataBlock(void* data, size_t size); - ~KRDataBlock(); + Block(); + Block(void* data, size_t size); + ~Block(); // Encapsulate a pointer. Note - The pointer will not be free'ed bool load(void* data, size_t size); @@ -55,14 +55,14 @@ public: // Save the data to a file. bool save(const std::string& path); - // Create a KRDataBlock encapsulating a sub-region of this block. The caller is responsible to free the object. - KRDataBlock* getSubBlock(int start, int length); + // Create a Block encapsulating a sub-region of this block. The caller is responsible to free the object. + Block* getSubBlock(int start, int length); // Append data to the end of the block, increasing the size of the block and making it read-write. void append(void* data, size_t size); // Append data to the end of the block, increasing the size of the block and making it read-write. - void append(KRDataBlock& data); + void append(Block& data); // Append string to the end of the block, increasing the size of the block and making it read-write. The null terminating character is included void append(const std::string& s); @@ -111,7 +111,7 @@ private: #endif std::string m_fileName; - KRDataBlock* m_fileOwnerDataBlock; + Block* m_fileOwnerDataBlock; void* m_mmapData; // For malloc'ed objects: @@ -127,3 +127,5 @@ private: void assertLocked(); }; +} // namespace mimir +