work in progress, working on jump clipping against a wall

panda/src/collide/collisionHandlerPusher.cxx

@@ -245,12 +245,16 @@ handle_entries() {
           }
           #endif
           
+          // This is the part where the node actually gets moved:
           CPT(TransformState) trans = def._target.get_transform();
           LVecBase3f pos = trans->get_pos();
           pos += net_shove * trans->get_mat();
           def._target.set_transform(trans->set_pos(pos));
           def.updated_transform();
           
+          // We call this to allow derived classes to do other
+          // fix-ups as they see fit:
+          apply_net_shove(def, net_shove, force_normal);
           apply_linear_force(def, force_normal);
         }
       }
@@ -260,11 +264,23 @@ handle_entries() {
   return okflag;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: CollisionHandlerPusher::apply_net_shove
+//       Access: Protected, Virtual
+//  Description: This is an optional hook for derived classes to do
+//               some work with the ColliderDef and the force vector.
+////////////////////////////////////////////////////////////////////
+void CollisionHandlerPusher::
+apply_net_shove(ColliderDef &def, const LVector3f &net_shove, 
+    const LVector3f &force_normal) {
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: CollisionHandlerPusher::apply_linear_force
 //       Access: Protected, Virtual
-//  Description: 
+//  Description: This is an optional hook for derived classes to do
+//               some work with the ColliderDef and the force vector.
 ////////////////////////////////////////////////////////////////////
 void CollisionHandlerPusher::
-apply_linear_force(ColliderDef &, const LVector3f &) {
+apply_linear_force(ColliderDef &def, const LVector3f &force_normal) {
 }

panda/src/collide/collisionHandlerPusher.h

@@ -40,6 +40,7 @@ PUBLISHED:
 
 protected:
   virtual bool handle_entries();
+  virtual void apply_net_shove(ColliderDef &def, const LVector3f &net_shove, const LVector3f &force_normal);
   virtual void apply_linear_force(ColliderDef &def, const LVector3f &force);
 
 private:

panda/src/physics/physicsCollisionHandler.I

@@ -15,3 +15,36 @@
 // [email protected] .
 //
 ////////////////////////////////////////////////////////////////////
+
+
+INLINE void PhysicsCollisionHandler::
+set_almost_stationary_speed(float speed) {
+  _almost_stationary_speed = speed;
+}
+
+INLINE float PhysicsCollisionHandler::
+get_almost_stationary_speed() {
+  return _almost_stationary_speed;
+}
+
+INLINE void PhysicsCollisionHandler::
+set_static_friction_coef(float coef) {
+  _static_friction_coef = coef;
+}
+
+INLINE float PhysicsCollisionHandler::
+get_static_friction_coef() {
+  return _static_friction_coef;
+}
+
+INLINE void PhysicsCollisionHandler::
+set_dynamic_friction_coef(float coef) {
+  _dynamic_friction_coef = coef;
+}
+
+INLINE float PhysicsCollisionHandler::
+get_dynamic_friction_coef() {
+  return _dynamic_friction_coef;
+}
+
+

panda/src/physics/physicsCollisionHandler.cxx

@@ -32,6 +32,9 @@ TypeHandle PhysicsCollisionHandler::_type_handle;
 ////////////////////////////////////////////////////////////////////
 PhysicsCollisionHandler::
 PhysicsCollisionHandler() {
+  _almost_stationary_speed = 0.1f;
+  _static_friction_coef=0.9f;
+  _dynamic_friction_coef=0.5f;
   set_horizontal(false);
 }
 
@@ -44,6 +47,46 @@ PhysicsCollisionHandler::
 ~PhysicsCollisionHandler() {
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: PhysicsCollisionHandler::apply_friction
+//       Access: 
+//  Description: The vel parameter will be modified in place to
+//               account for friction.
+////////////////////////////////////////////////////////////////////
+void PhysicsCollisionHandler::
+apply_friction(ColliderDef &def, LVector3f& vel, const LVector3f& force, float angle) {
+  if (vel!=LVector3f::zero()) {
+    float friction_coefficient=0.0f;
+    // Determine the friction:
+    if (fabs(force.dot(LVector3f::unit_z())<0.5f)) {
+      // ...The force is nearly horizontal, it is probably a wall.
+      physics_debug("  wall friction");
+      friction_coefficient=0.0f;
+    } else if (vel.length()<_almost_stationary_speed) {
+      physics_debug("  static friction");
+      friction_coefficient=_static_friction_coef;
+    } else {
+      physics_debug("  dynamic friction");
+      friction_coefficient=_dynamic_friction_coef;
+    }
+    // Apply the friction:
+    physics_debug("  vel pre  friction "<<vel<<" len "<<vel.length());
+    float friction=friction_coefficient*angle;
+    physics_debug("  friction "<<friction);
+    if (friction<0.0f && friction>1.0f) {
+      cerr<<"\n\nfriction error "<<friction<<endl;
+      friction=1.0f;
+    }
+    #if 0
+    float dt=ClockObject::get_global_clock()->get_dt();
+    vel *= (1.0f-friction) * dt * dt;
+    #else
+    vel *= 1.0f-friction;
+    #endif
+    physics_debug("  vel post friction "<<vel<<" len "<<vel.length());
+  }
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: PhysicsCollisionHandler::apply_linear_force
 //       Access: Protected, Virtual
@@ -51,7 +94,15 @@ PhysicsCollisionHandler::
 ////////////////////////////////////////////////////////////////////
 void PhysicsCollisionHandler::
 apply_linear_force(ColliderDef &def, const LVector3f &force) {
-  CollisionHandlerPusher::apply_linear_force(def, force);
+}
+////////////////////////////////////////////////////////////////////
+//     Function: PhysicsCollisionHandler::apply_net_shove
+//       Access: Protected, Virtual
+//  Description: 
+////////////////////////////////////////////////////////////////////
+void PhysicsCollisionHandler::
+apply_net_shove(ColliderDef &def, const LVector3f& net_shove, const LVector3f &force) {
+  CollisionHandlerPusher::apply_net_shove(def, net_shove, force);
   if (force == LVector3f::zero()) {
     return;
   }
@@ -66,6 +117,7 @@ apply_linear_force(ColliderDef &def, const LVector3f &force) {
   }
   physics_debug("apply_linear_force() {");
   physics_debug("  vel            "<<vel<<" len "<<vel.length());
+  physics_debug("  net_shove      "<<net_shove<<" len "<<net_shove.length());
   physics_debug("  force          "<<force<<" len "<<force.length());
   LVector3f old_vel=vel;
 
@@ -77,7 +129,7 @@ apply_linear_force(ColliderDef &def, const LVector3f &force) {
   //NodePath np(def._node);
   //CPT(TransformState) trans = np.get_net_transform();
   //adjustment=adjustment*trans->get_mat();
-  physics_debug("  adjustment trn "<<adjustment<<" len "<<adjustment.length());
+  //physics_debug("  adjustment trn "<<adjustment<<" len "<<adjustment.length());
 
   adjustment=adjustment*actor->get_physics_object()->get_lcs();
   physics_debug("  adjustment lcs "<<adjustment<<" len "<<adjustment.length());
@@ -94,37 +146,16 @@ apply_linear_force(ColliderDef &def, const LVector3f &force) {
     physics_debug("  positive contact");
     adjustment*=adjustmentLength;
     physics_debug("  adjustment mul "<<adjustment<<" len "<<adjustment.length());
+    
     // This adjustment to our velocity will not reflect us off the surface,
     // but will deflect us parallel (or tangent) to the surface:
-    vel+=adjustment;
-    physics_debug("  vel "<<vel<<" len "<<vel.length());
-    if (vel!=LVector3f::zero()) {
-      const float almostStationary=0.1f;
-      float frictionCoefficient=0.0f;
-      // Determine the friction:
-      if (vel.length()<almostStationary) {
-        physics_debug("  static friction");
-        frictionCoefficient=0.9f;
-      } else {
-        physics_debug("  dynamic friction");
-        frictionCoefficient=0.5f;
-      }
-      // Apply the friction:
-      physics_debug("  vel pre  friction "<<vel<<" len "<<vel.length());
-      float friction=frictionCoefficient*angle;
-      physics_debug("  friction "<<friction);
-      if (friction<0.0f && friction>1.0f) {
-        cerr<<"\n\nfriction error "<<friction<<endl;
-        friction=1.0f;
-      }
-      #if 0
-      float dt=ClockObject::get_global_clock()->get_dt();
-      vel *= (1.0f-friction) * dt * dt;
-      #else
-      vel *= 1.0f-friction;
-      #endif
-      physics_debug("  vel post friction "<<vel<<" len "<<vel.length());
+    if (normalize(net_shove).dot(LVector3f::unit_z())>0.5) {
+        vel=LVector3f::zero();
     }
+    //vel+=adjustment;
+    physics_debug("  vel+adj "<<vel<<" len "<<vel.length());
+    
+    //apply_friction(def, vel, force, angle);
   } else if (adjustmentLength==0.0f) {
     physics_debug("  brushing contact");
   } else {
@@ -132,9 +163,15 @@ apply_linear_force(ColliderDef &def, const LVector3f &force) {
   }
 
   #ifndef NDEBUG //[
-  if (vel.length() > old_vel.length()) {
+  if (IS_THRESHOLD_EQUAL(vel.length(), old_vel.length(), 0.0001f)) {
+    // This is a check to see if vel is staying the same:
+    physics_debug("  vel is about the same length:  "<<vel.length()<<" ~ "<<old_vel.length());
+  } else if (vel.length() > old_vel.length()) {
     // This is a check to avoid adding engergy:
-    physics_debug("  vel.length() > old_vel.length()  "<<vel.length()<<" > "<<old_vel.length());
+    physics_debug("  vel got larger  "<<vel.length()<<" > "<<old_vel.length());
+  } else {
+    // This is a check to avoid loosing engergy:
+    physics_debug("  vel got smaller  "<<vel.length()<<" < "<<old_vel.length());
   }
   if (vel.length() > 10.0f) {
     // This is a check to see if the velocity is higher than I expect it

panda/src/physics/physicsCollisionHandler.h

@@ -33,8 +33,24 @@ class EXPCL_PANDAPHYSICS PhysicsCollisionHandler : public CollisionHandlerPusher
 PUBLISHED:
   PhysicsCollisionHandler();
   virtual ~PhysicsCollisionHandler();
+  
+  // These setters and getter are a bit of a hack:
+  INLINE void set_almost_stationary_speed(float speed);
+  INLINE float get_almost_stationary_speed();
+  
+  INLINE void set_static_friction_coef(float coef);
+  INLINE float get_static_friction_coef();
+  
+  INLINE void set_dynamic_friction_coef(float coef);
+  INLINE float get_dynamic_friction_coef();
 
 protected:
+  float _almost_stationary_speed;
+  float _static_friction_coef;
+  float _dynamic_friction_coef;
+
+  void apply_friction(ColliderDef &def, LVector3f &vel, const LVector3f& force, float angle);
+  virtual void apply_net_shove(ColliderDef &def, const LVector3f &net_shove, const LVector3f &force_normal);
   virtual void apply_linear_force(ColliderDef &def, const LVector3f &force);
 
 public: