Remove old MLightVector TexGen mode and FFP-based normal mapping

panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx

@@ -3751,7 +3751,7 @@ update_standard_texture_bindings() {
 
     switch (mode) {
     case TexGenAttrib::M_off:
-    case TexGenAttrib::M_light_vector:
+    case TexGenAttrib::M_unused2:
       set_texture_stage_state(si, D3DTSS_TEXCOORDINDEX, texcoord_index);
       break;
 

panda/src/glstuff/glGraphicsStateGuardian_src.cxx

@@ -9645,7 +9645,7 @@ do_issue_tex_gen() {
     TexGenAttrib::Mode mode = _target_tex_gen->get_mode(stage);
     switch (mode) {
     case TexGenAttrib::M_off:
-    case TexGenAttrib::M_light_vector:
+    case TexGenAttrib::M_unused2:
       break;
 
     case TexGenAttrib::M_eye_sphere_map:

panda/src/gobj/geomEnums.h

@@ -134,11 +134,6 @@ PUBLISHED:
 
     // The union of the above shade model types.
     GR_shade_model_bits     = 0x06000,
-
-    // If there is a TexGenAttrib in effect with M_light_vector
-    // enabled, meaning we need to generate the tangent space light
-    // vector as the texture coordinates.
-    GR_texcoord_light_vector = 0x08000,
   };
 
   // The shade model specifies whether the per-vertex colors and

panda/src/pgraph/cullableObject.cxx

@@ -38,7 +38,6 @@ PStatCollector CullableObject::_munge_geom_pcollector("*:Munge:Geom");
 PStatCollector CullableObject::_munge_sprites_pcollector("*:Munge:Sprites");
 PStatCollector CullableObject::_munge_sprites_verts_pcollector("*:Munge:Sprites:Verts");
 PStatCollector CullableObject::_munge_sprites_prims_pcollector("*:Munge:Sprites:Prims");
-PStatCollector CullableObject::_munge_light_vector_pcollector("*:Munge:Light Vector");
 PStatCollector CullableObject::_sw_sprites_pcollector("SW Sprites");
 
 TypeHandle CullableObject::_type_handle;
@@ -123,23 +122,6 @@ munge_geom(GraphicsStateGuardianBase *gsg,
       }
     }
 
-    bool cpu_animated = false;
-
-    if (unsupported_bits & Geom::GR_texcoord_light_vector) {
-      // If we have to compute the light vector, we have to animate
-      // the vertices in the CPU--and we have to do it before we call
-      // munge_geom(), which might lose the tangent and binormal.
-      CPT(GeomVertexData) animated_vertices =
-        _munged_data->animate_vertices(force, current_thread);
-      if (animated_vertices != _munged_data) {
-        cpu_animated = true;
-        swap(_munged_data, animated_vertices);
-      }
-      if (!munge_texcoord_light_vector(traverser, force)) {
-        return false;
-      }
-    }
-
     // Now invoke the munger to ensure the resulting geometry is in
     // a GSG-friendly form.
     if (!munger->munge_geom(_geom, _munged_data, force, current_thread)) {
@@ -150,17 +132,17 @@ munge_geom(GraphicsStateGuardianBase *gsg,
     DCAST_INTO_R(state_munger, munger, false);
     _state = state_munger->munge_state(_state);
 
-    if (!cpu_animated) {
-      // If there is any animation left in the vertex data after it
-      // has been munged--that is, we couldn't arrange to handle the
-      // animation in hardware--then we have to calculate that
-      // animation now.
-      CPT(GeomVertexData) animated_vertices =
-        _munged_data->animate_vertices(force, current_thread);
-      if (animated_vertices != _munged_data) {
-        cpu_animated = true;
-        swap(_munged_data, animated_vertices);
-      }
+    // If there is any animation left in the vertex data after it
+    // has been munged--that is, we couldn't arrange to handle the
+    // animation in hardware--then we have to calculate that
+    // animation now.
+    bool cpu_animated = false;
+
+    CPT(GeomVertexData) animated_vertices =
+      _munged_data->animate_vertices(force, current_thread);
+    if (animated_vertices != _munged_data) {
+      cpu_animated = true;
+      swap(_munged_data, animated_vertices);
     }
 
 #ifndef NDEBUG
@@ -599,109 +581,6 @@ munge_points_to_quads(const CullTraverser *traverser, bool force) {
   return true;
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: CullableObject::munge_texcoord_light_vector
-//       Access: Private
-//  Description: Generates the vector from each vertex to the
-//               indicated light as a 3-d texture coordinate.
-//
-//               This may replace _geom, _munged_data, and _state.
-////////////////////////////////////////////////////////////////////
-bool CullableObject::
-munge_texcoord_light_vector(const CullTraverser *traverser, bool force) {
-  Thread *current_thread = traverser->get_current_thread();
-  PStatTimer timer(_munge_light_vector_pcollector, current_thread);
-
-  if (_net_transform->is_singular()) {
-    // If we're under a singular transform, never mind.
-    return true;
-  }
-
-  if (!_munged_data->has_column(InternalName::get_vertex()) ||
-      !_munged_data->has_column(InternalName::get_normal())) {
-    // No vertex or normal; can't compute light vector.
-    return true;
-  }
-
-  CPT(TexGenAttrib) tex_gen = DCAST(TexGenAttrib, _state->get_attrib(TexGenAttrib::get_class_slot()));
-  nassertr(tex_gen != (TexGenAttrib *)NULL, false);
-
-  const TexGenAttrib::LightVectors &light_vectors = tex_gen->get_light_vectors();
-  TexGenAttrib::LightVectors::const_iterator lvi;
-  for (lvi = light_vectors.begin();
-       lvi != light_vectors.end();
-       ++lvi) {
-    TextureStage *stage = (*lvi);
-    NodePath light = tex_gen->get_light(stage);
-    if (light.is_empty()) {
-      // If a particular light isn't specified in the TexGenAttrib,
-      // use the most important light in the current state.
-      CPT(RenderAttrib) attrib = _state->get_attrib(LightAttrib::get_class_slot());
-      if (attrib != (RenderAttrib *)NULL) {
-        CPT(LightAttrib) la = DCAST(LightAttrib, attrib);
-        light = la->get_most_important_light();
-      }
-    }
-    if (!light.is_empty()) {
-      string source_name = tex_gen->get_source_name(stage);
-      Light *light_obj = light.node()->as_light();
-      nassertr(light_obj != (Light *)NULL, false);
-
-      // Determine the names of the tangent and binormal columns
-      // associated with the stage's texcoord name.
-      PT(InternalName) tangent_name = InternalName::get_tangent_name(source_name);
-      PT(InternalName) binormal_name = InternalName::get_binormal_name(source_name);
-
-      PT(InternalName) texcoord_name = stage->get_texcoord_name();
-
-      if (_munged_data->has_column(tangent_name) &&
-          _munged_data->has_column(binormal_name)) {
-
-        if (!force && !_munged_data->request_resident()) {
-          // The data isn't resident; give up.
-          return false;
-        }
-
-        // Create a new column for the new texcoords.
-        PT(GeomVertexData) new_data = _munged_data->replace_column
-          (texcoord_name, 3, Geom::NT_stdfloat, Geom::C_texcoord);
-        _munged_data = new_data;
-
-        // Remove this TexGen stage from the state, since we're handling
-        // it now.
-        _state = _state->add_attrib(tex_gen->remove_stage(stage));
-
-        // Get the transform from the light to the object.
-        CPT(TransformState) light_transform =
-          _net_transform->invert_compose(light.get_net_transform());
-        const LMatrix4 &light_mat = light_transform->get_mat();
-
-        GeomVertexWriter texcoord(new_data, texcoord_name, current_thread);
-        GeomVertexReader vertex(new_data, InternalName::get_vertex(),
-                                current_thread);
-        GeomVertexReader tangent(new_data, tangent_name, current_thread);
-        GeomVertexReader binormal(new_data, binormal_name, current_thread);
-        GeomVertexReader normal(new_data, InternalName::get_normal(),
-                                current_thread);
-
-        while (!vertex.is_at_end()) {
-          LPoint3 p = vertex.get_data3();
-          LVector3 t = tangent.get_data3();
-          LVector3 b = binormal.get_data3();
-          LVector3 n = normal.get_data3();
-
-          LVector3 lv;
-          if (light_obj->get_vector_to_light(lv, p, light_mat)) {
-            texcoord.add_data3(lv.dot(t), lv.dot(b), lv.dot(n));
-          }
-        }
-      }
-    }
-  }
-
-  return true;
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: CullableObject::get_flash_cpu_state
 //       Access: Private, Static

panda/src/pgraph/cullableObject.h

@@ -89,7 +89,6 @@ public:
 
 private:
   bool munge_points_to_quads(const CullTraverser *traverser, bool force);
-  bool munge_texcoord_light_vector(const CullTraverser *traverser, bool force);
 
   static CPT(RenderState) get_flash_cpu_state();
   static CPT(RenderState) get_flash_hardware_state();
@@ -130,7 +129,6 @@ private:
   static PStatCollector _munge_sprites_pcollector;
   static PStatCollector _munge_sprites_verts_pcollector;
   static PStatCollector _munge_sprites_prims_pcollector;
-  static PStatCollector _munge_light_vector_pcollector;
   static PStatCollector _sw_sprites_pcollector;
 
 public:

panda/src/pgraph/nodePath.cxx

@@ -4359,38 +4359,6 @@ set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode, int priority) {
   node()->set_attrib(tga->add_stage(stage, mode), priority);
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: NodePath::set_tex_gen
-//       Access: Published
-//  Description: Enables automatic texture coordinate generation for
-//               the indicated texture stage.  This version of this
-//               method is useful when setting M_light_vector, which
-//               requires the name of the texture coordinate set that
-//               supplies the tangent and binormal, as well as the
-//               specific light to generate coordinates for.
-////////////////////////////////////////////////////////////////////
-void NodePath::
-set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode,
-            const string &source_name, const NodePath &light, int priority) {
-  nassertv_always(!is_empty());
-
-  const RenderAttrib *attrib =
-    node()->get_attrib(TexGenAttrib::get_class_slot());
-
-  CPT(TexGenAttrib) tga;
-
-  if (attrib != (const RenderAttrib *)NULL) {
-    priority = max(priority,
-                   node()->get_state()->get_override(TextureAttrib::get_class_slot()));
-    tga = DCAST(TexGenAttrib, attrib);
-
-  } else {
-    tga = DCAST(TexGenAttrib, TexGenAttrib::make());
-  }
-
-  node()->set_attrib(tga->add_stage(stage, mode, source_name, light), priority);
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: NodePath::set_tex_gen
 //       Access: Published
@@ -4500,28 +4468,6 @@ get_tex_gen(TextureStage *stage) const {
   return TexGenAttrib::M_off;
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: NodePath::get_tex_gen_light
-//       Access: Published
-//  Description: Returns the particular Light set for the indicated
-//               texgen mode's texture stage, or empty NodePath if no
-//               light is set.  This is only meaningful if the texgen
-//               mode (returned by get_tex_gen()) is M_light_vector.
-////////////////////////////////////////////////////////////////////
-NodePath NodePath::
-get_tex_gen_light(TextureStage *stage) const {
-  nassertr_always(!is_empty(), NodePath::fail());
-
-  const RenderAttrib *attrib =
-    node()->get_attrib(TexGenAttrib::get_class_slot());
-  if (attrib != (const RenderAttrib *)NULL) {
-    const TexGenAttrib *tga = DCAST(TexGenAttrib, attrib);
-    return tga->get_light(stage);
-  }
-
-  return NodePath();
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: NodePath::set_tex_projector
 //       Access: Published
@@ -4676,99 +4622,6 @@ project_texture(TextureStage *stage, Texture *tex, const NodePath &projector) {
   set_tex_projector(stage, NodePath(), projector);
 }
 
-
-////////////////////////////////////////////////////////////////////
-//     Function: NodePath::set_normal_map
-//       Access: Published
-//  Description: A convenience function to set up a normal map on this
-//               geometry.  This uses the single highest-priority
-//               light on the object only.  It also requires
-//               multitexture, and consumes at least two texture
-//               stages, in addition to what may already be in use.
-//
-//               The normal_map parameter is the texture that contains
-//               the normal map information (with a 3-d delta vector
-//               encoded into the r,g,b of each texel).  texcoord_name is
-//               the name of the texture coordinate set that contains
-//               the tangent and binormal we wish to use.  If
-//               preserve_color is true, then one additional texture
-//               stage is consumed to blend in the geometry's original
-//               vertex color.
-//
-//               Only one normal map may be in effect through this
-//               interface at any given time.
-////////////////////////////////////////////////////////////////////
-void NodePath::
-set_normal_map(Texture *normal_map, const string &texcoord_name,
-               bool preserve_color) {
-  clear_normal_map();
-
-  // First, we apply the normal map itself, to the bottom layer.
-  PT(TextureStage) normal_map_ts = new TextureStage("__normal_map");
-  normal_map_ts->set_texcoord_name(texcoord_name);
-  normal_map_ts->set_sort(-20);
-  normal_map_ts->set_mode(TextureStage::M_replace);
-  set_texture(normal_map_ts, normal_map);
-
-  // Then, we apply a normalization map, to normalize, per-pixel, the
-  // vector to the light.
-  PT(Texture) normalization_map = TexturePool::get_normalization_cube_map(32);
-  PT(TextureStage) normalization_map_ts = new TextureStage("__normalization_map");
-  normalization_map_ts->set_combine_rgb
-    (TextureStage::CM_dot3_rgb,
-     TextureStage::CS_texture, TextureStage::CO_src_color,
-     TextureStage::CS_previous, TextureStage::CO_src_color);
-  normalization_map_ts->set_texcoord_name("light_vector");
-  normalization_map_ts->set_sort(-15);
-  set_texture(normalization_map_ts, normalization_map);
-
-  // Finally, we enable M_light_vector texture coordinate generation.
-  set_tex_gen(normalization_map_ts, TexGenAttrib::M_light_vector,
-              texcoord_name, NodePath());
-
-  if (preserve_color) {
-    // One more stage to get back the original color.
-    PT(TextureStage) orig_color_ts = new TextureStage("__orig_color");
-    orig_color_ts->set_combine_rgb
-      (TextureStage::CM_modulate,
-       TextureStage::CS_primary_color, TextureStage::CO_src_color,
-       TextureStage::CS_previous, TextureStage::CO_src_color);
-    set_texture(orig_color_ts, normal_map);
-  }
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: NodePath::clear_normal_map
-//       Access: Published
-//  Description: Undoes the effect of a previous call to
-//               set_normal_map().
-////////////////////////////////////////////////////////////////////
-void NodePath::
-clear_normal_map() {
-  // Scan through the TextureStages, and if we find any whose name
-  // matches one of the stages that would have been left by
-  // set_normal_map(), remove it from the state.
-
-  CPT(RenderAttrib) attrib =
-    get_state()->get_attrib(TextureAttrib::get_class_slot());
-  if (attrib != (const RenderAttrib *)NULL) {
-    const TextureAttrib *ta = DCAST(TextureAttrib, attrib);
-    for (int i = 0; i < ta->get_num_on_stages(); i++) {
-      TextureStage *stage = ta->get_on_stage(i);
-      if (stage->get_name() == "__normal_map") {
-        clear_texture(stage);
-
-      } else if (stage->get_name() == "__normalization_map") {
-        clear_texture(stage);
-        clear_tex_gen(stage);
-
-      } else if (stage->get_name() == "__orig_color") {
-        clear_texture(stage);
-      }
-    }
-  }
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: NodePath::has_vertex_column
 //       Access: Published

panda/src/pgraph/nodePath.h

@@ -704,9 +704,6 @@ PUBLISHED:
   INLINE LVecBase3 get_tex_scale_3d(const NodePath &other, TextureStage *stage) const;
 
   void set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode, int priority = 0);
-  void set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode,
-                   const string &source_name, const NodePath &light,
-                   int priority = 0);
   void set_tex_gen(TextureStage *stage, RenderAttrib::TexGenMode mode,
                    const LTexCoord3 &constant_value,
                    int priority = 0);
@@ -714,7 +711,6 @@ PUBLISHED:
   void clear_tex_gen(TextureStage *stage);
   bool has_tex_gen(TextureStage *stage) const;
   RenderAttrib::TexGenMode get_tex_gen(TextureStage *stage) const;
-  NodePath get_tex_gen_light(TextureStage *stage) const;
 
   void set_tex_projector(TextureStage *stage, const NodePath &from, const NodePath &to,
                          int lens_index = 0);
@@ -727,10 +723,6 @@ PUBLISHED:
   void project_texture(TextureStage *stage, Texture *tex, const NodePath &projector);
   INLINE void clear_project_texture(TextureStage *stage);
 
-  void set_normal_map(Texture *normal_map, const string &texcoord_name = string(),
-                      bool preserve_color = false);
-  void clear_normal_map();
-
   INLINE bool has_texcoord(const string &texcoord_name) const;
   bool has_vertex_column(const InternalName *name) const;
   InternalNameCollection find_all_vertex_columns() const;

panda/src/pgraph/renderAttrib.h

@@ -131,7 +131,7 @@ PUBLISHED:
     // Typically, a statically-generated cube map will be in eye
     // space, while a dynamically-generated map will be in world
     // space.
-
+    //
     // Cube mapping is not supported on all hardware.
     M_world_cube_map,
     M_eye_cube_map,
@@ -153,7 +153,7 @@ PUBLISHED:
     // lower-right across the point's face.  Without this, each point
     // will have just a single uniform texture coordinate value across
     // its face.
-
+    //
     // Unfortunately, the generated texture coordinates are inverted
     // (upside-down) from Panda's usual convention, but this is what
     // the graphics card manufacturers decided to use.  You could use
@@ -163,16 +163,12 @@ PUBLISHED:
     // hardware sprites.
     M_point_sprite,
 
-    // M_light_vector generates special 3-d texture coordinates that
-    // represent the vector to a particular Light in the scene graph,
-    // expressed in each vertex's tangent space.  This is used to
-    // implement bumpmapping.  It is always computed on the CPU.
-
-    // This requires a Light to be specified to the TexGenAttrib.  It
-    // also requires each vertex to define a normal, as well as a
-    // tangent and binormal for the particular named texture
-    // coordinate set.
-    M_light_vector,
+    // M_light_vector generated special 3-d texture coordinates that
+    // represented the vector to a particular Light in the scene graph,
+    // expressed in each vertex's tangent space.  This has now been
+    // removed.  We need to reserve the slot in the enum, though, to
+    // make sure the following enum value still has the same value.
+    M_unused2,
 
     // M_constant generates the same fixed texture coordinates at each
     // vertex.  Not terribly useful, of course, except for certain

panda/src/pgraph/texGenAttrib.I

@@ -22,7 +22,6 @@
 INLINE TexGenAttrib::
 TexGenAttrib() :
   _num_point_sprites(0),
-  _num_light_vectors(0),
   _point_geom_rendering(0),
   _geom_rendering(0)
 {
@@ -39,7 +38,6 @@ TexGenAttrib(const TexGenAttrib &copy) :
   _stages(copy._stages),
   _no_texcoords(copy._no_texcoords),
   _num_point_sprites(copy._num_point_sprites),
-  _num_light_vectors(copy._num_light_vectors),
   _point_geom_rendering(copy._point_geom_rendering),
   _geom_rendering(copy._geom_rendering)
 {
@@ -62,22 +60,10 @@ get_geom_rendering(int geom_rendering) const {
   return geom_rendering | _geom_rendering;
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: TexGenAttrib::get_light_vectors
-//       Access: Public
-//  Description: Returns the set of TextureStages that have
-//               M_light_vector in effect, as well as the associated
-//               Lights.
-////////////////////////////////////////////////////////////////////
-INLINE const TexGenAttrib::LightVectors &TexGenAttrib::
-get_light_vectors() const {
-  return _light_vectors;
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::ModeDef::Constructor
 //       Access: Public
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE TexGenAttrib::ModeDef::
 ModeDef() :
@@ -88,7 +74,7 @@ ModeDef() :
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::ModeDef::compare_to
 //       Access: Public
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 INLINE int TexGenAttrib::ModeDef::
 compare_to(const TexGenAttrib::ModeDef &other) const {

panda/src/pgraph/texGenAttrib.cxx

@@ -28,7 +28,7 @@ int TexGenAttrib::_attrib_slot;
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::Destructor
 //       Access: Public, Virtual
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 TexGenAttrib::
 ~TexGenAttrib() {
@@ -84,7 +84,7 @@ make_default() {
 ////////////////////////////////////////////////////////////////////
 CPT(RenderAttrib) TexGenAttrib::
 add_stage(TextureStage *stage, TexGenAttrib::Mode mode) const {
-  nassertr(mode != M_light_vector && mode != M_constant, this);
+  nassertr(mode != M_constant, this);
 
   CPT(RenderAttrib) removed = remove_stage(stage);
   TexGenAttrib *attrib = new TexGenAttrib(*DCAST(TexGenAttrib, removed));
@@ -96,34 +96,6 @@ add_stage(TextureStage *stage, TexGenAttrib::Mode mode) const {
   return return_new(attrib);
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: TexGenAttrib::add_stage
-//       Access: Published, Static
-//  Description: Returns a new TexGenAttrib just like this one,
-//               with the indicated generation mode for the given
-//               stage.  If this stage already exists, its mode is
-//               replaced.
-//
-//               This variant also accepts source_name and light,
-//               which are only meaningful if mode is M_light_vector.
-////////////////////////////////////////////////////////////////////
-CPT(RenderAttrib) TexGenAttrib::
-add_stage(TextureStage *stage, TexGenAttrib::Mode mode, 
-          const string &source_name, const NodePath &light) const {
-  nassertr(mode == M_light_vector, this);
-
-  CPT(RenderAttrib) removed = remove_stage(stage);
-  TexGenAttrib *attrib = new TexGenAttrib(*DCAST(TexGenAttrib, removed));
-
-  ModeDef &mode_def = attrib->_stages[stage];
-  mode_def._mode = mode;
-  mode_def._source_name = source_name;
-  mode_def._light = light;
-  attrib->record_stage(stage, mode_def);
-
-  return return_new(attrib);
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::add_stage
 //       Access: Published, Static
@@ -136,7 +108,7 @@ add_stage(TextureStage *stage, TexGenAttrib::Mode mode,
 //               only meaningful if mode is M_constant.
 ////////////////////////////////////////////////////////////////////
 CPT(RenderAttrib) TexGenAttrib::
-add_stage(TextureStage *stage, TexGenAttrib::Mode mode, 
+add_stage(TextureStage *stage, TexGenAttrib::Mode mode,
           const LTexCoord3 &constant_value) const {
   nassertr(mode == M_constant, this);
 
@@ -174,12 +146,6 @@ remove_stage(TextureStage *stage) const {
     if (attrib->_num_point_sprites == 0) {
       attrib->_point_geom_rendering &= ~Geom::GR_point_sprite;
     }
-  } else if (mode == M_light_vector) {
-    attrib->_light_vectors.erase(stage);
-    attrib->_num_light_vectors--;
-    if (attrib->_num_light_vectors == 0) {
-      attrib->_geom_rendering &= ~Geom::GR_texcoord_light_vector;
-    }
   }
   return return_new(attrib);
 }
@@ -238,43 +204,6 @@ has_gen_texcoord_stage(TextureStage *stage) const {
   return (mi != _no_texcoords.end());
 }
 
-////////////////////////////////////////////////////////////////////
-//     Function: TexGenAttrib::get_source_name
-//       Access: Published
-//  Description: Returns the source name associated with the named
-//               texture stage, or the empty string if no name is
-//               associated with the indicated stage.  This is only
-//               meaningful if the mode is M_light_vector, in which
-//               case it indicates the name of the source texture
-//               coordinate set from which the tangent and binormal
-//               are derived.
-////////////////////////////////////////////////////////////////////
-string TexGenAttrib::
-get_source_name(TextureStage *stage) const {
-  Stages::const_iterator mi = _stages.find(stage);
-  if (mi != _stages.end()) {
-    return (*mi).second._source_name;
-  }
-  return string();
-}
-
-////////////////////////////////////////////////////////////////////
-//     Function: TexGenAttrib::get_light
-//       Access: Published
-//  Description: Returns the Light associated with the named texture
-//               stage, or the empty NodePath if no light is
-//               associated with the indicated stage.  This is only
-//               meaningful if the mode is M_light_vector.
-////////////////////////////////////////////////////////////////////
-NodePath TexGenAttrib::
-get_light(TextureStage *stage) const {
-  Stages::const_iterator mi = _stages.find(stage);
-  if (mi != _stages.end()) {
-    return (*mi).second._light;
-  }
-  return NodePath();
-}
-
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::get_constant_value
 //       Access: Published
@@ -294,7 +223,7 @@ get_constant_value(TextureStage *stage) const {
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::output
 //       Access: Public, Virtual
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 void TexGenAttrib::
 output(ostream &out) const {
@@ -339,16 +268,12 @@ output(ostream &out) const {
       out << "point_sprite";
       break;
 
-    case M_light_vector:
-      out << "light_vector: \"" << mode_def._source_name << "\", "
-          << mode_def._light;
-      break;
-
     case M_constant:
       out << "constant: " << mode_def._constant_value;
       break;
 
     case M_unused:
+    case M_unused2:
       break;
     }
     out << ")";
@@ -374,7 +299,7 @@ int TexGenAttrib::
 compare_to_impl(const RenderAttrib *other) const {
   const TexGenAttrib *ta;
   DCAST_INTO_R(ta, other, 0);
-  
+
   Stages::const_iterator ai, bi;
   ai = _stages.begin();
   bi = ta->_stages.begin();
@@ -566,7 +491,7 @@ invert_compose_impl(const RenderAttrib *other) const {
 ////////////////////////////////////////////////////////////////////
 //     Function: TexGenAttrib::get_auto_shader_attrib_impl
 //       Access: Protected, Virtual
-//  Description: 
+//  Description:
 ////////////////////////////////////////////////////////////////////
 CPT(RenderAttrib) TexGenAttrib::
 get_auto_shader_attrib_impl(const RenderState *state) const {
@@ -608,26 +533,6 @@ record_stage(TextureStage *stage, TexGenAttrib::ModeDef &mode_def) {
     _num_point_sprites++;
     break;
 
-  case M_light_vector:
-    {
-      if (!mode_def._light.is_empty()) {
-        Light *light_obj = mode_def._light.node()->as_light();
-        if (light_obj == (Light *)NULL) {
-#ifndef NDEBUG
-          ostringstream strm;
-          strm << "Not a light: " << mode_def._light;
-          nassert_raise(strm.str());
-#endif
-          mode_def._light = NodePath();
-        }
-      }
-
-      _light_vectors.insert(stage);
-      _geom_rendering |= Geom::GR_texcoord_light_vector;
-      _num_light_vectors++;
-    }
-    break;
-
   case M_off:
     break;
 

panda/src/pgraph/texGenAttrib.h

@@ -54,7 +54,6 @@ PUBLISHED:
   static CPT(RenderAttrib) make_default();
 
   CPT(RenderAttrib) add_stage(TextureStage *stage, Mode mode) const;
-  CPT(RenderAttrib) add_stage(TextureStage *stage, Mode mode, const string &source_name, const NodePath &light) const;
   CPT(RenderAttrib) add_stage(TextureStage *stage, Mode mode, const LTexCoord3 &constant_value) const;
   CPT(RenderAttrib) remove_stage(TextureStage *stage) const;
 
@@ -62,16 +61,11 @@ PUBLISHED:
   bool has_stage(TextureStage *stage) const;
   Mode get_mode(TextureStage *stage) const;
   bool has_gen_texcoord_stage(TextureStage *stage) const;
-  string get_source_name(TextureStage *stage) const;
-  NodePath get_light(TextureStage *stage) const;
   const LTexCoord3 &get_constant_value(TextureStage *stage) const;
 
   INLINE int get_geom_rendering(int geom_rendering) const;
 
 public:
-  typedef pset<TextureStage *> LightVectors;
-  INLINE const LightVectors &get_light_vectors() const;
-
   virtual void output(ostream &out) const;
 
 protected:
@@ -105,16 +99,11 @@ private:
   typedef pset<TextureStage *> NoTexCoordStages;
   NoTexCoordStages _no_texcoords;
 
-  // This is another optimization during rendering; it lists the
-  // texture stages (if any) that use M_light_vector.
-  LightVectors _light_vectors;
-
   // This element is only used during reading from a bam file.  It has
   // no meaningful value any other time.
   pvector<Mode> _read_modes;
 
   int _num_point_sprites;
-  int _num_light_vectors;
 
   // _point_geom_rendering is the GeomRendering bits that are added by
   // the TexGenAttrib if there are any points in the Geom.
@@ -122,7 +111,7 @@ private:
   // regardless of the kind of Geom it is.
   int _point_geom_rendering;
   int _geom_rendering;
-  
+
   static CPT(RenderAttrib) _empty_attrib;
 
 PUBLISHED:
@@ -141,7 +130,7 @@ public:
 protected:
   static TypedWritable *make_from_bam(const FactoryParams &params);
   void fillin(DatagramIterator &scan, BamReader *manager);
-  
+
 public:
   static TypeHandle get_class_type() {
     return _type_handle;