BAM errors

panda/src/navigation/config_navigation.cxx

@@ -18,8 +18,9 @@
 #include "navMesh.h"
 #include "navMeshNode.h"
 #include "navMeshQuery.h"
+#include <iostream>
 
-#if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_RECASTDETOUR)
+#if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_NAVIGATION)
   #error Buildsystem error: BUILDING_NAVIGATION not defined
 #endif
 
@@ -41,12 +42,22 @@ ConfigVariableInt navigation_sample_config_variable
  */
 void
 init_libnavigation() {
-  NavMesh::init_type();
-  NavMeshNode::init_type();
+  
+  std::cout<<"\nCalled init_libnavigation\n";
   static bool initialized = false;
   if (initialized) {
     return;
   }
   initialized = true;
+  std::cout<<"\nCalling init_type\n";
+  NavMesh::init_type();
+  NavMeshNode::init_type();
+  
+  std::cout<<"\nCalling register_with_read_factory\n";
+  // Register factory functions for constructing objects from .bam files
+  NavMeshNode::register_with_read_factory();
+  NavMesh::register_with_read_factory();
+
+  
 }
 

panda/src/navigation/navMesh.cxx

@@ -35,7 +35,7 @@ bool NavMesh::init_nav_mesh() {
 	unsigned char *nav_data = 0;
   int nav_data_size = 0;
 
-  if (!dtCreateNavMeshData(&params, &nav_data, &nav_data_size)) {
+  if (!dtCreateNavMeshData(&_params, &nav_data, &nav_data_size)) {
     std::cout<<"\nCould not build Detour navmesh.\n";
     return false;
   }
@@ -63,6 +63,7 @@ bool NavMesh::init_nav_mesh() {
  */
 void NavMesh::
 register_with_read_factory() {
+  std::cout<<"\nCalled NavMesh::register_with_read_factory()\n";
   BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
 }
 
@@ -72,65 +73,65 @@ register_with_read_factory() {
  */
 void NavMesh::
 write_datagram(BamWriter *manager, Datagram &dg) {
-  NavMesh::write_datagram(manager, dg);
+  //NavMesh::write_datagram(manager, dg);
   
-  dg.add_int32(params.vertCount);
-  dg.add_int32(params.polyCount);
-  dg.add_int32(params.nvp);
-  dg.add_int32(params.detailVertsCount);
-  dg.add_int32(params.detailTriCount);
-  dg.add_float32(params.walkableHeight);
-  dg.add_float32(params.walkableRadius);
-  dg.add_float32(params.walkableClimb);
-  dg.add_float32(params.cs);
-  dg.add_float32(params.ch);
-  dg.add_bool(params.buildBvTree);
+  dg.add_int32(_params.vertCount);
+  dg.add_int32(_params.polyCount);
+  dg.add_int32(_params.nvp);
+  dg.add_int32(_params.detailVertsCount);
+  dg.add_int32(_params.detailTriCount);
+  dg.add_float32(_params.walkableHeight);
+  dg.add_float32(_params.walkableRadius);
+  dg.add_float32(_params.walkableClimb);
+  dg.add_float32(_params.cs);
+  dg.add_float32(_params.ch);
+  dg.add_bool(_params.buildBvTree);
 
   //the bmin and bmax values
   for(int i=0;i<3;i++) {
-    dg.add_float32(params.bmin[i]);
+    dg.add_float32(_params.bmin[i]);
   }
   for(int i=0;i<3;i++) {
-    dg.add_float32(params.bmax[i]);
+    dg.add_float32(_params.bmax[i]);
   }
   
   //POLYGON MESH ATTRIBUTES
 
   //the vertices
-  for(int i=0 ; i < (params.vertCount) * 3 ; i++) {
-    dg.add_uint16(params.verts[i]);
+  for(int i=0 ; i < (_params.vertCount) * 3 ; i++) {
+    dg.add_uint16(_params.verts[i]);
   }
 
   //the polygon data
-  for(int i=0 ; i < (params.polyCount) * 2 * (params.nvp) ;i++) {
-    dg.add_uint16(params.polys[i]);
+  for(int i=0 ; i < (_params.polyCount) * 2 * (_params.nvp) ;i++) {
+    dg.add_uint16(_params.polys[i]);
   }
 
   //the polygon flags
-  for(int i=0 ; i < params.polyCount ;i++) {
-    dg.add_uint16(params.polyFlags[i]);
+  for(int i=0 ; i < _params.polyCount ;i++) {
+    dg.add_uint16(_params.polyFlags[i]);
   }
 
   //the polygon area IDs
-  for(int i=0 ; i < params.polyCount ;i++) {
-    dg.add_uint8(params.polyAreas[i]);           
+  for(int i=0 ; i < _params.polyCount ;i++) {
+    dg.add_uint8(_params.polyAreas[i]);           
   }
   
   //POLYGON MESH DETAIL ATTRIBUTES
 
   //height detail sub-mesh data
-  for(int i=0 ; i < (params.polyCount) * 4 ;i++) {
-    dg.add_uint32(params.detailMeshes[i]);
+  for(int i=0 ; i < (_params.polyCount) * 4 ;i++) {
+    dg.add_uint32(_params.detailMeshes[i]);
   }
 
   //detail mesh vertices
-  for(int i=0 ; i < (params.detailVertsCount) * 3 ;i++) {
-    dg.add_float32(params.detailVerts[i]);
+  for(int i=0 ; i < (_params.detailVertsCount) * 3 ;i++) {
+    dg.add_float32(_params.detailVerts[i]);
   }
 
   //detail mesh vertices
-  for(int i=0 ; i < (params.detailTriCount) * 4 ;i++) {
-    dg.add_uint8(params.detailTris[i]);
+  for(int i=0 ; i < (_params.detailTriCount) * 4 ;i++) {
+    dg.add_uint8(_params.detailTris[i]);
   }
 
 }
@@ -158,7 +159,7 @@ make_from_bam(const FactoryParams &params) {
  */
 void NavMesh::
 fillin(DatagramIterator &scan, BamReader *manager) {
-  NavMesh::fillin(scan, manager);
+  //NavMesh::fillin(scan, manager);
   
   int vert_count = scan.get_int32();
   int poly_count = scan.get_int32();
@@ -220,36 +221,36 @@ fillin(DatagramIterator &scan, BamReader *manager) {
     detail_tris[i] = scan.get_uint8();
   }
 
-  memset(&(params), 0, sizeof(params));
-
-  params.verts = verts;
-  params.vertCount = vert_count;
-  params.polys = polys;
-  params.polyAreas = poly_areas;
-  params.polyFlags = poly_flags;
-  params.polyCount = poly_count;
-  params.nvp = nvp;
-  params.detailMeshes = detail_meshes;
-  params.detailVerts = detail_verts;
-  params.detailVertsCount = detail_vert_count;
-  params.detailTris = detail_tris;
-  params.detailTriCount = detail_tri_count;
-
-
-  params.walkableHeight = walkable_height;
-  params.walkableRadius = walkable_radius;
-  params.walkableClimb = walkable_climb;
-
-  params.bmin[0] = b_min[0];
-  params.bmin[1] = b_min[1];
-  params.bmin[2] = b_min[2];
-  params.bmax[0] = b_max[0];
-  params.bmax[1] = b_max[1];
-  params.bmax[2] = b_max[2];
+  memset(&(_params), 0, sizeof(_params));
+
+  _params.verts = verts;
+  _params.vertCount = vert_count;
+  _params.polys = polys;
+  _params.polyAreas = poly_areas;
+  _params.polyFlags = poly_flags;
+  _params.polyCount = poly_count;
+  _params.nvp = nvp;
+  _params.detailMeshes = detail_meshes;
+  _params.detailVerts = detail_verts;
+  _params.detailVertsCount = detail_vert_count;
+  _params.detailTris = detail_tris;
+  _params.detailTriCount = detail_tri_count;
+
+
+  _params.walkableHeight = walkable_height;
+  _params.walkableRadius = walkable_radius;
+  _params.walkableClimb = walkable_climb;
+
+  _params.bmin[0] = b_min[0];
+  _params.bmin[1] = b_min[1];
+  _params.bmin[2] = b_min[2];
+  _params.bmax[0] = b_max[0];
+  _params.bmax[1] = b_max[1];
+  _params.bmax[2] = b_max[2];
   
-  params.cs = cs;
-  params.ch = ch;
-  params.buildBvTree = build_bv_tree;
+  _params.cs = cs;
+  _params.ch = ch;
+  _params.buildBvTree = build_bv_tree;
 
   init_nav_mesh();
 

panda/src/navigation/navMesh.h

@@ -34,7 +34,7 @@ private:
 public:
   bool init_nav_mesh();
   dtNavMesh *get_nav_mesh() { return _nav_mesh; }
-  dtNavMeshCreateParams params;
+  dtNavMeshCreateParams _params;
   ~NavMesh();
   
 

panda/src/navigation/navMeshNode.cxx

@@ -13,6 +13,7 @@
 
 
 #include "navMeshNode.h"
+#include <iostream>
 
 TypeHandle NavMeshNode::_type_handle;
 
@@ -25,9 +26,7 @@ NavMeshNode::NavMeshNode(const std::string &name, PT(NavMesh) nav_mesh):
 NavMeshNode::NavMeshNode(const std::string &name):
  PandaNode(name) {}
 
-NavMeshNode::~NavMeshNode() {
-  
-}
+NavMeshNode::~NavMeshNode() {}
 
 
 /**
@@ -35,6 +34,8 @@ NavMeshNode::~NavMeshNode() {
  */
 void NavMeshNode::
 register_with_read_factory() {
+  std::cout<<"\nCalled NavMeshNode::register_with_read_factory()\n";
+  
   BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
 }
 
@@ -70,18 +71,18 @@ complete_pointers(TypedWritable **p_list, BamReader *manager) {
 //  * type BulletShape is encountered in the Bam file.  It should create the
 //  * BulletShape and extract its information from the file.
 //  */
-// TypedWritable *NavMeshNode::
-// make_from_bam(const FactoryParams &params) {
-//   string s = "FromBam"
-//   NavMeshNode *param = new NavMeshNode(s);
-//   DatagramIterator scan;
-//   BamReader *manager;
+TypedWritable *NavMeshNode::
+make_from_bam(const FactoryParams &params) {
+  string s = "FromBam"
+  NavMeshNode *param = new NavMeshNode(s);
+  DatagramIterator scan;
+  BamReader *manager;
 
-//   parse_params(params, scan, manager);
-//   param->fillin(scan, manager);
+  parse_params(params, scan, manager);
+  param->fillin(scan, manager);
 
-//   return param;
-// }
+  return param;
+}
 
 /**
  * This internal function is called by make_from_bam to read in all of the
@@ -90,12 +91,7 @@ complete_pointers(TypedWritable **p_list, BamReader *manager) {
 void NavMeshNode::
 fillin(DatagramIterator &scan, BamReader *manager) {
   PandaNode::fillin(scan, manager);
-
- 
-
   manager->read_pointer(scan);
-
-  
 }
 
 

panda/src/navigation/navMeshNode.h

@@ -25,6 +25,7 @@ class EXPCL_NAVIGATION NavMeshNode: public PandaNode
 {
 PUBLISHED:
   NavMeshNode(const std::string &name, PT(NavMesh) nav_mesh);
+  PT(NavMesh) get_navmesh() { return _nav_mesh; }
 private:
   PT(NavMesh) _nav_mesh;
 

panda/src/navigation/navMeshQuery.cxx

@@ -21,15 +21,15 @@ NavMeshQuery::NavMeshQuery():
   _nav_query = dtAllocNavMeshQuery();
 }
 
+/**
+ * This function forms and initialises query object. No need to call set_nav_query() 
+ * after calling this constructor.
+ */
 NavMeshQuery::NavMeshQuery(PT(NavMesh) nav_mesh):
   _nav_query(0) {
   
   _nav_query = dtAllocNavMeshQuery();
-  dtStatus status = _nav_query->init(nav_mesh->get_nav_mesh(), 2048);
-
-  if (dtStatusFailed(status)) {
-    std::cout<<"\nCannot set nav query!\n";
-  }
+  set_nav_query(nav_mesh);
 
 }
 
@@ -37,9 +37,14 @@ NavMeshQuery::~NavMeshQuery() {
   dtFreeNavMeshQuery(_nav_query);
 }
 
+/**
+ * This function initializes the query object.
+ * It must be the first function called after construction, before other functions are used
+ * and can be used multiple times.
+ */
 bool NavMeshQuery::set_nav_query(PT(NavMesh) nav_mesh) {
-
-  dtStatus status = _nav_query->init(nav_mesh->get_nav_mesh(), 2048);
+  const int MAX_NODES = 2048;
+  dtStatus status = _nav_query->init(nav_mesh->get_nav_mesh(), MAX_NODES);
 
   if (dtStatusFailed(status)) {
     std::cout<<"\nCannot set nav query!\n";
@@ -49,6 +54,10 @@ bool NavMeshQuery::set_nav_query(PT(NavMesh) nav_mesh) {
   return true;
 }
 
+/**
+ * Given an input point, this function finds 
+ * the nearest point to it lying over the navigation mesh surface.
+ */
 bool NavMeshQuery::nearest_point(LPoint3 &p) {
   if (!_nav_query) {
     std::cout << "\nNavMeshQuery not created!\n";
@@ -74,6 +83,10 @@ bool NavMeshQuery::nearest_point(LPoint3 &p) {
   return true;
 }
 
+/**
+ * This function takes two input points as start and end points.
+ * It returns an array of points that form a path from start to end point.
+ */
 PTA_LVecBase3 NavMeshQuery::find_path(LPoint3 &start, LPoint3 &end) {
 
   PTA_LVecBase3 path_array;
@@ -136,6 +149,10 @@ PTA_LVecBase3 NavMeshQuery::find_path(LPoint3 &start, LPoint3 &end) {
   return path_array;
 }
 
+/**
+ * This function takes two input points as start and end points.
+ * It returns an array of points that form a straight path from start to end point.
+ */
 PTA_LVecBase3 NavMeshQuery::find_straight_path(LPoint3 &start, LPoint3 &end, int opt) {
 
   PTA_LVecBase3 straight_path_array;

panda/src/navigation/p3navigation_composite1.cxx

@@ -1,3 +1,5 @@
 #include "navMesh.cxx"
-#include "navMeshNode.cxx"
 #include "navMeshQuery.cxx"
+#include "config_navigation.cxx"
+#include "navMeshNode.cxx"
+

panda/src/navmeshgen/config_navmeshgen.cxx

@@ -17,7 +17,7 @@
 #include "dconfig.h"
 #include "navMeshBuilder.h"
 
-#if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_RECASTDETOUR)
+#if !defined(CPPPARSER) && !defined(LINK_ALL_STATIC) && !defined(BUILDING_NAVMESHGEN)
   #error Buildsystem error: BUILDING_NAVMESHGEN not defined
 #endif
 

panda/src/navmeshgen/navMeshBuilder.cxx

@@ -26,6 +26,7 @@
 #include "geomVertexWriter.h"
 #include "geomTrifans.h"
 
+#include "string_utils.h"
 
 #ifdef WIN32
 # define snprintf _snprintf
@@ -49,9 +50,9 @@ NavMeshBuilder::NavMeshBuilder() :
   _vert_count(0),
   _tri_count(0) {
   index_temp = 0;
-  vertex_map.clear();
-  vertex_vector.clear();
-  face_vector.clear();
+  _vertex_map.clear();
+  _vertex_vector.clear();
+  _face_vector.clear();
   _ctx = new rcContext;
   reset_common_settings();
   //_crowd = dtAllocCrowd();
@@ -151,21 +152,21 @@ void NavMeshBuilder::process_primitive(const GeomPrimitive *orig_prim, const Geo
       int a = prim->get_vertex(s);
       vertex.set_row(a);
       v = vertex.get_data3();
-      a = vertex_map[v];
+      a = _vertex_map[v];
 
       int b = prim->get_vertex(s + 1);
       vertex.set_row(b);
       v = vertex.get_data3();
-      b = vertex_map[v];
+      b = _vertex_map[v];
 
       int c = prim->get_vertex(s + 2);
       vertex.set_row(c);
       v = vertex.get_data3();
-      c = vertex_map[v];
+      c = _vertex_map[v];
 
 
       LVector3 xvx = { float(a + 1), float(b + 1), float(c + 1) };
-      face_vector.push_back(xvx);
+      _face_vector.push_back(xvx);
       add_triangle(a, b, c, tcap);
 
     }
@@ -175,20 +176,20 @@ void NavMeshBuilder::process_primitive(const GeomPrimitive *orig_prim, const Geo
         int a = prim->get_vertex(s);
         vertex.set_row(a);
         v = vertex.get_data3();
-        a = vertex_map[v];
+        a = _vertex_map[v];
 
         int b = prim->get_vertex(i - 1);
         vertex.set_row(b);
         v = vertex.get_data3();
-        b = vertex_map[v];
+        b = _vertex_map[v];
 
         int c = prim->get_vertex(i);
         vertex.set_row(c);
         v = vertex.get_data3();
-        c = vertex_map[v];
+        c = _vertex_map[v];
 
         LVector3 xvx = { float(a + 1), float(b + 1), float(c + 1) };
-        face_vector.push_back(xvx);
+        _face_vector.push_back(xvx);
         add_triangle(a, b, c, tcap);
 
       }
@@ -196,7 +197,7 @@ void NavMeshBuilder::process_primitive(const GeomPrimitive *orig_prim, const Geo
     else continue;
 
   }
-  return;
+  
 }
 
 void NavMeshBuilder::process_vertex_data(const GeomVertexData *vdata, int &vcap) {
@@ -209,14 +210,14 @@ void NavMeshBuilder::process_vertex_data(const GeomVertexData *vdata, int &vcap)
     x = v[0];
     y = v[1];
     z = v[2];
-    if (vertex_map.find(v) == vertex_map.end()) {
+    if (_vertex_map.find(v) == _vertex_map.end()) {
       add_vertex(x, z, -y, vcap); //if input model is originally z-up
       //add_vertex(x, y, z, vcap); //if input model is originally y-up
 
-      //vertex_map[v] = index_temp++;
+      //_vertex_map[v] = index_temp++;
       LVector3 xvx = { v[0],v[2],-v[1] };
-      vertex_map[v] = index_temp++;
-      vertex_vector.push_back(v);
+      _vertex_map[v] = index_temp++;
+      _vertex_vector.push_back(v);
     }
 
   }
@@ -274,15 +275,15 @@ void NavMeshBuilder::cleanup()
 }
 
 void NavMeshBuilder::set_partition_type(std::string p) {
-  if (p == "watershed" || p == "Watershed" || p == "WATERSHED") {
+  if (downcase(p) == "watershed") {
     _partition_type = SAMPLE_PARTITION_WATERSHED;
     return;
   }
-  if (p == "monotone" || p == "Monotone" || p == "MONOTONE") {
+  if (downcase(p) == "monotone") {
     _partition_type = SAMPLE_PARTITION_MONOTONE;
     return;
   }
-  if (p == "layer" || p == "Layer" || p == "LAYER") {
+  if (downcase(p) == "layer") {
     _partition_type = SAMPLE_PARTITION_LAYERS;
     return;
   }
@@ -614,29 +615,29 @@ PT(NavMesh) NavMeshBuilder::build() {
 
     _nav_mesh_obj = new NavMesh(_nav_mesh);
     
-    memset(&(_nav_mesh_obj->params), 0, sizeof(_nav_mesh_obj->params));
-    _nav_mesh_obj->params.verts = _pmesh->verts;
-    _nav_mesh_obj->params.vertCount = _pmesh->nverts;
-    _nav_mesh_obj->params.polys = _pmesh->polys;
-    _nav_mesh_obj->params.polyAreas = _pmesh->areas;
-    _nav_mesh_obj->params.polyFlags = _pmesh->flags;
-    _nav_mesh_obj->params.polyCount = _pmesh->npolys;
-    _nav_mesh_obj->params.nvp = _pmesh->nvp;
-    _nav_mesh_obj->params.detailMeshes = _dmesh->meshes;
-    _nav_mesh_obj->params.detailVerts = _dmesh->verts;
-    _nav_mesh_obj->params.detailVertsCount = _dmesh->nverts;
-    _nav_mesh_obj->params.detailTris = _dmesh->tris;
-    _nav_mesh_obj->params.detailTriCount = _dmesh->ntris;
-
-
-    _nav_mesh_obj->params.walkableHeight = _agent_height;
-    _nav_mesh_obj->params.walkableRadius = _agent_radius;
-    _nav_mesh_obj->params.walkableClimb = _agent_max_climb;
-    rcVcopy(_nav_mesh_obj->params.bmin, _pmesh->bmin);
-    rcVcopy(_nav_mesh_obj->params.bmax, _pmesh->bmax);
-    _nav_mesh_obj->params.cs = _cfg.cs;
-    _nav_mesh_obj->params.ch = _cfg.ch;
-    _nav_mesh_obj->params.buildBvTree = true;
+    memset(&(_nav_mesh_obj->_params), 0, sizeof(_nav_mesh_obj->_params));
+    _nav_mesh_obj->_params.verts = _pmesh->verts;
+    _nav_mesh_obj->_params.vertCount = _pmesh->nverts;
+    _nav_mesh_obj->_params.polys = _pmesh->polys;
+    _nav_mesh_obj->_params.polyAreas = _pmesh->areas;
+    _nav_mesh_obj->_params.polyFlags = _pmesh->flags;
+    _nav_mesh_obj->_params.polyCount = _pmesh->npolys;
+    _nav_mesh_obj->_params.nvp = _pmesh->nvp;
+    _nav_mesh_obj->_params.detailMeshes = _dmesh->meshes;
+    _nav_mesh_obj->_params.detailVerts = _dmesh->verts;
+    _nav_mesh_obj->_params.detailVertsCount = _dmesh->nverts;
+    _nav_mesh_obj->_params.detailTris = _dmesh->tris;
+    _nav_mesh_obj->_params.detailTriCount = _dmesh->ntris;
+
+
+    _nav_mesh_obj->_params.walkableHeight = _agent_height;
+    _nav_mesh_obj->_params.walkableRadius = _agent_radius;
+    _nav_mesh_obj->_params.walkableClimb = _agent_max_climb;
+    rcVcopy(_nav_mesh_obj->_params.bmin, _pmesh->bmin);
+    rcVcopy(_nav_mesh_obj->_params.bmax, _pmesh->bmax);
+    _nav_mesh_obj->_params.cs = _cfg.cs;
+    _nav_mesh_obj->_params.ch = _cfg.ch;
+    _nav_mesh_obj->_params.buildBvTree = true;
 
     _nav_mesh_obj->init_nav_mesh();
 

panda/src/navmeshgen/navMeshBuilder.h

@@ -85,7 +85,6 @@ PUBLISHED:
   int get_pmesh_poly_count() { return _pmesh->npolys; }
   int get_pmesh_max_poly_count() { return _pmesh->maxpolys; }
 private:
-  std::string _filename;
   float _scale;
   float *_verts;
   int *_tris;
@@ -102,8 +101,8 @@ private:
   void process_vertex_data(const GeomVertexData *vdata, int &vcap);
   void process_primitive(const GeomPrimitive *orig_prim, const GeomVertexData *vdata, int &tcap);
 
-  std::map<LVector3, int> vertex_map;
-  std::vector<LVector3> vertex_vector, face_vector;
+  std::map<LVector3, int> _vertex_map;
+  std::vector<LVector3> _vertex_vector, _face_vector;
   bool _loaded;
   int index_temp;
 protected:
@@ -154,12 +153,11 @@ public:
 
   virtual void collect_settings(struct BuildSettings &settings);
  
-  unsigned char getNavMeshDrawFlags() const { return _nav_mesh_draw_flags; }
+  unsigned char get_nav_mesh_draw_flags() const { return _nav_mesh_draw_flags; }
   const float *get_verts() const { return _verts; }
   const float *get_normals() const { return _normals; }
   const int *get_tris() const { return _tris; }
   
-  const std::string& get_file_name() const { return _filename; }
   bool loaded_geom() { return _loaded; }
   
 

panda/src/navmeshgen/p3navmeshgen_composite1.cxx

@@ -1 +1,2 @@
 #include "navMeshBuilder.cxx"
+#include "config_navmeshgen.cxx"