fix billboards, lod's, etc.

panda/src/collide/collisionNode.cxx

@@ -224,7 +224,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
   Solids::iterator si;
   for (si = _solids.begin(); si != _solids.end(); ++si) {
     CollisionSolid *solid = (*si);
-    PT(PandaNode) node = solid->get_viz(data, false);
+    PT(PandaNode) node = solid->get_viz(trav, data, false);
     if (node != (PandaNode *)NULL) {
       CullTraverserData next_data(data, node);
 
@@ -246,12 +246,12 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
 
     for (si = _solids.begin(); si != _solids.end(); ++si) {
       CollisionSolid *solid = (*si);
-      PT(PandaNode) node = solid->get_viz(data, false);
+      PT(PandaNode) node = solid->get_viz(trav, data, false);
       if (node != (PandaNode *)NULL) {
         CullTraverserData next_data(data, node);
 
-        next_data._net_transform = 
-          next_data._net_transform->compose(transform);
+        next_data._modelview_transform = 
+          next_data._modelview_transform->compose(transform);
         next_data._state = get_last_pos_state();
         trav->traverse(next_data);
       }

panda/src/collide/collisionPolygon.cxx

@@ -278,13 +278,14 @@ get_collision_origin() const {
 //               made visible.
 ////////////////////////////////////////////////////////////////////
 PT(PandaNode) CollisionPolygon::
-get_viz(const CullTraverserData &data, bool bounds_only) const {
+get_viz(const CullTraverser *trav, const CullTraverserData &data, 
+        bool bounds_only) const {
   const RenderAttrib *cpa_attrib =
     data._state->get_attrib(ClipPlaneAttrib::get_class_type());
   if (cpa_attrib == (const RenderAttrib *)NULL) {
     // Fortunately, the polygon is not clipped.  This is the normal,
     // easy case.
-    return CollisionSolid::get_viz(data, bounds_only);
+    return CollisionSolid::get_viz(trav, data, bounds_only);
   }
 
   if (collide_cat.is_debug()) {
@@ -300,10 +301,10 @@ get_viz(const CullTraverserData &data, bool bounds_only) const {
   // work.
   const ClipPlaneAttrib *cpa = DCAST(ClipPlaneAttrib, cpa_attrib);
   Points new_points;
-  if (apply_clip_plane(new_points, cpa, data._net_transform)) {
+  if (apply_clip_plane(new_points, cpa, data.get_net_transform(trav))) {
     // All points are behind the clip plane; just draw the original
     // polygon.
-    return CollisionSolid::get_viz(data, bounds_only);
+    return CollisionSolid::get_viz(trav, data, bounds_only);
   }
 
   if (new_points.empty()) {
@@ -845,11 +846,11 @@ draw_polygon(GeomNode *viz_geom_node, GeomNode *bounds_viz_geom_node,
     geom2->set_vertex_data(vdata);
     geom2->add_primitive(border);
 
-    _viz_geom->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_viz_state());
-    _viz_geom->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_viz_state());
+    viz_geom_node->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_viz_state());
+    viz_geom_node->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_viz_state());
 
-    _bounds_viz_geom->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_bounds_viz_state());
-    _bounds_viz_geom->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_bounds_viz_state());
+    bounds_viz_geom_node->add_geom(geom1, ((CollisionPolygon *)this)->get_solid_bounds_viz_state());
+    bounds_viz_geom_node->add_geom(geom2, ((CollisionPolygon *)this)->get_wireframe_bounds_viz_state());
 
   } else {
     PTA_Vertexf verts;

panda/src/collide/collisionPolygon.h

@@ -61,7 +61,8 @@ public:
   virtual void xform(const LMatrix4f &mat);
   virtual LPoint3f get_collision_origin() const;
 
-  virtual PT(PandaNode) get_viz(const CullTraverserData &data,
+  virtual PT(PandaNode) get_viz(const CullTraverser *trav,
+                                const CullTraverserData &data,
                                 bool bounds_only) const;
 
   virtual void output(ostream &out) const;

panda/src/collide/collisionSolid.cxx

@@ -108,7 +108,7 @@ xform(const LMatrix4f &mat) {
 //               made visible.
 ////////////////////////////////////////////////////////////////////
 PT(PandaNode) CollisionSolid::
-get_viz(const CullTraverserData &, bool bounds_only) const {
+get_viz(const CullTraverser *, const CullTraverserData &, bool bounds_only) const {
   if ((_flags & F_viz_geom_stale) != 0) {
     if (_viz_geom == (GeomNode *)NULL) {
       ((CollisionSolid *)this)->_viz_geom = new GeomNode("viz");

panda/src/collide/collisionSolid.h

@@ -77,7 +77,8 @@ public:
 
   virtual void xform(const LMatrix4f &mat);
 
-  virtual PT(PandaNode) get_viz(const CullTraverserData &data,
+  virtual PT(PandaNode) get_viz(const CullTraverser *trav,
+                                const CullTraverserData &data,
                                 bool bounds_only) const;
 
 PUBLISHED:

panda/src/collide/collisionVisualizer.cxx

@@ -129,7 +129,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._net_transform = TransformState::make_identity();
+    xform_data._modelview_transform = trav->get_world_transform();
     xform_data.apply_transform_and_state(trav, net_transform, 
                                          RenderState::make_empty(),
                                          RenderEffects::make_empty());
@@ -145,7 +145,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
       const CollisionSolid *solid = (*si).first;
       const SolidInfo &solid_info = (*si).second;
       bool was_detected = (solid_info._detected_count > 0);
-      PT(PandaNode) node = solid->get_viz(xform_data, !was_detected);
+      PT(PandaNode) node = solid->get_viz(trav, xform_data, !was_detected);
       if (node != (PandaNode *)NULL) {
         CullTraverserData next_data(xform_data, node);
         
@@ -188,7 +188,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
           }
             
           CullableObject *object = 
-            new CullableObject(sphere, empty_state, xform_data._net_transform);
+            new CullableObject(sphere, empty_state, xform_data._modelview_transform);
           
           trav->get_cull_handler()->record_object(object, trav);
         }
@@ -206,7 +206,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
           line->set_num_prims(1);
           
           CullableObject *object = 
-            new CullableObject(line, empty_state, xform_data._net_transform);
+            new CullableObject(line, empty_state, xform_data._modelview_transform);
           
           trav->get_cull_handler()->record_object(object, trav);
         }

panda/src/parametrics/ropeNode.cxx

@@ -361,7 +361,7 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
     CPT(RenderState) state = data._state->add_attrib(thick);
     
     CullableObject *object = new CullableObject(geom, state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
 
   } else {
@@ -406,7 +406,7 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
     CPT(RenderState) state = data._state->add_attrib(thick);
     
     CullableObject *object = new CullableObject(geom, state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
   }
 }
@@ -451,7 +451,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
     geom->add_primitive(strip);
 
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
 
   } else {
@@ -497,7 +497,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
     geom->set_lengths(lengths);
     
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
   }
 }
@@ -515,7 +515,7 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
 void RopeNode::
 render_billboard(CullTraverser *trav, CullTraverserData &data, 
                  NurbsCurveResult *result) const {
-  const TransformState *net_transform = data._net_transform;
+  const TransformState *net_transform = data._modelview_transform;
   const TransformState *camera_transform = trav->get_camera_transform();
 
   CPT(TransformState) rel_transform =
@@ -549,7 +549,7 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
     geom->add_primitive(strip);
 
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
 
   } else {
@@ -595,7 +595,7 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
     geom->set_lengths(lengths);
     
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
   }
 }
@@ -654,7 +654,7 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
     geom->add_primitive(strip);
 
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
 
   } else {
@@ -713,7 +713,7 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
     geom->set_lengths(lengths);
     
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
   }
 }

panda/src/parametrics/sheetNode.cxx

@@ -333,7 +333,7 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
     geom->add_primitive(strip);
 
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
 
   } else {
@@ -403,7 +403,7 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
     geom->set_lengths(lengths);
   
     CullableObject *object = new CullableObject(geom, data._state,
-                                                data._net_transform);
+                                                data._modelview_transform);
     trav->get_cull_handler()->record_object(object, trav);
   }
 }

panda/src/pgraph/billboardEffect.cxx

@@ -147,18 +147,21 @@ void BillboardEffect::
 cull_callback(CullTraverser *trav, CullTraverserData &data,
               CPT(TransformState) &node_transform,
               CPT(RenderState) &) const {
-  CPT(TransformState) net_transform = data._net_transform;
+  CPT(TransformState) net_transform = data._modelview_transform;
   if (net_transform->is_singular()) {
     // If we're under a singular transform, never mind.
     return;
   }
 
-  CPT(TransformState) camera_transform = trav->get_camera_transform();
+  // Since the "net" transform from the cull traverser already
+  // includes the inverse camera transform, the camera transform is
+  // identity.
+  CPT(TransformState) camera_transform = TransformState::make_identity();
 
-  // Determine the relative transform to our camera (or other look_at
-  // coordinate space).
+  // But if we're rotating to face something other than the camera, we
+  // have to compute the "camera" transform to compensate for that.
   if (!_look_at.is_empty()) {
-    camera_transform = _look_at.get_net_transform();
+    camera_transform = trav->get_camera_transform()->invert_compose(_look_at.get_net_transform());
   }
 
   compute_billboard(node_transform, net_transform, camera_transform);

panda/src/pgraph/compassEffect.cxx

@@ -135,7 +135,7 @@ has_cull_callback() const {
 //               level.
 ////////////////////////////////////////////////////////////////////
 void CompassEffect::
-cull_callback(CullTraverser *, CullTraverserData &data,
+cull_callback(CullTraverser *trav, CullTraverserData &data,
               CPT(TransformState) &node_transform,
               CPT(RenderState) &) const {
   if (_properties == 0) {
@@ -143,8 +143,8 @@ cull_callback(CullTraverser *, CullTraverserData &data,
     return;
   }
 
-  CPT(TransformState) true_net_transform = data._net_transform;
-  CPT(TransformState) want_net_transform = data._net_transform;
+  CPT(TransformState) true_net_transform = data.get_net_transform(trav);
+  CPT(TransformState) want_net_transform = true_net_transform;
   adjust_transform(want_net_transform, node_transform);
 
   // Now compute the transform that will convert true_net_transform to

panda/src/pgraph/cullBinBackToFront.cxx

@@ -59,8 +59,8 @@ add_object(CullableObject *object) {
     DCAST_INTO_V(gbv, &volume);
     
     LPoint3f center = gbv->get_approx_center();
-    nassertv(object->_transform != (const TransformState *)NULL);
-    center = center * object->_transform->get_mat();
+    nassertv(object->_modelview_transform != (const TransformState *)NULL);
+    center = center * object->_modelview_transform->get_mat();
     
     float distance = _gsg->compute_distance_to(center);
     _objects.push_back(ObjectData(object, distance));

panda/src/pgraph/cullBinFrontToBack.cxx

@@ -59,8 +59,8 @@ add_object(CullableObject *object) {
     DCAST_INTO_V(gbv, &volume);
     
     LPoint3f center = gbv->get_approx_center();
-    nassertv(object->_transform != (const TransformState *)NULL);
-    center = center * object->_transform->get_mat();
+    nassertv(object->_modelview_transform != (const TransformState *)NULL);
+    center = center * object->_modelview_transform->get_mat();
     
     float distance = _gsg->compute_distance_to(center);
     _objects.push_back(ObjectData(object, distance));

panda/src/pgraph/cullBinStateSorted.I

@@ -52,8 +52,8 @@ operator < (const ObjectData &other) const {
 
   // Then group objects by transform, since these are supposed to be
   // expensive too.
-  if (_object->_transform != other._object->_transform) {
-    return _object->_transform < other._object->_transform;
+  if (_object->_modelview_transform != other._object->_modelview_transform) {
+    return _object->_modelview_transform < other._object->_modelview_transform;
   }
       
   // Then, sort by all the other states, in no particular order,

panda/src/pgraph/cullHandler.I

@@ -29,7 +29,7 @@ draw(CullableObject *object, GraphicsStateGuardianBase *gsg) {
   if (object->_next != (CullableObject *)NULL) {
     draw_with_decals(object, gsg);
   } else {
-    gsg->set_state_and_transform(object->_state, object->_transform);
+    gsg->set_state_and_transform(object->_state, object->_modelview_transform);
     object->draw(gsg);
   }
 }

panda/src/pgraph/cullHandler.cxx

@@ -45,7 +45,7 @@ CullHandler::
 ////////////////////////////////////////////////////////////////////
 void CullHandler::
 record_object(CullableObject *object, const CullTraverser *traverser) {
-  nout << *object->_geom << " " << *object->_transform << " " 
+  nout << *object->_geom << " " << *object->_modelview_transform << " " 
        << *object->_state << "\n";
   delete object;
 }
@@ -65,7 +65,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
 
   CullableObject *base = object;
   while (base != (CullableObject *)NULL && base->_geom != (Geom *)NULL) {
-    gsg->set_state_and_transform(base->_state->compose(state), base->_transform);
+    gsg->set_state_and_transform(base->_state->compose(state), base->_modelview_transform);
     base->draw(gsg);
     
     base = base->_next;
@@ -77,7 +77,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
 
     CullableObject *decal = base->_next;
     while (decal != (CullableObject *)NULL) {
-      gsg->set_state_and_transform(decal->_state->compose(state), decal->_transform);
+      gsg->set_state_and_transform(decal->_state->compose(state), decal->_modelview_transform);
       decal->draw(gsg);
       decal = decal->_next;
     }
@@ -88,7 +88,7 @@ draw_with_decals(CullableObject *object, GraphicsStateGuardianBase *gsg) {
   if (state != (const RenderState *)NULL) {
     base = object;
     while (base != (CullableObject *)NULL && base->_geom != (Geom *)NULL) {
-      gsg->set_state_and_transform(base->_state->compose(state), base->_transform);
+      gsg->set_state_and_transform(base->_state->compose(state), base->_modelview_transform);
       base->draw(gsg);
       
       base = base->_next;

panda/src/pgraph/cullTraverser.cxx

@@ -125,7 +125,7 @@ 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._net_transform = my_data._net_transform->compose(transform);
+    my_data._modelview_transform = my_data._modelview_transform->compose(transform);
     traverse(my_data);
 
   } else {
@@ -273,7 +273,7 @@ show_bounds(CullTraverserData &data, bool tight) {
       _geoms_pcollector.add_level(1);
       CullableObject *outer_viz = 
         new CullableObject(bounds_viz, get_bounds_outer_viz_state(), 
-                           data._net_transform);
+                           data._modelview_transform);
       _cull_handler->record_object(outer_viz, this);
     }
     
@@ -284,12 +284,12 @@ show_bounds(CullTraverserData &data, bool tight) {
       _geoms_pcollector.add_level(2);
       CullableObject *outer_viz = 
         new CullableObject(bounds_viz, get_bounds_outer_viz_state(), 
-                           data._net_transform);
+                           data._modelview_transform);
       _cull_handler->record_object(outer_viz, this);
       
       CullableObject *inner_viz = 
         new CullableObject(bounds_viz, get_bounds_inner_viz_state(), 
-                           data._net_transform);
+                           data._modelview_transform);
       _cull_handler->record_object(inner_viz, this);
     }
   }

panda/src/pgraph/cullTraverserData.I

@@ -23,12 +23,12 @@
 ////////////////////////////////////////////////////////////////////
 INLINE CullTraverserData::
 CullTraverserData(const NodePath &start,
-                  const TransformState *net_transform,
+                  const TransformState *modelview_transform,
                   const RenderState *state,
                   GeometricBoundingVolume *view_frustum,
                   GeometricBoundingVolume *guard_band) :
   _node_path(start),
-  _net_transform(net_transform),
+  _modelview_transform(modelview_transform),
   _state(state),
   _view_frustum(view_frustum),
   _guard_band(guard_band)
@@ -43,7 +43,7 @@ CullTraverserData(const NodePath &start,
 INLINE CullTraverserData::
 CullTraverserData(const CullTraverserData &copy) :
   _node_path(copy._node_path),
-  _net_transform(copy._net_transform),
+  _modelview_transform(copy._modelview_transform),
   _state(copy._state),
   _view_frustum(copy._view_frustum),
   _guard_band(copy._guard_band)
@@ -58,7 +58,7 @@ CullTraverserData(const CullTraverserData &copy) :
 INLINE void CullTraverserData::
 operator = (const CullTraverserData &copy) {
   _node_path = copy._node_path;
-  _net_transform = copy._net_transform;
+  _modelview_transform = copy._modelview_transform;
   _state = copy._state;
   _view_frustum = copy._view_frustum;
   _guard_band = copy._guard_band;
@@ -73,7 +73,7 @@ operator = (const CullTraverserData &copy) {
 INLINE CullTraverserData::
 CullTraverserData(const CullTraverserData &parent, PandaNode *child) :
   _node_path(parent._node_path, child),
-  _net_transform(parent._net_transform),
+  _modelview_transform(parent._modelview_transform),
   _state(parent._state),
   _view_frustum(parent._view_frustum),
   _guard_band(parent._guard_band)
@@ -99,6 +99,17 @@ node() const {
   return _node_path.node();
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: CullTraverserData::get_modelview_transform
+//       Access: Public
+//  Description: Returns the modelview transform: the relative
+//               transform from the camera to the model.
+////////////////////////////////////////////////////////////////////
+INLINE const TransformState *CullTraverserData::
+get_modelview_transform() const {
+  return _modelview_transform;
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: CullTraverserData::is_in_view
 //       Access: Public

panda/src/pgraph/cullTraverserData.cxx

@@ -29,6 +29,17 @@
 #include "renderState.h"
 
 
+////////////////////////////////////////////////////////////////////
+//     Function: CullTraverserData::get_net_transform
+//       Access: Public
+//  Description: Returns the net transform: the relative
+//               transform from the root of the scene to the model.
+////////////////////////////////////////////////////////////////////
+CPT(TransformState) CullTraverserData::
+get_net_transform(const CullTraverser *trav) const {
+  return trav->get_camera_transform()->compose(_modelview_transform);
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: CullTraverserData::apply_transform_and_state
 //       Access: Public
@@ -71,7 +82,7 @@ apply_transform_and_state(CullTraverser *trav,
   }
 
   if (!node_transform->is_identity()) {
-    _net_transform = _net_transform->compose(node_transform);
+    _modelview_transform = _modelview_transform->compose(node_transform);
 
     if ((_view_frustum != (GeometricBoundingVolume *)NULL) ||
         (_guard_band != (GeometricBoundingVolume *)NULL)) {

panda/src/pgraph/cullTraverserData.h

@@ -48,7 +48,7 @@ class CullTraverser;
 class EXPCL_PANDA CullTraverserData {
 public:
   INLINE CullTraverserData(const NodePath &start,
-                           const TransformState *net_transform,
+                           const TransformState *modelview_transform,
                            const RenderState *state,
                            GeometricBoundingVolume *view_frustum,
                            GeometricBoundingVolume *guard_band);
@@ -60,6 +60,9 @@ public:
 
   INLINE PandaNode *node() const;
 
+  INLINE const TransformState *get_modelview_transform() const;
+  CPT(TransformState) get_net_transform(const CullTraverser *trav) const;
+
   INLINE bool is_in_view(const DrawMask &camera_mask);
   void apply_transform_and_state(CullTraverser *trav);
   void apply_transform_and_state(CullTraverser *trav, 
@@ -68,7 +71,7 @@ public:
                                  CPT(RenderEffects) node_effects);
 
   WorkingNodePath _node_path;
-  CPT(TransformState) _net_transform;
+  CPT(TransformState) _modelview_transform;
   CPT(RenderState) _state;
   PT(GeometricBoundingVolume) _view_frustum;
   PT(GeometricBoundingVolume) _guard_band;

panda/src/pgraph/cullableObject.I

@@ -41,7 +41,7 @@ CullableObject(const CullTraverserData &data,
                CullableObject *next) :
   _geom(geom_node->get_geom(i)),
   _state(data._state->compose(geom_node->get_geom_state(i))),
-  _transform(data._net_transform),
+  _modelview_transform(data._modelview_transform),
   _next(next)
 {
 }
@@ -54,11 +54,11 @@ CullableObject(const CullTraverserData &data,
 ////////////////////////////////////////////////////////////////////
 INLINE CullableObject::
 CullableObject(const Geom *geom, const RenderState *state,
-               const TransformState *transform,
+               const TransformState *modelview_transform,
                CullableObject *next) :
   _geom(geom),
   _state(state),
-  _transform(transform),
+  _modelview_transform(modelview_transform),
   _next(next)
 {
 }
@@ -74,7 +74,7 @@ INLINE CullableObject::
 CullableObject(const CullableObject &copy) :
   _geom(copy._geom),
   _state(copy._state),
-  _transform(copy._transform),
+  _modelview_transform(copy._modelview_transform),
   _next((CullableObject *)NULL)
 {
 }
@@ -89,7 +89,7 @@ INLINE void CullableObject::
 operator = (const CullableObject &copy) {
   _geom = copy._geom;
   _state = copy._state;
-  _transform = copy._transform;
+  _modelview_transform = copy._modelview_transform;
 }
 
 ////////////////////////////////////////////////////////////////////

panda/src/pgraph/cullableObject.cxx

@@ -54,7 +54,7 @@ munge_geom(GraphicsStateGuardianBase *gsg,
 
       int geom_rendering = qpgeom->get_geom_rendering();
       geom_rendering = _state->get_geom_rendering(geom_rendering);
-      geom_rendering = _transform->get_geom_rendering(geom_rendering);
+      geom_rendering = _modelview_transform->get_geom_rendering(geom_rendering);
 
       GraphicsStateGuardianBase *gsg = traverser->get_gsg();
       int gsg_bits = gsg->get_supported_geom_rendering();
@@ -235,7 +235,7 @@ munge_points_to_quads(const CullTraverser *traverser) {
   PT(qpGeom) new_geom = new qpGeom();
   new_geom->set_vertex_data(new_data);
 
-  const LMatrix4f &modelview = _transform->get_mat();
+  const LMatrix4f &modelview = _modelview_transform->get_mat();
 
   SceneSetup *scene = traverser->get_scene();
   const Lens *lens = scene->get_lens();
@@ -350,7 +350,7 @@ munge_points_to_quads(const CullTraverser *traverser) {
         // height in 3-d units.  To arrange that, we need to figure
         // out the appropriate scaling factor based on the current
         // viewport and projection matrix.
-        float scale = _transform->get_scale()[1];
+        float scale = _modelview_transform->get_scale()[1];
         LVector3f height(0.0f, point_size * scale, scale);
         height = height * height_projection;
         scale_y = height[1] * viewport_height;

panda/src/pgraph/cullableObject.h

@@ -49,7 +49,7 @@ public:
                         GeomNode *geom_node, int i,
                         CullableObject *next = NULL);
   INLINE CullableObject(const Geom *geom, const RenderState *state,
-                        const TransformState *transform,
+                        const TransformState *modelview_transform,
                         CullableObject *next = NULL);
     
   INLINE CullableObject(const CullableObject &copy);
@@ -80,7 +80,7 @@ public:
   PT(qpGeomMunger) _munger;
   CPT(qpGeomVertexData) _munged_data;
   CPT(RenderState) _state;
-  CPT(TransformState) _transform;
+  CPT(TransformState) _modelview_transform;
   CullableObject *_next;
 
 private:

panda/src/pgraph/lodNode.cxx

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

panda/src/pgui/pgItem.cxx

@@ -182,7 +182,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
       PGCullTraverser *pg_trav;
       DCAST_INTO_R(pg_trav, trav, true);
 
-      const LMatrix4f &transform = data._net_transform->get_mat();
+      CPT(TransformState) net_transform = data.get_net_transform(trav);
+      const LMatrix4f &transform = net_transform->get_mat();
 
       // Consider the cull bin this object is in.  Since the binning
       // affects the render order, we want bins that render later to