Streamlined resource handling in Pre-Stream with KRResourceBinding::submitRequest

kraken/nodes/KRCamera.cpp

@@ -70,6 +70,8 @@ KrResult KRCamera::update(const KrNodeInfo* nodeInfo)
 
 KRCamera::KRCamera(KRScene& scene, std::string name)
   : KRNode(scene, name)
+  , m_fontTexture(KRTextureBinding("font", KRTexture::TEXTURE_USAGE_UI))
+  , m_skyBox(KRTextureBinding(KRTexture::TEXTURE_USAGE_SKY_CUBE))
 {
   m_surfaceHandle = KR_NULL_HANDLE;
   m_last_frame_start = 0;
@@ -148,16 +150,8 @@ void KRCamera::preStream(const KRViewport& viewport, std::list<KRResourceRequest
 {
   KRNode::preStream(viewport, resourceRequests);
 
-  m_skyBox.bind(&getContext());
+  m_skyBox.submitRequest(&getContext(), resourceRequests);
-  m_fontTexture.bind(&getContext());
+  m_fontTexture.submitRequest(&getContext(), resourceRequests);
-
-  if (m_skyBox.isBound()) {
-    resourceRequests.emplace_back(m_skyBox.get(), KRTexture::TEXTURE_USAGE_SKY_CUBE);
-  }
-
-  if (m_fontTexture.isBound()) {
-    resourceRequests.emplace_back(m_fontTexture.get(), KRTexture::TEXTURE_USAGE_UI);
-  }
 }
 
 void KRCamera::render(KRNode::RenderInfo& ri)

kraken/nodes/KRLight.cpp

@@ -63,7 +63,9 @@ void KRLight::InitNodeInfo(KrNodeInfo* nodeInfo)
   nodeInfo->light.light_shafts = true;
 }
 
-KRLight::KRLight(KRScene& scene, std::string name) : KRNode(scene, name)
+KRLight::KRLight(KRScene& scene, std::string name)
+  : KRNode(scene, name)
+  , m_flareTexture(KRTextureBinding(KRTexture::TEXTURE_USAGE_LIGHT_FLARE))
 {
   m_intensity = 1.0f;
   m_dust_particle_intensity = 1.0f;
@@ -226,11 +228,7 @@ void KRLight::preStream(const KRViewport& viewport, std::list<KRResourceRequest>
   KRNode::preStream(viewport, resourceRequests);
 
   // Pre-stream sprites, even if the alpha is zero
-  m_flareTexture.bind(&getContext());
+  m_flareTexture.submitRequest(&getContext(), resourceRequests);
-
-  if (m_flareTexture.isBound()) {
-    resourceRequests.emplace_back(m_flareTexture.get(), KRTexture::TEXTURE_USAGE_LIGHT_FLARE);
-  }
 }
 
 void KRLight::render(RenderInfo& ri)

kraken/nodes/KRModel.cpp

@@ -56,6 +56,7 @@ void KRModel::InitNodeInfo(KrNodeInfo* nodeInfo)
 
 KRModel::KRModel(KRScene& scene, std::string name)
   : KRNode(scene, name)
+  , m_lightMap(KRTexture::TEXTURE_USAGE_LIGHT_MAP)
   , m_min_lod_coverage(0.0f)
   , m_receivesShadow(true)
   , m_faces_camera(false)
@@ -82,8 +83,8 @@ KRModel::KRModel(KRScene& scene, std::string name)
 
 KRModel::KRModel(KRScene& scene, std::string instance_name, std::string model_name[kMeshLODCount], std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color, float rim_power)
   : KRNode(scene, instance_name)
+  , m_lightMap(light_map, KRTexture::TEXTURE_USAGE_LIGHT_MAP)
 {
-  m_lightMap.set(light_map);
   for (int lod = 0; lod < kMeshLODCount; lod++) {
     m_meshes[lod].set(model_name[lod]);
   }
@@ -312,17 +313,10 @@ void KRModel::preStream(const KRViewport& viewport, std::list<KRResourceRequest>
   float lod_coverage = viewport.coverage(getBounds());
 
   for (int i = 0; i < kMeshLODCount; i++) {
-    if (m_meshes[i].isBound()) {
+    m_meshes[i].submitRequest(&getContext(), resourceRequests, lod_coverage);
-      m_meshes[i].get()->preStream(resourceRequests, lod_coverage);
-      resourceRequests.emplace_back(m_meshes[i].get(), 0, lod_coverage);
-    }
   }
 
-  m_lightMap.bind(&getContext());
+  m_lightMap.submitRequest(&getContext(), resourceRequests);
-
-  if (m_lightMap.isBound()) {
-    resourceRequests.emplace_back(m_lightMap.get(), KRTexture::TEXTURE_USAGE_LIGHT_MAP);
-  }
 }
 
 

kraken/nodes/KRSprite.cpp

@@ -54,7 +54,9 @@ void KRSprite::InitNodeInfo(KrNodeInfo* nodeInfo)
   nodeInfo->sprite.texture = -1;
 }
 
-KRSprite::KRSprite(KRScene& scene, std::string name) : KRNode(scene, name)
+KRSprite::KRSprite(KRScene& scene, std::string name)
+  : KRNode(scene, name)
+  , m_spriteTexture(KRTextureBinding(KRTexture::TEXTURE_USAGE_SPRITE))
 {
   m_spriteAlpha = 1.0f;
 }
@@ -117,11 +119,7 @@ void KRSprite::preStream(const KRViewport& viewport, std::list<KRResourceRequest
   KRNode::preStream(viewport, resourceRequests);
 
   // Pre-stream sprites, even if the alpha is zero
-  m_spriteTexture.bind(&getContext());
+  m_spriteTexture.submitRequest(&getContext(), resourceRequests);
-
-  if (m_spriteTexture.isBound()) {
-    resourceRequests.emplace_back(m_spriteTexture.get(), KRTexture::TEXTURE_USAGE_SPRITE);
-  }
 }
 
 void KRSprite::render(RenderInfo& ri)

kraken/resources/KRResourceBinding.cpp

@@ -33,14 +33,16 @@
 #include "KRResourceBinding.h"
 #include "KRContext.h"
 
-KRResourceBinding::KRResourceBinding(const std::string& name)
+KRResourceBinding::KRResourceBinding(const std::string& name, uint64_t usage)
   : m_name(name)
   , m_resource(nullptr)
+  , m_usage(usage)
 {
 }
 
-KRResourceBinding::KRResourceBinding()
+KRResourceBinding::KRResourceBinding(uint64_t usage)
   : m_resource(nullptr)
+  , m_usage(usage)
 {
 }
 
@@ -50,6 +52,14 @@ KRResourceBinding::~KRResourceBinding()
   m_name.clear();
 }
 
+void KRResourceBinding::submitRequest(KRContext* context, std::list<KRResourceRequest>& resourceRequests, float lodCoverage)
+{
+  bind(context);
+  if (isBound()) {
+    resourceRequests.emplace_back(get(), m_usage, lodCoverage);
+  }
+}
+
 KRResource* KRResourceBinding::get()
 {
   return m_resource;

kraken/resources/KRResourceBinding.h

@@ -33,6 +33,7 @@
 
 #include "KREngine-common.h"
 #include "KRContextObject.h"
+#include "KRResourceRequest.h"
 
 class KRResource;
 class KRContext;
@@ -40,10 +41,12 @@ class KRContext;
 class KRResourceBinding
 {
 public:
-  KRResourceBinding(const std::string& name);
+  KRResourceBinding(const std::string& name, uint64_t usage);
-  KRResourceBinding();
+  KRResourceBinding(uint64_t usage);
   ~KRResourceBinding();
 
+  void submitRequest(KRContext* context, std::list<KRResourceRequest>& resourceRequests, float lodCoverage = 0.f);
+
   KRResource* get();
   void set(KRResource* resource);
   void set(const std::string& name);
@@ -58,4 +61,5 @@ public:
 protected:
   KRResource* m_resource;
   std::string m_name;
+  uint64_t m_usage;
 };

kraken/resources/KRResourceRequest.h

@@ -37,14 +37,15 @@ class KRResource;
 class KRResourceRequest
 {
 public:
-  KRResourceRequest(KRResource* resource, uint32_t usage, float lodCoverage = 0.0f)
+  KRResourceRequest(KRResource* resource, uint64_t usage, float lodCoverage = 0.0f)
     : resource(resource)
     , usage(usage)
     , coverage(static_cast<uint8_t>(KRCLAMP(lodCoverage / 1.0f * 255.f, 0, 255.f)))
   {
 
   }
+
   KRResource* resource;
-  unsigned int usage : 24;
+  uint64_t usage : 56;
   uint8_t coverage : 8;
 };

kraken/resources/audio/KRAudioSampleBinding.cpp

@@ -36,6 +36,17 @@
 #include "KRAudioSample.h"
 #include "KRAudioManager.h"
 
+KRAudioSampleBinding::KRAudioSampleBinding()
+  : KRResourceBinding(0)
+{
+
+}
+
+KRAudioSampleBinding::KRAudioSampleBinding(const std::string& name)
+  : KRResourceBinding(name, 0)
+{
+
+}
 
 KRAudioSample* KRAudioSampleBinding::get()
 {

kraken/resources/audio/KRAudioSampleBinding.h

@@ -39,6 +39,8 @@ class KRAudioSample;
 class KRAudioSampleBinding : public KRResourceBinding
 {
 public:
+  KRAudioSampleBinding();
+  KRAudioSampleBinding(const std::string& name);
   KRAudioSample* get();
 
   bool bind(KRContext* context) override final;

kraken/resources/material/KRMaterial.cpp

@@ -40,7 +40,14 @@
 using namespace mimir;
 using namespace hydra;
 
-KRMaterial::KRMaterial(KRContext& context, const char* szName) : KRResource(context, szName)
+KRMaterial::KRMaterial(KRContext& context, const char* szName)
+  : KRResource(context, szName)
+  , m_ambientMap(KRTextureBinding(KRTexture::TEXTURE_USAGE_AMBIENT_MAP))
+  , m_diffuseMap(KRTexture::TEXTURE_USAGE_DIFFUSE_MAP)
+  , m_specularMap(KRTexture::TEXTURE_USAGE_NORMAL_MAP)
+  , m_reflectionMap(KRTexture::TEXTURE_USAGE_REFLECTION_MAP)
+  , m_reflectionCube(KRTexture::TEXTURE_USAGE_REFECTION_CUBE)
+  , m_normalMap(KRTexture::TEXTURE_USAGE_NORMAL_MAP)
 {
   m_name = szName;
   m_ambientColor = Vector3::Zero();
@@ -230,40 +237,18 @@ bool KRMaterial::isTransparent()
 
 void KRMaterial::preStream(std::list<KRResourceRequest>& resourceRequests, float lodCoverage)
 {
-  getTextures();
+  m_ambientMap.submitRequest(&getContext(), resourceRequests, lodCoverage);
-
+  m_diffuseMap.submitRequest(&getContext(), resourceRequests, lodCoverage);
-  if (m_ambientMap.isBound()) {
+  m_normalMap.submitRequest(&getContext(), resourceRequests, lodCoverage);
-    resourceRequests.emplace_back(m_ambientMap.get(), KRTexture::TEXTURE_USAGE_AMBIENT_MAP);
+  m_specularMap.submitRequest(&getContext(), resourceRequests, lodCoverage);
+  m_reflectionMap.submitRequest(&getContext(), resourceRequests, lodCoverage);
+  m_reflectionCube.submitRequest(&getContext(), resourceRequests, lodCoverage);
 }
 
-  if (m_diffuseMap.isBound()) {
-    resourceRequests.emplace_back(m_diffuseMap.get(), KRTexture::TEXTURE_USAGE_DIFFUSE_MAP);
-  }
-
-  if (m_normalMap.isBound()) {
-    resourceRequests.emplace_back(m_normalMap.get(), KRTexture::TEXTURE_USAGE_NORMAL_MAP);
-  }
-
-  if (m_specularMap.isBound()) {
-    resourceRequests.emplace_back(m_specularMap.get(), KRTexture::TEXTURE_USAGE_SPECULAR_MAP);
-  }
-
-  if (m_reflectionMap.isBound()) {
-    resourceRequests.emplace_back(m_reflectionMap.get(), KRTexture::TEXTURE_USAGE_REFLECTION_MAP);
-  }
-
-  if (m_reflectionCube.isBound()) {
-    resourceRequests.emplace_back(m_reflectionCube.get(), KRTexture::TEXTURE_USAGE_REFECTION_CUBE);
-  }
-}
-
-
 kraken_stream_level KRMaterial::getStreamLevel()
 {
   kraken_stream_level stream_level = kraken_stream_level::STREAM_LEVEL_IN_HQ;
 
-  getTextures();
-
   if (m_ambientMap.isBound()) {
     stream_level = KRMIN(stream_level, m_ambientMap.get()->getStreamLevel());
   }
@@ -291,22 +276,10 @@ kraken_stream_level KRMaterial::getStreamLevel()
   return stream_level;
 }
 
-void KRMaterial::getTextures()
-{
-  m_ambientMap.bind(&getContext());
-  m_diffuseMap.bind(&getContext());
-  m_normalMap.bind(&getContext());
-  m_specularMap.bind(&getContext());
-  m_reflectionMap.bind(&getContext());
-  m_reflectionCube.bind(&getContext());
-}
-
 void KRMaterial::bind(KRNode::RenderInfo& ri, ModelFormat modelFormat, __uint32_t vertexAttributes, CullMode cullMode, const std::vector<KRBone*>& bones, const std::vector<Matrix4>& bind_poses, const Matrix4& matModel, KRTexture* pLightMap, float lod_coverage)
 {
   bool bLightMap = pLightMap && ri.camera->settings.bEnableLightMap;
 
-  getTextures();
-
   Vector2 default_scale = Vector2::One();
   Vector2 default_offset = Vector2::Zero();
 

kraken/resources/material/KRMaterial.h

@@ -134,8 +134,6 @@ private:
 
   alpha_mode_type m_alpha_mode;
 
-  void getTextures();
-
 private:
   bool getShaderValue(ShaderValue value, float* output) const final;
   bool getShaderValue(ShaderValue value, hydra::Vector2* output) const final;

kraken/resources/mesh/KRMeshBinding.cpp

@@ -34,6 +34,18 @@
 #include "KRMesh.h"
 #include "KRMeshBinding.h"
 
+KRMeshBinding::KRMeshBinding()
+  : KRResourceBinding(0)
+{
+
+}
+
+KRMeshBinding::KRMeshBinding(const std::string& name)
+  : KRResourceBinding(name, 0)
+{
+
+}
+
 KRMesh* KRMeshBinding::get()
 {
   return static_cast<KRMesh*>(m_resource);

kraken/resources/mesh/KRMeshBinding.h

@@ -39,6 +39,8 @@ class KRMesh;
 class KRMeshBinding : public KRResourceBinding
 {
 public:
+  KRMeshBinding();
+  KRMeshBinding(const std::string& name);
   KRMesh* get();
 
   bool bind(KRContext* context) override final;

kraken/resources/texture/KRTextureBinding.cpp

@@ -34,6 +34,18 @@
 #include "KRTexture.h"
 #include "KRTextureBinding.h"
 
+KRTextureBinding::KRTextureBinding(const std::string& name, KRTexture::texture_usage_t usage)
+  : KRResourceBinding(name, static_cast<uint64_t>(usage))
+{
+
+}
+
+KRTextureBinding::KRTextureBinding(KRTexture::texture_usage_t usage)
+  : KRResourceBinding(static_cast<uint64_t>(usage))
+{
+
+}
+
 KRTexture* KRTextureBinding::get()
 {
   return static_cast<KRTexture*>(m_resource);

kraken/resources/texture/KRTextureBinding.h

@@ -33,12 +33,15 @@
 
 #include "KREngine-common.h"
 #include "resources/KRResourceBinding.h"
+#include "resources/texture/KRTexture.h"
 
 class KRTexture;
 
 class KRTextureBinding : public KRResourceBinding
 {
 public:
+  KRTextureBinding(const std::string& name, KRTexture::texture_usage_t usage);
+  KRTextureBinding(KRTexture::texture_usage_t usage);
   KRTexture* get();
 
   bool bind(KRContext* context) override final;