per-displayregion tracking of cull, draw times

panda/src/cull/cullBinBackToFront.I

@@ -23,8 +23,9 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinBackToFront::
-CullBinBackToFront(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_back_to_front, gsg)
+CullBinBackToFront(const string &name, GraphicsStateGuardianBase *gsg,
+                   const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_back_to_front, gsg, draw_region_pcollector)
 {
 }
 

panda/src/cull/cullBinBackToFront.cxx

@@ -48,8 +48,9 @@ CullBinBackToFront::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinBackToFront::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinBackToFront(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinBackToFront(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinBackToFront.h

@@ -37,10 +37,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullBinBackToFront : public CullBin {
 public:
-  INLINE CullBinBackToFront(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinBackToFront(const string &name, 
+                            GraphicsStateGuardianBase *gsg,
+                            const PStatCollector &draw_region_pcollector);
   virtual ~CullBinBackToFront();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
   
 
   virtual void add_object(CullableObject *object, Thread *current_thread);

panda/src/cull/cullBinFixed.I

@@ -23,8 +23,9 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinFixed::
-CullBinFixed(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_fixed, gsg)
+CullBinFixed(const string &name, GraphicsStateGuardianBase *gsg,
+             const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_fixed, gsg, draw_region_pcollector)
 {
 }
 

panda/src/cull/cullBinFixed.cxx

@@ -48,8 +48,9 @@ CullBinFixed::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinFixed::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinFixed(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinFixed(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinFixed.h

@@ -40,10 +40,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullBinFixed : public CullBin {
 public:
-  INLINE CullBinFixed(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinFixed(const string &name, 
+                      GraphicsStateGuardianBase *gsg,
+                      const PStatCollector &draw_region_pcollector);
   virtual ~CullBinFixed();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
 
   virtual void add_object(CullableObject *object, Thread *current_thread);
   virtual void finish_cull(SceneSetup *scene_setup, Thread *current_thread);

panda/src/cull/cullBinFrontToBack.I

@@ -23,8 +23,9 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinFrontToBack::
-CullBinFrontToBack(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_front_to_back, gsg)
+CullBinFrontToBack(const string &name, GraphicsStateGuardianBase *gsg,
+                   const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_front_to_back, gsg, draw_region_pcollector)
 {
 }
 

panda/src/cull/cullBinFrontToBack.cxx

@@ -48,8 +48,9 @@ CullBinFrontToBack::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinFrontToBack::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinFrontToBack(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinFrontToBack(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinFrontToBack.h

@@ -38,10 +38,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullBinFrontToBack : public CullBin {
 public:
-  INLINE CullBinFrontToBack(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinFrontToBack(const string &name, 
+                            GraphicsStateGuardianBase *gsg,
+                            const PStatCollector &draw_region_pcollector);
   virtual ~CullBinFrontToBack();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
 
   virtual void add_object(CullableObject *object, Thread *current_thread);
   virtual void finish_cull(SceneSetup *scene_setup, Thread *current_thread);

panda/src/cull/cullBinOcclusionTest.I

@@ -43,8 +43,9 @@ CullBinOcclusionTest(const CullBinOcclusionTest &copy) :
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinOcclusionTest::
-CullBinOcclusionTest(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_occlusion_test, gsg),
+CullBinOcclusionTest(const string &name, GraphicsStateGuardianBase *gsg,
+                     const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_occlusion_test, gsg, draw_region_pcollector),
   _draw_occlusion_pcollector(_draw_this_pcollector, "Occlusion")
 {
   nassertv(_gsg->get_supports_occlusion_query());

panda/src/cull/cullBinOcclusionTest.cxx

@@ -84,8 +84,9 @@ CullBinOcclusionTest::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinOcclusionTest::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinOcclusionTest(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinOcclusionTest(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinOcclusionTest.h

@@ -51,10 +51,14 @@ class EXPCL_PANDA CullBinOcclusionTest : public CullBin {
 protected:
   INLINE CullBinOcclusionTest(const CullBinOcclusionTest &copy);
 public:
-  INLINE CullBinOcclusionTest(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinOcclusionTest(const string &name, 
+                              GraphicsStateGuardianBase *gsg,
+                              const PStatCollector &draw_region_pcollector);
   virtual ~CullBinOcclusionTest();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
   virtual PT(CullBin) make_next() const;
 
   virtual void add_object(CullableObject *object, Thread *current_thread);

panda/src/cull/cullBinStateSorted.I

@@ -23,8 +23,9 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinStateSorted::
-CullBinStateSorted(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_state_sorted, gsg)
+CullBinStateSorted(const string &name, GraphicsStateGuardianBase *gsg,
+                   const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_state_sorted, gsg, draw_region_pcollector)
 {
 }
 

panda/src/cull/cullBinStateSorted.cxx

@@ -47,8 +47,9 @@ CullBinStateSorted::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinStateSorted::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinStateSorted(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinStateSorted(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinStateSorted.h

@@ -42,10 +42,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullBinStateSorted : public CullBin {
 public:
-  INLINE CullBinStateSorted(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinStateSorted(const string &name, 
+                            GraphicsStateGuardianBase *gsg,
+                            const PStatCollector &draw_region_pcollector);
   virtual ~CullBinStateSorted();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
 
   virtual void add_object(CullableObject *object, Thread *current_thread);
   virtual void finish_cull(SceneSetup *scene_setup, Thread *current_thread);

panda/src/cull/cullBinUnsorted.I

@@ -23,7 +23,8 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullBinUnsorted::
-CullBinUnsorted(const string &name, GraphicsStateGuardianBase *gsg) :
-  CullBin(name, BT_unsorted, gsg)
+CullBinUnsorted(const string &name, GraphicsStateGuardianBase *gsg,
+                const PStatCollector &draw_region_pcollector) :
+  CullBin(name, BT_unsorted, gsg, draw_region_pcollector)
 {
 }

panda/src/cull/cullBinUnsorted.cxx

@@ -44,8 +44,9 @@ CullBinUnsorted::
 //  Description: Factory constructor for passing to the CullBinManager.
 ////////////////////////////////////////////////////////////////////
 CullBin *CullBinUnsorted::
-make_bin(const string &name, GraphicsStateGuardianBase *gsg) {
-  return new CullBinUnsorted(name, gsg);
+make_bin(const string &name, GraphicsStateGuardianBase *gsg,
+         const PStatCollector &draw_region_pcollector) {
+  return new CullBinUnsorted(name, gsg, draw_region_pcollector);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/cull/cullBinUnsorted.h

@@ -33,10 +33,14 @@
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullBinUnsorted : public CullBin {
 public:
-  INLINE CullBinUnsorted(const string &name, GraphicsStateGuardianBase *gsg);
+  INLINE CullBinUnsorted(const string &name, 
+                         GraphicsStateGuardianBase *gsg,
+                         const PStatCollector &draw_region_pcollector);
   ~CullBinUnsorted();
 
-  static CullBin *make_bin(const string &name, GraphicsStateGuardianBase *gsg);
+  static CullBin *make_bin(const string &name, 
+                           GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
 
   virtual void add_object(CullableObject *object, Thread *current_thread);
   virtual void draw(Thread *current_thread);

panda/src/display/displayRegion.I

@@ -342,6 +342,28 @@ get_scene_setup(Thread *current_thread) const {
   return cdata->_scene_setup;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: DisplayRegion::get_cull_region_pcollector
+//       Access: Public
+//  Description: Returns a PStatCollector for timing the cull
+//               operation for just this DisplayRegion.
+////////////////////////////////////////////////////////////////////
+INLINE PStatCollector &DisplayRegion::
+get_cull_region_pcollector() {
+  return _cull_region_pcollector;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: DisplayRegion::get_draw_region_pcollector
+//       Access: Public
+//  Description: Returns a PStatCollector for timing the draw
+//               operation for just this DisplayRegion.
+////////////////////////////////////////////////////////////////////
+INLINE PStatCollector &DisplayRegion::
+get_draw_region_pcollector() {
+  return _draw_region_pcollector;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: DisplayRegion::CDataCull::Constructor
 //       Access: Public

panda/src/display/displayRegion.cxx

@@ -34,7 +34,9 @@ TypeHandle DisplayRegion::_type_handle;
 DisplayRegion::
 DisplayRegion(GraphicsOutput *window) :
   _window(window),
-  _clear_depth_between_eyes(true)
+  _clear_depth_between_eyes(true),
+  _cull_region_pcollector("Cull:Invalid"),
+  _draw_region_pcollector("Draw:Invalid")
 {
   _draw_buffer_type = window->get_draw_buffer_type();
   compute_pixels_all_stages();
@@ -48,7 +50,9 @@ DisplayRegion(GraphicsOutput *window) :
 DisplayRegion::
 DisplayRegion(GraphicsOutput *window, float l, float r, float b, float t) :
   _window(window),
-  _clear_depth_between_eyes(true)
+  _clear_depth_between_eyes(true),
+  _cull_region_pcollector("Cull:Invalid"),
+  _draw_region_pcollector("Draw:Invalid")
 {
   _draw_buffer_type = window->get_draw_buffer_type();
   set_dimensions(l, r, b, t);
@@ -61,7 +65,10 @@ DisplayRegion(GraphicsOutput *window, float l, float r, float b, float t) :
 //  Description:
 ////////////////////////////////////////////////////////////////////
 DisplayRegion::
-DisplayRegion(const DisplayRegion&) {
+DisplayRegion(const DisplayRegion&) : 
+  _cull_region_pcollector("Cull:Invalid"),
+  _draw_region_pcollector("Draw:Invalid")
+{
   nassertv(false);
 }
 
@@ -549,6 +556,30 @@ do_compute_pixels(int x_size, int y_size, CData *cdata) {
   }
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: DisplayRegion::set_active_index
+//       Access: Private
+//  Description: This is called by GraphicsOutput to indicate that the
+//               index of this DisplayRegion within the window's list
+//               of active DisplayRegions might have changed.  The
+//               index number will be -1 if the DisplayRegion is not
+//               active.
+//
+//               This is primarily intended only for updating the
+//               PStatCollector name appropriately.
+////////////////////////////////////////////////////////////////////
+void DisplayRegion::
+set_active_index(int index) {
+#ifdef DO_PSTATS
+  ostringstream strm;
+  strm << "dr_" << index;
+  string name = strm.str();
+
+  _cull_region_pcollector = PStatCollector(_window->get_cull_window_pcollector(), name);
+  _draw_region_pcollector = PStatCollector(_window->get_draw_window_pcollector(), name);
+#endif  // DO_PSTATS
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: DisplayRegion::CData::Constructor
 //       Access: Public

panda/src/display/displayRegion.h

@@ -36,6 +36,7 @@
 #include "lens.h"
 #include "deletedChain.h"
 #include "plist.h"
+#include "pStatCollector.h"
 
 class GraphicsOutput;
 class GraphicsPipe;
@@ -124,11 +125,15 @@ public:
   INLINE CullResult *get_cull_result(Thread *current_thread) const;
   INLINE SceneSetup *get_scene_setup(Thread *current_thread) const;
 
+  INLINE PStatCollector &get_cull_region_pcollector();
+  INLINE PStatCollector &get_draw_region_pcollector();
+
 private:
   class CData;
 
   void win_display_regions_changed();
   void do_compute_pixels(int x_size, int y_size, CData *cdata);
+  void set_active_index(int index);
 
   // The associated window is a permanent property of the
   // DisplayRegion.  It doesn't need to be cycled.
@@ -198,6 +203,9 @@ private:
   typedef CycleDataReader<CDataCull> CDCullReader;
   typedef CycleDataWriter<CDataCull> CDCullWriter;
 
+  PStatCollector _cull_region_pcollector;
+  PStatCollector _draw_region_pcollector;
+
 public:
   static TypeHandle get_class_type() {
     return _type_handle;

panda/src/display/graphicsEngine.cxx

@@ -1063,6 +1063,7 @@ cull_to_bins(const GraphicsEngine::Windows &wlist, Thread *current_thread) {
   for (wi = wlist.begin(); wi != wlist.end(); ++wi) {
     GraphicsOutput *win = (*wi);
     if (win->is_active() && win->get_gsg()->is_active()) {
+      PStatTimer timer(win->get_cull_window_pcollector(), current_thread);
       int num_display_regions = win->get_num_active_display_regions();
       for (int i = 0; i < num_display_regions; ++i) {
         DisplayRegion *dr = win->get_active_display_region(i);
@@ -1121,7 +1122,7 @@ cull_to_bins(GraphicsOutput *win, DisplayRegion *dr, Thread *current_thread) {
     if (cull_result != (CullResult *)NULL) {
       cull_result = cull_result->make_next();
     } else {
-      cull_result = new CullResult(gsg);
+      cull_result = new CullResult(gsg, dr->get_draw_region_pcollector());
     }
     DisplayRegionPipelineReader dr_reader(dr, current_thread);
     scene_setup = setup_scene(gsg, &dr_reader);
@@ -1155,6 +1156,7 @@ draw_bins(const GraphicsEngine::Windows &wlist, Thread *current_thread) {
   for (wi = wlist.begin(); wi != wlist.end(); ++wi) {
     GraphicsOutput *win = (*wi);
     if (win->is_active() && win->get_gsg()->is_active()) {
+      PStatTimer timer(win->get_draw_window_pcollector(), current_thread);
       if (win->begin_frame(GraphicsOutput::FM_render, current_thread)) {
         win->clear(current_thread);
       
@@ -1433,6 +1435,8 @@ setup_scene(GraphicsStateGuardian *gsg, DisplayRegionPipelineReader *dr) {
 void GraphicsEngine::
 do_cull(CullHandler *cull_handler, SceneSetup *scene_setup,
         GraphicsStateGuardian *gsg, Thread *current_thread) {
+  PStatTimer timer(scene_setup->get_display_region()->get_cull_region_pcollector(), current_thread);
+
   CullTraverser trav(gsg, current_thread);
   trav.set_cull_handler(cull_handler);
   trav.set_depth_offset_decals(depth_offset_decals && gsg->depth_offset_decals());
@@ -1473,7 +1477,7 @@ void GraphicsEngine::
 do_draw(CullResult *cull_result, SceneSetup *scene_setup,
         GraphicsOutput *win, DisplayRegion *dr, Thread *current_thread) {
   // Statistics
-  PStatTimer timer(_draw_pcollector, current_thread);
+  PStatTimer timer(dr->get_draw_region_pcollector(), current_thread);
 
   DisplayRegionPipelineReader *dr_reader = 
     new DisplayRegionPipelineReader(dr, current_thread);

panda/src/display/graphicsOutput.I

@@ -526,6 +526,28 @@ win_display_regions_changed() {
   _display_regions_stale = true;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: GraphicsOutput::get_cull_window_pcollector
+//       Access: Public
+//  Description: Returns a PStatCollector for timing the cull
+//               operation for just this GraphicsOutput.
+////////////////////////////////////////////////////////////////////
+INLINE PStatCollector &GraphicsOutput::
+get_cull_window_pcollector() {
+  return _cull_window_pcollector;
+}
+
+////////////////////////////////////////////////////////////////////
+//     Function: GraphicsOutput::get_draw_window_pcollector
+//       Access: Public
+//  Description: Returns a PStatCollector for timing the draw
+//               operation for just this GraphicsOutput.
+////////////////////////////////////////////////////////////////////
+INLINE PStatCollector &GraphicsOutput::
+get_draw_window_pcollector() {
+  return _draw_window_pcollector;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: GraphicsOutput::begin_frame_spam
 //       Access: Public

panda/src/display/graphicsOutput.cxx

@@ -42,6 +42,8 @@ TypeHandle GraphicsOutput::_type_handle;
 
 PStatCollector GraphicsOutput::_make_current_pcollector("Draw:Make current");
 PStatCollector GraphicsOutput::_copy_texture_pcollector("Draw:Copy texture");
+PStatCollector GraphicsOutput::_cull_pcollector("Cull");
+PStatCollector GraphicsOutput::_draw_pcollector("Draw");
 
 struct CubeFaceDef {
   CubeFaceDef(const char *name, const LPoint3f &look_at, const LVector3f &up) :
@@ -75,7 +77,9 @@ GraphicsOutput(GraphicsPipe *pipe,
                int x_size, int y_size, int flags,
                GraphicsStateGuardian *gsg,
                GraphicsOutput *host) :
-  _lock("GraphicsOutput")
+  _lock("GraphicsOutput"),
+  _cull_window_pcollector(_cull_pcollector, name),
+  _draw_window_pcollector(_draw_pcollector, name)
 {
 #ifdef DO_MEMORY_USAGE
   MemoryUsage::update_type(this, this);
@@ -154,7 +158,10 @@ GraphicsOutput(GraphicsPipe *pipe,
 //  Description:
 ////////////////////////////////////////////////////////////////////
 GraphicsOutput::
-GraphicsOutput(const GraphicsOutput &) {
+GraphicsOutput(const GraphicsOutput &) :
+  _cull_window_pcollector(_cull_pcollector, "Invalid"),
+  _draw_window_pcollector(_draw_pcollector, "Invalid")
+{
   nassertv(false);
 }
 
@@ -1183,6 +1190,7 @@ do_determine_display_regions() {
   _active_display_regions.clear();
   _active_display_regions.reserve(_total_display_regions.size());
 
+  int index = 0;
   TotalDisplayRegions::const_iterator dri;
   for (dri = _total_display_regions.begin();
        dri != _total_display_regions.end();
@@ -1190,6 +1198,9 @@ do_determine_display_regions() {
     DisplayRegion *display_region = (*dri);
     if (display_region->is_active()) {
       _active_display_regions.push_back(display_region);
+      display_region->set_active_index(index);
+    } else {
+      display_region->set_active_index(-1);
     }
   }
 

panda/src/display/graphicsOutput.h

@@ -233,6 +233,9 @@ public:
   // called by the GraphicsEngine.
   virtual void process_events();
 
+  INLINE PStatCollector &get_cull_window_pcollector();
+  INLINE PStatCollector &get_draw_window_pcollector();
+
 protected:
 
   void prepare_for_deletion();
@@ -311,6 +314,10 @@ protected:
 
   static PStatCollector _make_current_pcollector;
   static PStatCollector _copy_texture_pcollector;
+  static PStatCollector _cull_pcollector;
+  static PStatCollector _draw_pcollector;
+  PStatCollector _cull_window_pcollector;
+  PStatCollector _draw_window_pcollector;
   
 public:
   static TypeHandle get_class_type() {

panda/src/pgraph/cullBin.I

@@ -40,12 +40,13 @@ CullBin(const CullBin &copy) :
 ////////////////////////////////////////////////////////////////////
 INLINE CullBin::
 CullBin(const string &name, CullBin::BinType bin_type,
-        GraphicsStateGuardianBase *gsg) : 
+        GraphicsStateGuardianBase *gsg,
+        const PStatCollector &draw_region_pcollector) :
   _name(name),
   _bin_type(bin_type),
   _gsg(gsg),
   _cull_this_pcollector(_cull_bin_pcollector, name),
-  _draw_this_pcollector(_draw_bin_pcollector, name)
+  _draw_this_pcollector(draw_region_pcollector, name)
 {
   check_flash_color();
 }

panda/src/pgraph/cullBin.cxx

@@ -20,7 +20,6 @@
 #include "config_pgraph.h"
 
 PStatCollector CullBin::_cull_bin_pcollector("Cull:Sort");
-PStatCollector CullBin::_draw_bin_pcollector("Draw:Bins");
 
 TypeHandle CullBin::_type_handle;
 

panda/src/pgraph/cullBin.h

@@ -46,7 +46,8 @@ protected:
   INLINE CullBin(const CullBin &copy);
 public:
   INLINE CullBin(const string &name, BinType bin_type,
-                 GraphicsStateGuardianBase *gsg);
+                 GraphicsStateGuardianBase *gsg,
+                 const PStatCollector &draw_region_pcollector);
   virtual ~CullBin();
 
   INLINE const string &get_name() const;
@@ -74,7 +75,6 @@ protected:
   Colorf _flash_color;
 
   static PStatCollector _cull_bin_pcollector;
-  static PStatCollector _draw_bin_pcollector;
   PStatCollector _cull_this_pcollector;
   PStatCollector _draw_this_pcollector;
 

panda/src/pgraph/cullBinManager.cxx

@@ -212,7 +212,8 @@ get_global_ptr() {
 //               brand new CullBin object of the appropriate type.
 ////////////////////////////////////////////////////////////////////
 PT(CullBin) CullBinManager::
-make_new_bin(int bin_index, GraphicsStateGuardianBase *gsg) {
+make_new_bin(int bin_index, GraphicsStateGuardianBase *gsg,
+             const PStatCollector &draw_region_pcollector) {
   nassertr(bin_index >= 0 && bin_index < (int)_bin_definitions.size(), NULL);
   nassertr(_bin_definitions[bin_index]._in_use, NULL);
   string name = get_bin_name(bin_index);
@@ -221,7 +222,7 @@ make_new_bin(int bin_index, GraphicsStateGuardianBase *gsg) {
   BinConstructors::const_iterator ci = _bin_constructors.find(type);
   if (ci != _bin_constructors.end()) {
     BinConstructor *constructor = (*ci).second;
-    return constructor(name, gsg);
+    return constructor(name, gsg, draw_region_pcollector);
   }
 
   // Hmm, unknown (or unregistered) bin type.

panda/src/pgraph/cullBinManager.h

@@ -26,6 +26,7 @@
 #include "pvector.h"
 #include "pmap.h"
 #include "vector_int.h"
+#include "pStatCollector.h"
 
 class CullResult;
 class GraphicsStateGuardianBase;
@@ -73,12 +74,15 @@ PUBLISHED:
 
 public:
   // This interface is only intended to be used by CullResult.
-  PT(CullBin) make_new_bin(int bin_index, GraphicsStateGuardianBase *gsg);
+  PT(CullBin) make_new_bin(int bin_index, GraphicsStateGuardianBase *gsg,
+                           const PStatCollector &draw_region_pcollector);
 
   // This defines the factory interface for defining constructors to
   // bin types (the implementations are in the cull directory, not
   // here in pgraph, so we can't call the constructors directly).
-  typedef CullBin *BinConstructor(const string &name, GraphicsStateGuardianBase *gsg);
+  typedef CullBin *BinConstructor(const string &name, 
+                                  GraphicsStateGuardianBase *gsg,
+                                  const PStatCollector &draw_region_pcollector);
 
   void register_bin_type(BinType type, BinConstructor *constructor);
 

panda/src/pgraph/cullResult.I

@@ -23,8 +23,10 @@
 //  Description: 
 ////////////////////////////////////////////////////////////////////
 INLINE CullResult::
-CullResult(GraphicsStateGuardianBase *gsg) :
-  _gsg(gsg)
+CullResult(GraphicsStateGuardianBase *gsg,
+           const PStatCollector &draw_region_pcollector) :
+  _gsg(gsg),
+  _draw_region_pcollector(draw_region_pcollector)
 {
 }
 

panda/src/pgraph/cullResult.cxx

@@ -66,7 +66,7 @@ static const double bin_color_flash_rate = 1.0;  // 1 state change per second
 ////////////////////////////////////////////////////////////////////
 PT(CullResult) CullResult::
 make_next() const {
-  PT(CullResult) new_result = new CullResult(_gsg);
+  PT(CullResult) new_result = new CullResult(_gsg, _draw_region_pcollector);
   new_result->_bins.reserve(_bins.size());
 
   CullBinManager *bin_manager = CullBinManager::get_global_ptr();
@@ -283,7 +283,8 @@ bin_removed(int bin_index) {
 CullBin *CullResult::
 make_new_bin(int bin_index) {
   CullBinManager *bin_manager = CullBinManager::get_global_ptr();
-  PT(CullBin) bin = bin_manager->make_new_bin(bin_index, _gsg);
+  PT(CullBin) bin = bin_manager->make_new_bin(bin_index, _gsg,
+                                              _draw_region_pcollector);
   if (bin != (CullBin *)NULL) {
     // Now store it in the vector.
     while (bin_index >= (int)_bins.size()) {

panda/src/pgraph/cullResult.h

@@ -51,7 +51,8 @@ class SceneSetup;
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA CullResult : public ReferenceCount {
 public:
-  INLINE CullResult(GraphicsStateGuardianBase *gsg);
+  INLINE CullResult(GraphicsStateGuardianBase *gsg,
+                    const PStatCollector &draw_region_pcollector);
   INLINE ~CullResult();
 
   PT(CullResult) make_next() const;
@@ -77,6 +78,7 @@ private:
   static CPT(RenderState) get_dual_opaque_state();
 
   GraphicsStateGuardianBase *_gsg;
+  PStatCollector _draw_region_pcollector;
 
   typedef pvector< PT(CullBin) > Bins;
   Bins _bins;

panda/src/pstatclient/pStatProperties.cxx

@@ -145,7 +145,6 @@ static TimeCollectorProperties time_properties[] = {
   { 1, "Draw:Flip",                        { 1.0, 0.6, 0.3 } },
   { 1, "Draw:Flip:Begin",                  { 0.3, 0.3, 0.9 } },
   { 1, "Draw:Flip:End",                    { 0.9, 0.3, 0.6 } },
-  { 1, "Draw:Bins",                        { 0.3, 0.6, 0.0 } },
   { 0, "Draw:Transfer data",               { 0.8, 0.0, 0.6 } },
   { 0, "Draw:Transfer data:Vertex buffer", { 0.0, 0.1, 0.9 } },
   { 0, "Draw:Transfer data:Index buffer",  { 0.1, 0.9, 0.0 } },