took care of the dos file format on polylight* files and untabified

panda/src/pgraph/polylightEffect.I

@@ -115,8 +115,8 @@ remove_light(const string &lightname) {
 INLINE bool PolylightEffect::
 remove_all() {
   LIGHTGROUP::const_iterator light_iter;
-  for (light_iter = _lightgroup.begin(); light_iter != _lightgroup.end(); light_iter++){
+  for (light_iter = _lightgroup.begin(); light_iter != _lightgroup.end(); light_iter++){
-    string lightname = light_iter->first;
+    string lightname = light_iter->first;
     _lightgroup.erase(lightname);
   }
   return true;
@@ -156,7 +156,7 @@ get_weight() const {
 //               _contribution_type is a string that controls how
 //               this division occurs.
 //               "proximal" : A light only contributes if the node 
-//				 is inside its volume
+//               is inside its volume
 //               "all" : All lights added to the effect are used in
 //               division irrespective of their light volumes
 ////////////////////////////////////////////////////////////////////

panda/src/pgraph/polylightEffect.cxx

@@ -42,94 +42,94 @@ make() {
 ////////////////////////////////////////////////////////////////////
 //     Function: PolylightEffect::do_poly_light
 //       Access: Public
-//  Description: Gets the node's position and based on distance from 
+//  Description: Gets the node's position and based on distance from
 //  lights in the lightgroup calculates the color to be modulated in
 ////////////////////////////////////////////////////////////////////
 CPT(RenderAttrib) PolylightEffect::
 do_poly_light(const CullTraverserData *data, const TransformState *node_transform) const {
   float r,g,b; // To hold the color calculation
   float dist; // To calculate the distance of each light from the node
-  float light_scale = 1.0; // Variable to calculate attenuation 
+  float light_scale = 1.0; // Variable to calculate attenuation
   float fd; // Variable for quadratic attenuation
   float Rcollect = 0.0,Gcollect = 0.0,Bcollect = 0.0; // Color variables
   int num_lights = 0; // Keep track of number of lights for division
   r = 0.0;
   g = 0.0;
   b = 0.0;
-  LIGHTGROUP::const_iterator light_iter; 
+  LIGHTGROUP::const_iterator light_iter;
   // Cycle through all the lights in this effect's lightgroup
-  for (light_iter = _lightgroup.begin(); light_iter != _lightgroup.end(); light_iter++){
+  for (light_iter = _lightgroup.begin(); light_iter != _lightgroup.end(); light_iter++){
-    const PolylightNode *light = DCAST(PolylightNode,light_iter->second.node()); 
+    const PolylightNode *light = DCAST(PolylightNode,light_iter->second.node());
-	// light holds the current PolylightNode
+    // light holds the current PolylightNode
-	if(light->is_enabled()) { // if enabled get all the properties
+    if(light->is_enabled()) { // if enabled get all the properties
-	  float light_radius = light->get_radius();
+      float light_radius = light->get_radius();
-	  PolylightNode::Attenuation_Type light_attenuation = light->get_attenuation();
+      PolylightNode::Attenuation_Type light_attenuation = light->get_attenuation();
-	  float light_a0 = light->get_a0();
+      float light_a0 = light->get_a0();
-	  float light_a1 = light->get_a1();
+      float light_a1 = light->get_a1();
-	  float light_a2 = light->get_a2();
+      float light_a2 = light->get_a2();
-	  if(light_a0 == 0 && light_a1 == 0 && light_a2 == 0) { // To prevent division by zero
+      if(light_a0 == 0 && light_a1 == 0 && light_a2 == 0) { // To prevent division by zero
-        light_a0 = 1.0;
+        light_a0 = 1.0;
-	  }
+      }
-	  Colorf light_color;
+      Colorf light_color;
-	  if(light->is_flickering()) { // If flickering, modify color
+      if(light->is_flickering()) { // If flickering, modify color
-	    light_color = light->flicker();
+        light_color = light->flicker();
-	  }
+      }
-	  else {
+      else {
-	    light_color = light->get_color();
+        light_color = light->get_color();
-	  }
+      }
-	
+
-	  // Calculate the distance of the node from the light
+      // Calculate the distance of the node from the light
-	  //dist = light_iter->second->get_distance(data->_node_path.get_node_path());
+      //dist = light_iter->second->get_distance(data->_node_path.get_node_path());
-      const NodePath lightnp = light_iter->second;
+      const NodePath lightnp = light_iter->second;
-      LPoint3f point = data->_node_path.get_node_path().get_relative_point(lightnp,
+      LPoint3f point = data->_node_path.get_node_path().get_relative_point(lightnp,
-        light->get_pos());
+        light->get_pos());
-      dist = (point - _effect_center).length();
+      dist = (point - _effect_center).length();
-
+
-	  if(dist < light_radius) { // If node is in range of this light
+      if(dist < light_radius) { // If node is in range of this light
-        if(light_attenuation == PolylightNode::ALINEAR) {
+        if(light_attenuation == PolylightNode::ALINEAR) {
-		  light_scale = (light_radius - dist)/light_radius;
+          light_scale = (light_radius - dist)/light_radius;
-	    }
+        }
-	    else if(light_attenuation == PolylightNode::AQUADRATIC) {
+        else if(light_attenuation == PolylightNode::AQUADRATIC) {
-	      fd = 1.0 / (light_a0 + light_a1 * dist + light_a2 * dist * dist);
+          fd = 1.0 / (light_a0 + light_a1 * dist + light_a2 * dist * dist);
-		  if(fd < 1.0) {
+          if(fd < 1.0) {
-		    light_scale = fd;
+            light_scale = fd;
-		  }
+          }
-		  else {
+          else {
-		    light_scale = 1.0;
+            light_scale = 1.0;
-		  }
+          }
-		}
+        }
-        else {
+        else {
-          light_scale = 1.0;
+          light_scale = 1.0;
-        }
+        }
-        // Keep accumulating each lights contribution... we divide by 
+        // Keep accumulating each lights contribution... we divide by
-		// number of lights later.
+        // number of lights later.
-	    Rcollect += light_color[0] * light_scale;
+        Rcollect += light_color[0] * light_scale;
-	    Gcollect += light_color[1] * light_scale;
+        Gcollect += light_color[1] * light_scale;
-	    Bcollect += light_color[2] * light_scale;
+        Bcollect += light_color[2] * light_scale;
-	    num_lights++;
+        num_lights++;
-	  } // if dist< radius
+      } // if dist< radius
-	} // if light is enabled
+    } // if light is enabled
-  } // for all lights
+  } // for all lights
-  
+
-
+
-  if( _contribution_type == CALL) {
+  if( _contribution_type == CALL) {
-    // Sometimes to prevent snapping of color at light volume boundaries
+    // Sometimes to prevent snapping of color at light volume boundaries
-	// just divide total contribution by all the lights in the effect
+    // just divide total contribution by all the lights in the effect
-	// whether or not they contribute color
+    // whether or not they contribute color
-    num_lights = _lightgroup.size();
+    num_lights = _lightgroup.size();
-  }
+  }
-
+
-  if(num_lights == 0) {
+  if(num_lights == 0) {
-    num_lights = 1;
+    num_lights = 1;
-  }
+  }
-  Rcollect /= num_lights;
+  Rcollect /= num_lights;
-  Gcollect /= num_lights;
+  Gcollect /= num_lights;
-  Bcollect /= num_lights;
+  Bcollect /= num_lights;
-
+
-  r = (1.0 - _weight) + Rcollect * _weight;
+  r = (1.0 - _weight) + Rcollect * _weight;
-  g = (1.0 - _weight) + Gcollect * _weight;
+  g = (1.0 - _weight) + Gcollect * _weight;
-  b = (1.0 - _weight) + Bcollect * _weight;
+  b = (1.0 - _weight) + Bcollect * _weight;
-  
+
   return ColorScaleAttrib::make(LVecBase4f(r,g,b,1.0));
 }
 
@@ -155,21 +155,21 @@ compare_to_impl(const RenderEffect *other) const {
   DCAST_INTO_R(ta, other, 0);
 
   if (_enabled != ta->_enabled) {
-	  return _enabled ? 1 : -1;
+      return _enabled ? 1 : -1;
+  }
+
+  if (_contribution_type != ta->_contribution_type) {
+    return _contribution_type < ta->_contribution_type ? -1 : 1;
   }
 
-  if (_contribution_type != ta->_contribution_type) {
-    return _contribution_type < ta->_contribution_type ? -1 : 1;
-  }
- 
   if (_weight != ta->_weight) {
-	return _weight < ta->_weight ? -1 :1;
+    return _weight < ta->_weight ? -1 :1;
+  }
+
+  if (_lightgroup != ta->_lightgroup) {
+    return _lightgroup < ta->_lightgroup ? -1 : 1;
   }
 
-  if (_lightgroup != ta->_lightgroup) {
-    return _lightgroup < ta->_lightgroup ? -1 : 1;
-  }
- 
   return 0;
 }
 

panda/src/pgraph/polylightEffect.h

@@ -20,7 +20,7 @@
 #define POLYLIGHTEFFECT_H
 
 #include "pandabase.h"
-
+
 
 #include "renderEffect.h"
 #include "luse.h"
@@ -33,16 +33,16 @@
 ////////////////////////////////////////////////////////////////////
 //       Class : PolylightEffect
 // Description : A PolylightEffect can be used on a node to define a
-//				 LightGroup  for that node. A LightGroup contains 
+//               LightGroup  for that node. A LightGroup contains
-//               Polylights which are essentially nodes that add 
+//               Polylights which are essentially nodes that add
-//			     color to the polygons of a model based on distance.
+//               color to the polygons of a model based on distance.
-//				 PolylightNode is a cheap way to get lighting effects
+//               PolylightNode is a cheap way to get lighting effects
 //               specially for night scenes
 ////////////////////////////////////////////////////////////////////
 class EXPCL_PANDA PolylightEffect : public RenderEffect {
 private:
   INLINE PolylightEffect();
-  
+
 
 PUBLISHED:
   enum Contrib_Type {
@@ -58,7 +58,7 @@ PUBLISHED:
   INLINE bool remove_all();
   INLINE bool set_weight(float w);
   INLINE float get_weight() const;
-  INLINE bool set_contrib(Contrib_Type type);  
+  INLINE bool set_contrib(Contrib_Type type);
   INLINE Contrib_Type get_contrib() const;
   INLINE bool is_enabled()const;
   INLINE void set_effect_center(LPoint3f effect_center);
@@ -77,7 +77,7 @@ private:
   typedef pmap<string, NodePath> LIGHTGROUP;
   LIGHTGROUP _lightgroup;
   LPoint3f _effect_center;
-  
+
 
 public:
   static TypeHandle get_class_type() {

panda/src/pgraph/polylightNode.cxx

@@ -75,37 +75,37 @@ Colorf PolylightNode::flicker() const {
   g = color[1];
   b = color[2];
   float variation= 0.0;
-  
+
   if(_flicker_type == FRANDOM) {
     //srand((int)ClockObject::get_global_clock()->get_frame_time());
     variation = (rand()%100);// * ClockObject::get_global_clock()->get_dt();
-	variation /= 100.0;
+    variation /= 100.0;
-	//printf("Random Variation: %f\n",variation);
+    //printf("Random Variation: %f\n",variation);
-	variation += _offset;
+    variation += _offset;
-	variation *= _scale;
+    variation *= _scale;
   }
   else if(_flicker_type == FSIN) {
-	double now = ClockObject::get_global_clock()->get_frame_time();
+    double now = ClockObject::get_global_clock()->get_frame_time();
     variation = sinf(now*_sin_freq);// * ClockObject::get_global_clock()->get_dt();
-	//printf("Variation: %f\n",variation);
+    //printf("Variation: %f\n",variation);
-	variation += _offset;
+    variation += _offset;
-	variation *= _scale;
+    variation *= _scale;
   }
   else if(_flicker_type == FCUSTOM) {
     // fixed point list of variation values coming soon...
     //double index = (ClockObject::get_global_clock()->get_frame_time() % len(fixed_points)) *  ClockObject::get_global_clock()->get_dt();
-	//index *= _speed;
+    //index *= _speed;
-	/*if(!(int)index > len(fixed_points) {
+    /*if(!(int)index > len(fixed_points) {
-	  variation = _fixed_points[(int)index];
+      variation = _fixed_points[(int)index];
-	  variation += _offset;
+      variation += _offset;
-	  variation *= _scale;
+      variation *= _scale;
-	}*/
+    }*/
   }
   //printf("Variation: %f\n",variation);
   r+=variation;
   g+=variation;
   b+=variation;
- 
+
   /* CLAMPING
   if(fabs(r - color[0]) > 0.5 || fabs(g - color[1]) > 0.5 || fabs(b - color[2]) > 0.5) {
     r = color[0];
@@ -126,7 +126,7 @@ Colorf PolylightNode::flicker() const {
 //
 //               Two PolylightNodes are considered equivalent if they
 //               consist of exactly the same properties
-//				 Otherwise, they are different; different
+//               Otherwise, they are different; different
 //               PolylightNodes will be ranked in a consistent but
 //               undefined ordering; the ordering is useful only for
 //               placing the PolylightNodes in a sorted container like an
@@ -134,64 +134,64 @@ Colorf PolylightNode::flicker() const {
 ////////////////////////////////////////////////////////////////////
 int PolylightNode::
 compare_to(const PolylightNode &other) const {
-  
+
   if (_enabled != other._enabled) {
-	return _enabled ? 1 :-1;
+    return _enabled ? 1 :-1;
   }
 
   if (_radius != other._radius) {
-	return _radius < other._radius ? -1 :1;
+    return _radius < other._radius ? -1 :1;
   }
   LVecBase3f position = get_pos();
   LVecBase3f other_position = other.get_pos();
   if (position != other_position) {
-	return position < other_position ? -1 :1;
+    return position < other_position ? -1 :1;
   }
 
   Colorf color = get_color();
   Colorf other_color = other.get_color();
   if (color != other_color) {
-	return color < other_color ? -1 :1;
+    return color < other_color ? -1 :1;
   }
 
   if (_attenuation_type != other._attenuation_type) {
-	return _attenuation_type < other._attenuation_type ? -1 :1;
+    return _attenuation_type < other._attenuation_type ? -1 :1;
   }
 
   if (_a0 != other._a0) {
-	return _a0 < other._a0 ? -1 :1;
+    return _a0 < other._a0 ? -1 :1;
   }
 
   if (_a1 != other._a1) {
-	return _a1 < other._a1 ? -1 :1;
+    return _a1 < other._a1 ? -1 :1;
   }
 
   if (_a2 != other._a2) {
-	return _a2 < other._a2 ? -1 :1;
+    return _a2 < other._a2 ? -1 :1;
   }
 
   if (_flickering != other._flickering) {
-	return _flickering ? 1 :-1;
+    return _flickering ? 1 :-1;
   }
 
   if (_flicker_type != other._flicker_type) {
-	return _flicker_type < other._flicker_type ? -1 :1;
+    return _flicker_type < other._flicker_type ? -1 :1;
   }
 
   if (_offset != other._offset) {
-	return _offset < other._offset ? -1 :1;
+    return _offset < other._offset ? -1 :1;
   }
 
   if (_scale != other._scale) {
-	return _scale < other._scale ? -1 :1;
+    return _scale < other._scale ? -1 :1;
   }
 
   if (_step_size != other._step_size) {
-	return _step_size < other._step_size ? -1 :1;
+    return _step_size < other._step_size ? -1 :1;
   }
 
   if (_sin_freq != other._sin_freq) {
-	return _sin_freq < other._sin_freq ? -1 :1;
+    return _sin_freq < other._sin_freq ? -1 :1;
   }
 
 
@@ -282,7 +282,7 @@ fillin(DatagramIterator &scan, BamReader *manager) {
 ////////////////////////////////////////////////////////////////////
 //     Function: PolylightNode::output
 //       Access: Public, Virtual
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 void PolylightNode::
 output(ostream &out) const {

panda/src/pgraph/polylightNode.h

@@ -38,14 +38,14 @@ class EXPCL_PANDA PolylightNode : public PandaNode{
 
 PUBLISHED:
   /*
-  // This was the old constructor... interrogate would generate a 
+  // This was the old constructor... interrogate would generate a
-  // separate wrapper for each parameter... so its better to 
+  // separate wrapper for each parameter... so its better to
   // have a simpler constructor and require the programmer
   // to use set_* methods.
   PolylightNode(const string &name, float x = 0.0, float y = 0.0, float z = 0.0,
-	float r = 1.0, float g = 1.0, float b = 1.0,
+    float r = 1.0, float g = 1.0, float b = 1.0,
-	float radius=50.0, string attenuation_type= "linear",
+    float radius=50.0, string attenuation_type= "linear",
-	bool flickering =false, string flicker_type="random");
+    bool flickering =false, string flicker_type="random");
   */
 
   enum Flicker_Type {
@@ -103,7 +103,7 @@ PUBLISHED:
 public:
   Colorf flicker() const;
 
-  
+
 private:
   bool _enabled;
   LVecBase3f _position;
@@ -121,7 +121,7 @@ private:
   float _sin_freq;
   //float _speed;
   //float fixed_points
-  
+
 
 public:
   static void register_with_read_factory();