compute _net_transform, not _modelview_transform, at each node of cull traversal

panda/src/collide/collisionNode.cxx

@@ -250,8 +250,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
       if (node != (PandaNode *)NULL) {
         CullTraverserData next_data(data, node);
 
-        next_data._modelview_transform = 
-          next_data._modelview_transform->compose(transform);
+        next_data._net_transform = 
+          next_data._net_transform->compose(transform);
         next_data._state = get_last_pos_state();
         trav->traverse(next_data);
       }

panda/src/collide/collisionVisualizer.cxx

@@ -135,7 +135,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
     // whatever transforms were above the CollisionVisualizer node; it
     // always renders its objects according to their appropriate net
     // transform.
-    xform_data._modelview_transform = trav->get_world_transform();
+    xform_data._net_transform = TransformState::make_identity();
     xform_data.apply_transform_and_state(trav, net_transform, 
                                          RenderState::make_empty(),
                                          RenderEffects::make_empty(),
@@ -212,7 +212,9 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
           geom->add_primitive(points);
             
           CullableObject *object = 
-            new CullableObject(geom, point_state, xform_data._modelview_transform);
+            new CullableObject(geom, point_state, 
+                               xform_data.get_net_transform(trav),
+                               xform_data.get_modelview_transform(trav));
           
           trav->get_cull_handler()->record_object(object, trav);
         }
@@ -240,7 +242,9 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
           geom->add_primitive(lines);
           
           CullableObject *object = 
-            new CullableObject(geom, empty_state, xform_data._modelview_transform);
+            new CullableObject(geom, empty_state, 
+                               xform_data.get_net_transform(trav),
+                               xform_data.get_modelview_transform(trav));
           
           trav->get_cull_handler()->record_object(object, trav);
         }

panda/src/display/graphicsEngine.cxx

@@ -529,6 +529,13 @@ render_frame() {
   }
 #endif
 
+  ClockObject *global_clock = ClockObject::get_global_clock();
+
+  if (display_cat.is_spam()) {
+    display_cat.spam()
+      << "render_frame() - frame " << global_clock->get_frame_count() << "\n";
+  }
+
   // We hold the GraphicsEngine mutex while we wait for all of the
   // threads.  Doing this puts us at risk for deadlock if any of the
   // threads tries to call any methods on the GraphicsEngine.  So
@@ -621,7 +628,6 @@ render_frame() {
   }
 #endif  // THREADED_PIPELINE
 
-  ClockObject *global_clock = ClockObject::get_global_clock();
   global_clock->tick();
   if (global_clock->check_errors()) {
     throw_event("clock_error");

panda/src/parametrics/ropeNode.cxx

@@ -362,7 +362,8 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
   CPT(RenderState) state = data._state->add_attrib(thick);
   
   CullableObject *object = new CullableObject(geom, state,
-                                              data._modelview_transform);
+                                              data.get_net_transform(trav),
+                                              data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(object, trav);
 }
 
@@ -404,7 +405,8 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
   geom->add_primitive(strip);
   
   CullableObject *object = new CullableObject(geom, data._state,
-                                              data._modelview_transform);
+                                              data.get_net_transform(trav),
+                                              data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(object, trav);
 }
 
@@ -421,11 +423,11 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
 void RopeNode::
 render_billboard(CullTraverser *trav, CullTraverserData &data, 
                  NurbsCurveResult *result) const {
-  const TransformState *net_transform = data._modelview_transform;
+  const TransformState *modelview_transform = data.get_modelview_transform(trav);
   const TransformState *camera_transform = trav->get_camera_transform();
 
   CPT(TransformState) rel_transform =
-    net_transform->invert_compose(camera_transform);
+    modelview_transform->invert_compose(camera_transform);
   LVector3f camera_vec = LVector3f::forward() * rel_transform->get_mat();
 
   CurveSegments curve_segments;
@@ -453,7 +455,8 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
   geom->add_primitive(strip);
   
   CullableObject *object = new CullableObject(geom, data._state,
-                                              data._modelview_transform);
+                                              data.get_net_transform(trav),
+                                              data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(object, trav);
 }
 
@@ -509,7 +512,8 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
   geom->add_primitive(strip);
   
   CullableObject *object = new CullableObject(geom, data._state,
-                                              data._modelview_transform);
+                                              data.get_net_transform(trav),
+                                              data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(object, trav);
 }
 

panda/src/parametrics/sheetNode.cxx

@@ -335,7 +335,8 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
   geom->add_primitive(strip);
   
   CullableObject *object = new CullableObject(geom, data._state,
-                                              data._modelview_transform);
+                                              data.get_net_transform(trav),
+                                              data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(object, trav);
 }
 

panda/src/pgraph/billboardEffect.cxx

@@ -147,13 +147,13 @@ void BillboardEffect::
 cull_callback(CullTraverser *trav, CullTraverserData &data,
               CPT(TransformState) &node_transform,
               CPT(RenderState) &) const {
-  CPT(TransformState) net_transform = data._modelview_transform;
-  if (net_transform->is_singular()) {
+  CPT(TransformState) modelview_transform = data.get_modelview_transform(trav);
+  if (modelview_transform->is_singular()) {
     // If we're under a singular transform, never mind.
     return;
   }
 
-  // Since the "net" transform from the cull traverser already
+  // Since the "modelview" transform from the cull traverser already
   // includes the inverse camera transform, the camera transform is
   // identity.
   CPT(TransformState) camera_transform = TransformState::make_identity();
@@ -164,7 +164,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data,
     camera_transform = trav->get_camera_transform()->invert_compose(_look_at.get_net_transform());
   }
 
-  compute_billboard(node_transform, net_transform, camera_transform);
+  compute_billboard(node_transform, modelview_transform, camera_transform);
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/pgraph/cullTraverser.I

@@ -97,9 +97,9 @@ get_camera_transform() const {
 //
 //               Note that this value is always the position of the
 //               starting node, not the current node, even if it is
-//               sampled during a traversal.  To get the world
-//               transform of the current node use
-//               CullTraverserData::_net_transform.
+//               sampled during a traversal.  To get the transform of
+//               the current node use
+//               CullTraverserData::get_modelview_transform().
 ////////////////////////////////////////////////////////////////////
 INLINE const TransformState *CullTraverser::
 get_world_transform() const {

panda/src/pgraph/cullTraverser.cxx

@@ -110,7 +110,7 @@ traverse(const NodePath &root, bool python_cull_control) {
     // store this pointer in this
     set_portal_clipper(&portal_viewer);
 
-    CullTraverserData data(root, get_world_transform(),
+    CullTraverserData data(root, TransformState::make_identity(),
                            _initial_state, _view_frustum, 
                            _guard_band);
     
@@ -124,11 +124,11 @@ traverse(const NodePath &root, bool python_cull_control) {
     CPT(TransformState) transform = cull_center.get_transform(root);
     
     CullTraverserData my_data(data, portal_viewer._previous);
-    my_data._modelview_transform = my_data._modelview_transform->compose(transform);
+    my_data._net_transform = my_data._net_transform->compose(transform);
     traverse(my_data);
 
   } else {
-    CullTraverserData data(root, get_world_transform(),
+    CullTraverserData data(root, TransformState::make_identity(),
                            _initial_state, _view_frustum, 
                            _guard_band);
     
@@ -223,7 +223,7 @@ traverse_below(CullTraverserData &data) {
       int num_geoms = geom_node->get_num_geoms();
       _geoms_pcollector.add_level(num_geoms);
       for (int i = 0; i < num_geoms; i++) {
-        CullableObject *object = new CullableObject(data, geom_node, i);
+        CullableObject *object = new CullableObject(this, data, geom_node, i);
         if (object->_state->has_cull_callback() &&
             !object->_state->cull_callback(this, data)) {
           delete object;
@@ -286,7 +286,8 @@ show_bounds(CullTraverserData &data, bool tight) {
       _geoms_pcollector.add_level(1);
       CullableObject *outer_viz = 
         new CullableObject(bounds_viz, get_bounds_outer_viz_state(), 
-                           data._modelview_transform);
+                           data.get_net_transform(this),
+                           data.get_modelview_transform(this));
       _cull_handler->record_object(outer_viz, this);
     }
     
@@ -297,12 +298,14 @@ show_bounds(CullTraverserData &data, bool tight) {
       _geoms_pcollector.add_level(2);
       CullableObject *outer_viz = 
         new CullableObject(bounds_viz, get_bounds_outer_viz_state(), 
-                           data._modelview_transform);
+                           data.get_net_transform(this),
+                           data.get_modelview_transform(this));
       _cull_handler->record_object(outer_viz, this);
       
       CullableObject *inner_viz = 
         new CullableObject(bounds_viz, get_bounds_inner_viz_state(), 
-                           data._modelview_transform);
+                           data.get_net_transform(this),
+                           data.get_modelview_transform(this));
       _cull_handler->record_object(inner_viz, this);
     }
   }
@@ -549,7 +552,7 @@ start_decal(const CullTraverserData &data) {
   _geoms_pcollector.add_level(num_geoms);
   for (int i = num_geoms - 1; i >= 0; i--) {
     CullableObject *next_object = 
-      new CullableObject(data, geom_node, i, object);
+      new CullableObject(this, data, geom_node, i, object);
     if (next_object->_state->has_cull_callback() &&
         !next_object->_state->cull_callback(this, data)) {
       next_object->_next = NULL;
@@ -618,7 +621,7 @@ r_get_decals(CullTraverserData &data, CullableObject *decals) {
       _geoms_pcollector.add_level(num_geoms);
       for (int i = num_geoms - 1; i >= 0; i--) {
         CullableObject *next_decals = 
-          new CullableObject(data, geom_node, i, decals);
+          new CullableObject(this, data, geom_node, i, decals);
         if (next_decals->_state->has_cull_callback() &&
             !next_decals->_state->cull_callback(this, data)) {
           next_decals->_next = NULL;

panda/src/pgraph/cullTraverserData.I

@@ -23,12 +23,12 @@
 ////////////////////////////////////////////////////////////////////
 INLINE CullTraverserData::
 CullTraverserData(const NodePath &start,
-                  const TransformState *modelview_transform,
+                  const TransformState *net_transform,
                   const RenderState *state,
                   GeometricBoundingVolume *view_frustum,
                   GeometricBoundingVolume *guard_band) :
   _node_path(start),
-  _modelview_transform(modelview_transform),
+  _net_transform(net_transform),
   _state(state),
   _view_frustum(view_frustum),
   _guard_band(guard_band),
@@ -45,7 +45,7 @@ CullTraverserData(const NodePath &start,
 INLINE CullTraverserData::
 CullTraverserData(const CullTraverserData &copy) :
   _node_path(copy._node_path),
-  _modelview_transform(copy._modelview_transform),
+  _net_transform(copy._net_transform),
   _state(copy._state),
   _view_frustum(copy._view_frustum),
   _guard_band(copy._guard_band),
@@ -62,7 +62,7 @@ CullTraverserData(const CullTraverserData &copy) :
 INLINE void CullTraverserData::
 operator = (const CullTraverserData &copy) {
   _node_path = copy._node_path;
-  _modelview_transform = copy._modelview_transform;
+  _net_transform = copy._net_transform;
   _state = copy._state;
   _view_frustum = copy._view_frustum;
   _guard_band = copy._guard_band;
@@ -79,7 +79,7 @@ operator = (const CullTraverserData &copy) {
 INLINE CullTraverserData::
 CullTraverserData(const CullTraverserData &parent, PandaNode *child) :
   _node_path(parent._node_path, child),
-  _modelview_transform(parent._modelview_transform),
+  _net_transform(parent._net_transform),
   _state(parent._state),
   _view_frustum(parent._view_frustum),
   _guard_band(parent._guard_band),
@@ -108,14 +108,14 @@ node() const {
 }
 
 ////////////////////////////////////////////////////////////////////
-//     Function: CullTraverserData::get_modelview_transform
+//     Function: CullTraverserData::get_net_transform
 //       Access: Public
-//  Description: Returns the modelview transform: the relative
-//               transform from the camera to the model.
+//  Description: Returns the net transform: the relative transform
+//               from root of the scene graph to the current node.
 ////////////////////////////////////////////////////////////////////
 INLINE const TransformState *CullTraverserData::
-get_modelview_transform() const {
-  return _modelview_transform;
+get_net_transform(const CullTraverser *) const {
+  return _net_transform;
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/pgraph/cullTraverserData.cxx

@@ -32,14 +32,14 @@
 
 
 ////////////////////////////////////////////////////////////////////
-//     Function: CullTraverserData::get_net_transform
+//     Function: CullTraverserData::get_modelview_transform
 //       Access: Public
-//  Description: Returns the net transform: the relative
-//               transform from the root of the scene to the model.
+//  Description: Returns the modelview transform: the relative
+//               transform from the camera to the model.
 ////////////////////////////////////////////////////////////////////
 CPT(TransformState) CullTraverserData::
-get_net_transform(const CullTraverser *trav) const {
-  return trav->get_camera_transform()->compose(_modelview_transform);
+get_modelview_transform(const CullTraverser *trav) const {
+  return trav->get_world_transform()->compose(_net_transform);
 }
 
 ////////////////////////////////////////////////////////////////////
@@ -87,7 +87,7 @@ apply_transform_and_state(CullTraverser *trav,
   }
 
   if (!node_transform->is_identity()) {
-    _modelview_transform = _modelview_transform->compose(node_transform);
+    _net_transform = _net_transform->compose(node_transform);
 
     if ((_view_frustum != (GeometricBoundingVolume *)NULL) ||
         (_guard_band != (GeometricBoundingVolume *)NULL) ||

panda/src/pgraph/cullTraverserData.h

@@ -48,7 +48,7 @@ class PandaNode;
 class EXPCL_PANDA CullTraverserData {
 public:
   INLINE CullTraverserData(const NodePath &start,
-                           const TransformState *modelview_transform,
+                           const TransformState *net_transform,
                            const RenderState *state,
                            GeometricBoundingVolume *view_frustum,
                            GeometricBoundingVolume *guard_band);
@@ -60,8 +60,8 @@ public:
 
   INLINE PandaNode *node() const;
 
-  INLINE const TransformState *get_modelview_transform() const;
-  CPT(TransformState) get_net_transform(const CullTraverser *trav) const;
+  CPT(TransformState) get_modelview_transform(const CullTraverser *trav) const;
+  INLINE const TransformState *get_net_transform(const CullTraverser *trav) const;
 
   INLINE bool is_in_view(const DrawMask &camera_mask);
   INLINE bool is_this_node_hidden(const CullTraverser *trav) const;
@@ -74,7 +74,7 @@ public:
                                  const RenderAttrib *off_clip_planes);
 
   WorkingNodePath _node_path;
-  CPT(TransformState) _modelview_transform;
+  CPT(TransformState) _net_transform;
   CPT(RenderState) _state;
   PT(GeometricBoundingVolume) _view_frustum;
   PT(GeometricBoundingVolume) _guard_band;

panda/src/pgraph/cullableObject.I

@@ -36,12 +36,13 @@ CullableObject(CullableObject *next) :
 //               the indicated CullTraverserData.
 ////////////////////////////////////////////////////////////////////
 INLINE CullableObject::
-CullableObject(const CullTraverserData &data,
+CullableObject(const CullTraverser *trav, const CullTraverserData &data,
                GeomNode *geom_node, int i,
                CullableObject *next) :
   _geom(geom_node->get_geom(i)),
   _state(data._state->compose(geom_node->get_geom_state(i))),
-  _modelview_transform(data._modelview_transform),
+  _net_transform(data.get_net_transform(trav)),
+  _modelview_transform(data.get_modelview_transform(trav)),
   _next(next)
 {
 }
@@ -54,10 +55,12 @@ CullableObject(const CullTraverserData &data,
 ////////////////////////////////////////////////////////////////////
 INLINE CullableObject::
 CullableObject(const Geom *geom, const RenderState *state,
+               const TransformState *net_transform,
                const TransformState *modelview_transform,
                CullableObject *next) :
   _geom(geom),
   _state(state),
+  _net_transform(net_transform),
   _modelview_transform(modelview_transform),
   _next(next)
 {
@@ -74,6 +77,7 @@ INLINE CullableObject::
 CullableObject(const CullableObject &copy) :
   _geom(copy._geom),
   _state(copy._state),
+  _net_transform(copy._net_transform),
   _modelview_transform(copy._modelview_transform),
   _next((CullableObject *)NULL)
 {
@@ -89,6 +93,7 @@ INLINE void CullableObject::
 operator = (const CullableObject &copy) {
   _geom = copy._geom;
   _state = copy._state;
+  _net_transform = copy._net_transform;
   _modelview_transform = copy._modelview_transform;
 }
 

panda/src/pgraph/cullableObject.cxx

@@ -479,13 +479,15 @@ void CullableObject::
 munge_texcoord_light_vector(const CullTraverser *traverser) {
   PStatTimer timer(_munge_light_vector_pcollector);
 
-  if (_modelview_transform->is_singular()) {
+  if (_net_transform->is_singular()) {
     // If we're under a singular transform, never mind.
     return;
   }
 
+  /*
   CPT(TransformState) net_transform =
     traverser->get_camera_transform()->compose(_modelview_transform);
+  */
 
   if (!_munged_data->has_column(InternalName::get_vertex()) || 
       !_munged_data->has_column(InternalName::get_normal())) {
@@ -544,7 +546,7 @@ munge_texcoord_light_vector(const CullTraverser *traverser) {
 
         // Get the transform from the light to the object.
         CPT(TransformState) light_transform =
-          net_transform->invert_compose(light.get_net_transform());
+          _net_transform->invert_compose(light.get_net_transform());
         const LMatrix4f &light_mat = light_transform->get_mat();
 
         GeomVertexWriter texcoord(new_data, texcoord_name);

panda/src/pgraph/cullableObject.h

@@ -45,10 +45,12 @@ class CullTraverser;
 class EXPCL_PANDA CullableObject {
 public:
   INLINE CullableObject(CullableObject *next = NULL);
-  INLINE CullableObject(const CullTraverserData &data,
+  INLINE CullableObject(const CullTraverser *trav,
+                        const CullTraverserData &data,
                         GeomNode *geom_node, int i,
                         CullableObject *next = NULL);
   INLINE CullableObject(const Geom *geom, const RenderState *state,
+                        const TransformState *net_transform,
                         const TransformState *modelview_transform,
                         CullableObject *next = NULL);
     
@@ -80,6 +82,7 @@ public:
   PT(GeomMunger) _munger;
   CPT(GeomVertexData) _munged_data;
   CPT(RenderState) _state;
+  CPT(TransformState) _net_transform;
   CPT(TransformState) _modelview_transform;
   CullableObject *_next;
 

panda/src/pgraph/lodNode.cxx

@@ -244,7 +244,7 @@ is_lod_node() const {
 ////////////////////////////////////////////////////////////////////
 int LODNode::
 compute_child(CullTraverser *trav, CullTraverserData &data) {
-  if (data._modelview_transform->is_singular()) {
+  if (data.get_net_transform(trav)->is_singular()) {
     // If we're under a singular transform, we can't compute the LOD;
     // select none of them instead.
     return -1;
@@ -264,7 +264,7 @@ compute_child(CullTraverser *trav, CullTraverserData &data) {
   //     trav->get_scene()->get_cull_center().get_net_transform()->
   //     invert_compose(data._net_transform);
 
-  CPT(TransformState) rel_transform = data._modelview_transform;
+  CPT(TransformState) rel_transform = data.get_modelview_transform(trav);
   LPoint3f center = cdata->_center * rel_transform->get_mat();
 
   // Determine which child to traverse

panda/src/pgraph/planeNode.cxx

@@ -176,7 +176,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
 
   CullableObject *plane_viz = 
     new CullableObject(get_viz(trav, data), data._state, 
-                       data._modelview_transform);
+                       data.get_net_transform(trav),
+                       data.get_modelview_transform(trav));
   trav->get_cull_handler()->record_object(plane_viz, trav);
 
   // Now carry on to render our child nodes.
@@ -225,7 +226,7 @@ get_viz(CullTraverser *trav, CullTraverserData &data) {
   // Figure out whether we are looking at the front or the back of the
   // plane.
   const Lens *lens = trav->get_scene()->get_lens();
-  Planef eye_plane = cdata->_plane * data._modelview_transform->get_mat();
+  Planef eye_plane = cdata->_plane * data.get_modelview_transform(trav)->get_mat();
   bool front = (eye_plane.dist_to_plane(lens->get_nodal_point()) >= 0.0f);
 
   if (cdata->_front_viz != (Geom *)NULL) {