Implemented KrInitNodeInfo

kraken/KRAmbientZone.cpp

@@ -9,6 +9,16 @@
 #include "KRAmbientZone.h"
 #include "KRContext.h"
 
+/* static */
+void KRAmbientZone::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->ambient_zone.gain = 1.0f;
+  nodeInfo->ambient_zone.gradient = 0.25f;
+  nodeInfo->ambient_zone.pZoneName = nullptr;
+  nodeInfo->ambient_zone.sample = -1;
+}
+
 KRAmbientZone::KRAmbientZone(KRScene &scene, std::string name) : KRNode(scene, name)
 {
     m_ambient = "";

kraken/KRAmbientZone.h

@@ -15,6 +15,8 @@
 
 class KRAmbientZone : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRAmbientZone(KRScene &scene, std::string name);
     virtual ~KRAmbientZone();
     virtual std::string getElementName();

kraken/KRAudioSource.cpp

@@ -35,6 +35,22 @@
 #include "KRAudioSample.h"
 #include "KRAudioBuffer.h"
 
+/* static */
+void KRAudioSource::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->audio_source.enable_obstruction = true;
+  nodeInfo->audio_source.enable_occlusion = true;
+  nodeInfo->audio_source.gain = 1.0f;
+  nodeInfo->audio_source.is_3d = true;
+  nodeInfo->audio_source.looping = false;
+  nodeInfo->audio_source.pitch = 1.0f;
+  nodeInfo->audio_source.reference_distance = 1.0f;
+  nodeInfo->audio_source.reverb = 0.0f;
+  nodeInfo->audio_source.rolloff_factor = 2.0f;
+  nodeInfo->audio_source.sample = -1;
+}
+
 KRAudioSource::KRAudioSource(KRScene &scene, std::string name) : KRNode(scene, name)
 {
     m_currentBufferFrame = 0;

kraken/KRAudioSource.h

@@ -42,6 +42,8 @@ class KRAudioBuffer;
 
 class KRAudioSource : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRAudioSource(KRScene &scene, std::string name);
     virtual ~KRAudioSource();
     virtual std::string getElementName();

kraken/KRBone.cpp

@@ -9,6 +9,13 @@
 #include "KRBone.h"
 #include "KRContext.h"
 
+/* static */
+void KRBone::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  // No additional members
+}
+
 KRBone::KRBone(KRScene &scene, std::string name) : KRNode(scene, name)
 {
     setScaleCompensation(true);

kraken/KRBone.h

@@ -15,6 +15,8 @@
 
 class KRBone : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRBone(KRScene &scene, std::string name);
     virtual ~KRBone();
     virtual std::string getElementName();

kraken/KRCamera.cpp

@@ -34,6 +34,13 @@
 #include "KRStockGeometry.h"
 #include "KRDirectionalLight.h"
 
+/* static */
+void KRCamera::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->camera.skybox_texture = -1;
+}
+
 KRCamera::KRCamera(KRScene &scene, std::string name) : KRNode(scene, name) {
     m_last_frame_start = 0;
     

kraken/KRCamera.h

@@ -49,6 +49,7 @@ class KRViewport;
 
 class KRCamera : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     KRCamera(KRScene &scene, std::string name);
     virtual ~KRCamera();
 

kraken/KRCollider.cpp

@@ -34,6 +34,14 @@
 #include "KRContext.h"
 #include "KRMesh.h"
 
+/* static */
+void KRCollider::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->collider.audio_occlusion = 1.0f;
+  nodeInfo->collider.layer_mask = 65535;
+  nodeInfo->collider.mesh = -1;
+}
 
 KRCollider::KRCollider(KRScene &scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion) : KRNode(scene, collider_name) {
     m_model_name = model_name;

kraken/KRCollider.h

@@ -49,6 +49,8 @@
 class KRCollider : public KRNode {
     
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRCollider(KRScene &scene, std::string collider_name, std::string model_name, unsigned int layer_mask, float audio_occlusion);
     virtual ~KRCollider();
     

kraken/KRDirectionalLight.cpp

@@ -14,6 +14,13 @@
 #include "assert.h"
 #include "KRStockGeometry.h"
 
+/* static */
+void KRDirectionalLight::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRLight::InitNodeInfo(nodeInfo);
+  // No additional members
+}
+
 KRDirectionalLight::KRDirectionalLight(KRScene &scene, std::string name) : KRLight(scene, name)
 {
 

kraken/KRDirectionalLight.h

@@ -14,6 +14,7 @@
 class KRDirectionalLight : public KRLight {
     
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     
     KRDirectionalLight(KRScene &scene, std::string name);
     virtual ~KRDirectionalLight();

kraken/KRLODGroup.cpp

@@ -10,6 +10,17 @@
 #include "KRLODSet.h"
 #include "KRContext.h"
 
+/* static */
+void KRLODGroup::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->lod_group.min_distance = 0.0f;
+  nodeInfo->lod_group.max_distance = 0.0f;
+  nodeInfo->lod_group.reference_min = Vector3::Zero();
+  nodeInfo->lod_group.reference_max = Vector3::Zero();
+  nodeInfo->lod_group.use_world_units = true;
+}
+
 KRLODGroup::KRLODGroup(KRScene &scene, std::string name) : KRNode(scene, name)
 {
     m_min_distance = 0.0f;

kraken/KRLODGroup.h

@@ -14,6 +14,7 @@
 
 class KRLODGroup : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     KRLODGroup(KRScene &scene, std::string name);
     virtual ~KRLODGroup();
     virtual std::string getElementName();

kraken/KRLODSet.cpp

@@ -10,6 +10,13 @@
 #include "KRLODGroup.h"
 #include "KRContext.h"
 
+/* static */
+void KRLODSet::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  // No additional members
+}
+
 KRLODSet::KRLODSet(KRScene &scene, std::string name) : KRNode(scene, name)
 {
 

kraken/KRLODSet.h

@@ -16,6 +16,7 @@ class KRLODGroup;
 
 class KRLODSet : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     KRLODSet(KRScene &scene, std::string name);
     virtual ~KRLODSet();
     virtual std::string getElementName();

kraken/KRLight.cpp

@@ -21,6 +21,22 @@
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
 
+/* static */
+void KRLight::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->light.casts_shadow = true;
+  nodeInfo->light.color = Vector3::One();
+  nodeInfo->light.decay_start = 0.0f;
+  nodeInfo->light.dust_particle_density = 0.1f;
+  nodeInfo->light.dust_particle_intensity = 1.0f;
+  nodeInfo->light.dust_particle_size = 1.0f;
+  nodeInfo->light.flare_occlusion_size = 0.05f;
+  nodeInfo->light.flare_size = 0.0f;
+  nodeInfo->light.flare_texture = -1;
+  nodeInfo->light.intensity = 1.0f;
+  nodeInfo->light.light_shafts = true;
+}
 
 KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name)
 {
@@ -35,7 +51,9 @@ KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name)
     m_light_shafts = true;
     m_dust_particle_density = 0.1f;
     m_dust_particle_size = 1.0f;
+    m_dust_particle_intensity = 1.0f;
     m_occlusionQuery = 0;
+    m_decayStart = 0;
     
     // Initialize shadow buffers
     m_cShadowBuffers = 0;

kraken/KRLight.h

@@ -23,7 +23,7 @@ static const float KRLIGHT_MIN_INFLUENCE = 0.15f; // 0.05f
 
 class KRLight : public KRNode {
 public:
-    
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     
     virtual ~KRLight();
     virtual std::string getElementName() = 0;

kraken/KRLocator.cpp

@@ -9,6 +9,13 @@
 #include "KRLocator.h"
 #include "KRContext.h"
 
+/* static */
+void KRLocator::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  // No additional members
+}
+
 KRLocator::KRLocator(KRScene &scene, std::string name) : KRNode(scene, name)
 {
  

kraken/KRLocator.h

@@ -15,6 +15,8 @@
 
 class KRLocator : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRLocator(KRScene &scene, std::string name);
     virtual ~KRLocator();
     virtual std::string getElementName();

kraken/KRModel.cpp

@@ -35,6 +35,19 @@
 #include "KRContext.h"
 #include "KRMesh.h"
 
+/* static */
+void KRModel::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->model.faces_camera = false;
+  nodeInfo->model.light_map_texture = -1;
+  nodeInfo->model.lod_min_coverage = 0.0f;
+  nodeInfo->model.mesh = -1;
+  nodeInfo->model.receives_shadow = true;
+  nodeInfo->model.rim_color = Vector3::Zero();
+  nodeInfo->model.rim_power = 0.0f;
+}
+
 KRModel::KRModel(KRScene &scene, std::string instance_name, std::string model_name, 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;
     m_pLightMap = NULL;

kraken/KRModel.h

@@ -47,6 +47,8 @@
 class KRModel : public KRNode {
     
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRModel(KRScene &scene, std::string instance_name, std::string model_name, std::string light_map, float lod_min_coverage, bool receives_shadow, bool faces_camera, Vector3 rim_color = Vector3::Zero(), float rim_power = 0.0f);
     virtual ~KRModel();
     

kraken/KRNode.cpp

@@ -25,6 +25,21 @@
 #include "KRReverbZone.h"
 #include "KRSprite.h"
 
+/* static */
+void KRNode::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  nodeInfo->pName = nullptr;
+  nodeInfo->translate = Vector3::Zero();
+  nodeInfo->scale = Vector3::One();
+  nodeInfo->rotate = Vector3::Zero();
+  nodeInfo->pre_rotate = Vector3::Zero();
+  nodeInfo->post_rotate = Vector3::Zero();
+  nodeInfo->rotate_offset = Vector3::Zero();
+  nodeInfo->scale_offset = Vector3::Zero();
+  nodeInfo->rotate_pivot = Vector3::Zero();
+  nodeInfo->scale_pivot = Vector3::Zero();
+}
+
 KRNode::KRNode(KRScene &scene, std::string name) : KRContextObject(scene.getContext())
 {
     m_name = name;

kraken/KRNode.h

@@ -60,10 +60,13 @@ public:
         LOD_VISIBILITY_VISIBLE
     };
 
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+    
     KRNode(KRScene &scene, std::string name);
     virtual ~KRNode();
     
     virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent);
+
     static KRNode *LoadXML(KRScene &scene, tinyxml2::XMLElement *e);
     virtual void loadXML(tinyxml2::XMLElement *e);
     

kraken/KRPointLight.cpp

@@ -13,6 +13,13 @@
 #include "KRContext.h"
 #include "KRStockGeometry.h"
 
+/* static */
+void KRPointLight::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRLight::InitNodeInfo(nodeInfo);
+  // No additional members
+}
+
 KRPointLight::KRPointLight(KRScene &scene, std::string name) : KRLight(scene, name)
 {
     m_sphereVertices = NULL;

kraken/KRPointLight.h

@@ -14,7 +14,7 @@
 class KRPointLight : public KRLight {
     
 public:
-    
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
     KRPointLight(KRScene &scene, std::string name);
     virtual ~KRPointLight();
     

kraken/KRReverbZone.cpp

@@ -9,6 +9,16 @@
 #include "KRReverbZone.h"
 #include "KRContext.h"
 
+/* static */
+void KRReverbZone::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->reverb_zone.gain = 1.0f;
+  nodeInfo->reverb_zone.gradient = 0.25f;
+  nodeInfo->reverb_zone.sample = -1;
+  nodeInfo->reverb_zone.pZoneName = nullptr;
+}
+
 KRReverbZone::KRReverbZone(KRScene &scene, std::string name) : KRNode(scene, name)
 {
     m_reverb = "";

kraken/KRReverbZone.h

@@ -15,6 +15,8 @@
 
 class KRReverbZone : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRReverbZone(KRScene &scene, std::string name);
     virtual ~KRReverbZone();
     virtual std::string getElementName();

kraken/KRSpotLight.cpp

@@ -9,8 +9,18 @@
 #include "KREngine-common.h"
 #include "KRSpotLight.h"
 
+/* static */
+void KRSpotLight::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRLight::InitNodeInfo(nodeInfo);
+  nodeInfo->light.spot.inner_angle = M_PI_4;
+  nodeInfo->light.spot.outer_angle = M_PI_2;
+}
+
 KRSpotLight::KRSpotLight(KRScene &scene, std::string name) : KRLight(scene, name)
 {
+  m_innerAngle = M_PI_4;
+  m_outerAngle = M_PI_2;
 }
 
 KRSpotLight::~KRSpotLight()

kraken/KRSpotLight.h

@@ -13,6 +13,8 @@
 
 class KRSpotLight : public KRLight {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRSpotLight(KRScene &scene, std::string name);
     virtual ~KRSpotLight();
     

kraken/KRSprite.cpp

@@ -21,6 +21,13 @@
 #include "KRSpotLight.h"
 #include "KRPointLight.h"
 
+/* static */
+void KRSprite::InitNodeInfo(KrNodeInfo* nodeInfo)
+{
+  KRNode::InitNodeInfo(nodeInfo);
+  nodeInfo->sprite.alpha = 1.0f;
+  nodeInfo->sprite.texture = -1;
+}
 
 KRSprite::KRSprite(KRScene &scene, std::string name) : KRNode(scene, name)
 {

kraken/KRSprite.h

@@ -15,6 +15,8 @@
 
 class KRSprite : public KRNode {
 public:
+    static void InitNodeInfo(KrNodeInfo* nodeInfo);
+
     KRSprite(KRScene &scene, std::string name);
     
     virtual ~KRSprite();

kraken/kraken.cpp

@@ -2,6 +2,22 @@
 
 #include "KRContext.h"
 #include "KRBundle.h"
+#include "hydra.h"
+#include "KRLODSet.h"
+#include "KRLODGroup.h"
+#include "KRPointLight.h"
+#include "KRDirectionalLight.h"
+#include "KRSpotLight.h"
+#include "KRSprite.h"
+#include "KRModel.h"
+#include "KRCollider.h"
+#include "KRBone.h"
+#include "KRLocator.h"
+#include "KRAudioSource.h"
+#include "KRAmbientZone.h"
+#include "KRReverbZone.h"
+
+using namespace kraken;
 
 namespace {
 
@@ -86,3 +102,58 @@ KrResult KrCreateScene(const KrCreateSceneInfo* pCreateSceneInfo)
   }
   return sContext->createScene(pCreateSceneInfo);
 }
+
+KrResult KrInitNodeInfo(KrNodeInfo* pNodeInfo, KrStructureType nodeType)
+{
+  pNodeInfo->sType = nodeType;
+  switch (nodeType) {
+  case KR_STRUCTURE_TYPE_NODE:
+    KRNode::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_CAMERA:
+    KRCamera::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_LOD_SET:
+    KRLODSet::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_LOD_GROUP:
+    KRLODGroup::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_POINT_LIGHT:
+    KRPointLight::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_DIRECTIONAL_LIGHT:
+    KRDirectionalLight::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_SPOT_LIGHT:
+    KRSpotLight::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_SPRITE:
+    KRSprite::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_MODEL:
+    KRModel::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_COLLIDER:
+    KRCollider::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_BONE:
+    KRBone::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_LOCATOR:
+    KRLocator::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_AUDIO_SOURCE:
+    KRAudioSource::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_AMBIENT_ZONE:
+    KRAmbientZone::InitNodeInfo(pNodeInfo);
+    break;
+  case KR_STRUCTURE_TYPE_NODE_REVERB_ZONE:
+    KRReverbZone::InitNodeInfo(pNodeInfo);
+    break;
+  default:
+    return KR_ERROR_INCORRECT_TYPE;
+  }
+  return KR_SUCCESS;
+}

kraken/public/kraken.h

@@ -76,6 +76,7 @@ typedef enum {
   KR_STRUCTURE_TYPE_NODE_AUDIO_SOURCE,
   KR_STRUCTURE_TYPE_NODE_AMBIENT_ZONE,
   KR_STRUCTURE_TYPE_NODE_REVERB_ZONE,
+  KR_STRUCTURE_TYPE_NODE_MAX_ENUM,
   
   KR_STRUCTURE_TYPE_MAX_ENUM         = 0x7FFFFFFF
 } KrStructureType;
@@ -146,58 +147,58 @@ typedef struct {
   kraken::Vector3 rotate_pivot;
   kraken::Vector3 scale_pivot;
   union {
-    struct node {
+    struct {
       // KR_STRUCTURE_TYPE_NODE
       // No additional members
-    };
+    } node;
-    struct camera {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_CAMERA
       KrResourceMapIndex skybox_texture;
-    };
+    } camera;
-    struct lod_set {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_LOD_SET
       // No additional members
-    };
+    } lod_set;
-    struct lod_group {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_LOD_GROUP
       float min_distance;
       float max_distance;
       kraken::Vector3 reference_min;
       kraken::Vector3 reference_max;
       bool use_world_units;
-    };
+    } lod_group;
-    struct light {
+    struct {
       kraken::Vector3 color;
       float intensity;
       float decay_start;
       float flare_size;
       float flare_occlusion_size;
-      KrResourceMapIndex flate_texture;
+      KrResourceMapIndex flare_texture;
       bool casts_shadow;
       bool light_shafts;
       float dust_particle_density;
       float dust_particle_size;
       float dust_particle_intensity;
-      struct point {
+      struct {
         // KR_STRUCTURE_TYPE_NODE_POINT_LIGHT
         // No additional members
-      };
+      } point;
-      struct directional {
+      struct {
         // KR_STRUCTURE_TYPE_NODE_DIRECTIONAL_LIGHT
         // No additional members
-      };
+      } directional;
-      struct spot {
+      struct {
         // KR_STRUCTURE_TYPE_NODE_SPOT_LIGHT
         float inner_angle;
         float outer_angle;
-      };
+      } spot;
-    };
+    } light;
-    struct sprite {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_SPRITE
       KrResourceMapIndex texture;
       float alpha;
-    };
+    } sprite;
-    struct model {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_MODEL
       float lod_min_coverage;
       bool receives_shadow;
@@ -206,22 +207,22 @@ typedef struct {
       kraken::Vector3 rim_color;
       KrResourceMapIndex mesh;
       KrResourceMapIndex light_map_texture;
-    };
+    } model;
-    struct collider {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_COLLIDER
       KrResourceMapIndex mesh;
       uint64_t layer_mask;
       float audio_occlusion;
-    };
+    } collider;
-    struct bone {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_BONE
       // No additional members
-    };
+    } bone;
-    struct locator {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_LOCATOR
       // No additional members
-    };
+    } locator;
-    struct audio_source {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_AUDIO_SOURCE
       KrResourceMapIndex sample;
       float gain;
@@ -233,21 +234,21 @@ typedef struct {
       float rolloff_factor;
       bool enable_obstruction;
       bool enable_occlusion;
-    };
+    } audio_source;
-    struct ambient_zone {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_AMBIENT_ZONE
       char* pZoneName;
       float gradient;
       float gain;
       KrResourceMapIndex sample;
-    };
+    } ambient_zone;
-    struct reverb_zone {
+    struct {
       // KR_STRUCTURE_TYPE_NODE_REVERB_ZONE
       char* pZoneName;
       float gradient;
       float gain;
       KrResourceMapIndex sample;
-    };
+    } reverb_zone;
   };
 } KrNodeInfo;
 
@@ -260,6 +261,7 @@ KrResult KrMapResource(const KrMapResourceInfo* pMapResourceInfo);
 KrResult KrUnmapResource(const KrUnmapResourceInfo* pUnmapResourceInfo);
 KrResult KrCreateBundle(const KrCreateBundleInfo* pCreateBundleInfo);
 KrResult KrMoveToBundle(const KrMoveToBundleInfo* pMoveToBundleInfo);
+KrResult KrInitNodeInfo(KrNodeInfo* pNodeInfo, KrStructureType nodeType);
 
 KrResult KrCreateScene(const KrCreateSceneInfo* pCreateSceneInfo);