fix GeomVertexRewriter::set_row() problem with empty data; add GeomVertexReader/Writer::set_row_unsafe(); fix some compiler warnings

panda/src/collada/colladaInput.cxx

@@ -260,7 +260,7 @@ void ColladaInput::
 write_data(GeomVertexData *vdata, int start_row, domP &p, unsigned int stride, unsigned int offset) const {
   nassertv(_column_name != NULL);
   GeomVertexWriter writer (vdata, _column_name);
-  writer.set_row(start_row);
+  writer.set_row_unsafe(start_row);
 
   domList_of_uints &indices = p.getValue();
 

panda/src/collide/collisionTraverser.cxx

@@ -1330,11 +1330,11 @@ compare_collider_to_geom(CollisionEntry &entry, const Geom *geom,
           while (!index.is_at_end()) {
             Vertexf v[3];
             
-            vertex.set_row(index.get_data1i());
+            vertex.set_row_unsafe(index.get_data1i());
             v[0] = vertex.get_data3f();
-            vertex.set_row(index.get_data1i());
+            vertex.set_row_unsafe(index.get_data1i());
             v[1] = vertex.get_data3f();
-            vertex.set_row(index.get_data1i());
+            vertex.set_row_unsafe(index.get_data1i());
             v[2] = vertex.get_data3f();
             
             // Generate a temporary CollisionGeom on the fly for each
@@ -1358,7 +1358,7 @@ compare_collider_to_geom(CollisionEntry &entry, const Geom *geom,
           }
         } else {
           // Non-indexed case.
-          vertex.set_row(primitive->get_first_vertex());
+          vertex.set_row_unsafe(primitive->get_first_vertex());
           int num_vertices = primitive->get_num_vertices();
           for (int i = 0; i < num_vertices; i += 3) {
             Vertexf v[3];

panda/src/gobj/geomLines.cxx

@@ -137,9 +137,9 @@ rotate_impl() const {
     GeomVertexWriter to(new_vertices, 0);
 
     for (int begin = 0; begin < num_vertices; begin += 2) {
-      from.set_row(begin + 1);
+      from.set_row_unsafe(begin + 1);
       to.set_data1i(from.get_data1i());
-      from.set_row(begin);
+      from.set_row_unsafe(begin);
       to.set_data1i(from.get_data1i());
     }
   

panda/src/gobj/geomLinestrips.cxx

@@ -182,7 +182,7 @@ rotate_impl() const {
     for (ei = ends.begin(); ei != ends.end(); ++ei) {
       int end = (*ei);
       for (int vi = end - 1; vi >= begin; --vi) {
-        from.set_row(vi);
+        from.set_row_unsafe(vi);
         to.set_data1i(from.get_data1i());
       }
       begin = end;

panda/src/gobj/geomPrimitive.cxx

@@ -231,7 +231,7 @@ add_vertex(int vertex) {
 
   PT(GeomVertexArrayData) array_obj = cdata->_vertices.get_write_pointer();
   GeomVertexWriter index(array_obj, 0);
-  index.set_row(array_obj->get_num_rows());
+  index.set_row_unsafe(array_obj->get_num_rows());
 
   index.add_data1i(vertex);
 
@@ -295,7 +295,7 @@ add_consecutive_vertices(int start, int num_vertices) {
 
   PT(GeomVertexArrayData) array_obj = cdata->_vertices.get_write_pointer();
   GeomVertexWriter index(array_obj, 0);
-  index.set_row(array_obj->get_num_rows());
+  index.set_row_unsafe(array_obj->get_num_rows());
 
   for (int v = start; v <= end; ++v) {
     index.add_data1i(v);
@@ -680,7 +680,7 @@ get_primitive_min_vertex(int n) const {
     nassertr(n >= 0 && n < mins->get_num_rows(), -1);
 
     GeomVertexReader index(mins, 0);
-    index.set_row(n);
+    index.set_row_unsafe(n);
     return index.get_data1i();
   } else {
     return get_primitive_start(n);
@@ -700,7 +700,7 @@ get_primitive_max_vertex(int n) const {
     nassertr(n >= 0 && n < maxs->get_num_rows(), -1);
 
     GeomVertexReader index(maxs, 0);
-    index.set_row(n);
+    index.set_row_unsafe(n);
     return index.get_data1i();
   } else {
     return get_primitive_end(n) - 1;
@@ -1491,7 +1491,7 @@ calc_tight_bounds(LPoint3f &min_point, LPoint3f &max_point,
     nassertv(cdata->_num_vertices != -1);
     if (got_mat) {
       for (int i = 0; i < cdata->_num_vertices; i++) {
-        reader.set_row(cdata->_first_vertex + i);
+        reader.set_row_unsafe(cdata->_first_vertex + i);
         LPoint3f vertex = mat.xform_point(reader.get_data3f());
         
         if (found_any) {
@@ -1509,7 +1509,7 @@ calc_tight_bounds(LPoint3f &min_point, LPoint3f &max_point,
       }
     } else {
       for (int i = 0; i < cdata->_num_vertices; i++) {
-        reader.set_row(cdata->_first_vertex + i);
+        reader.set_row_unsafe(cdata->_first_vertex + i);
         const LVecBase3f &vertex = reader.get_data3f();
         
         if (found_any) {
@@ -1534,7 +1534,7 @@ calc_tight_bounds(LPoint3f &min_point, LPoint3f &max_point,
     if (got_mat) {
       while (!index.is_at_end()) {
         int ii = index.get_data1i();
-        reader.set_row(ii);
+        reader.set_row_unsafe(ii);
         LPoint3f vertex = mat.xform_point(reader.get_data3f());
         
         if (found_any) {
@@ -1553,7 +1553,7 @@ calc_tight_bounds(LPoint3f &min_point, LPoint3f &max_point,
     } else {
       while (!index.is_at_end()) {
         int ii = index.get_data1i();
-        reader.set_row(ii);
+        reader.set_row_unsafe(ii);
         const LVecBase3f &vertex = reader.get_data3f();
         
         if (found_any) {
@@ -2035,7 +2035,7 @@ get_vertex(int i) const {
     nassertr(i >= 0 && i < _vertices_reader->get_num_rows(), -1);
 
     GeomVertexReader index(_cdata->_vertices.get_read_pointer(), 0);
-    index.set_row(i);
+    index.set_row_unsafe(i);
     return index.get_data1i();
 
   } else {

panda/src/gobj/geomTriangles.cxx

@@ -210,10 +210,10 @@ rotate_impl() const {
       // Move the first vertex to the end.
       {
         for (int begin = 0; begin < num_vertices; begin += 3) {
-          from.set_row(begin + 1);
+          from.set_row_unsafe(begin + 1);
           to.set_data1i(from.get_data1i());
           to.set_data1i(from.get_data1i());
-          from.set_row(begin);
+          from.set_row_unsafe(begin);
           to.set_data1i(from.get_data1i());
         }
       }
@@ -223,9 +223,9 @@ rotate_impl() const {
       // Move the last vertex to the front.
       {
         for (int begin = 0; begin < num_vertices; begin += 3) {
-          from.set_row(begin + 2);
+          from.set_row_unsafe(begin + 2);
           to.set_data1i(from.get_data1i());
-          from.set_row(begin);
+          from.set_row_unsafe(begin);
           to.set_data1i(from.get_data1i());
           to.set_data1i(from.get_data1i());
         }

panda/src/gobj/geomTristrips.cxx

@@ -291,7 +291,7 @@ rotate_impl() const {
       if (begin != 0) {
         // Copy in the unused vertices between tristrips.
         to.set_data1i(last_added);
-        from.set_row(end - 1);
+        from.set_row_unsafe(end - 1);
         to.set_data1i(from.get_data1i());
         begin += 2;
       }
@@ -300,7 +300,7 @@ rotate_impl() const {
       // an odd number of vertices, which is not allowed.
       nassertr((num_vertices & 1) == 0, NULL);
       for (int vi = end - 1; vi >= begin; --vi) {
-        from.set_row(vi);
+        from.set_row_unsafe(vi);
         last_added = from.get_data1i();
         to.set_data1i(last_added);
       }
@@ -368,11 +368,11 @@ requires_unused_vertices() const {
 void GeomTristrips::
 append_unused_vertices(GeomVertexArrayData *vertices, int vertex) {
   GeomVertexReader from(vertices, 0);
-  from.set_row(vertices->get_num_rows() - 1);
+  from.set_row_unsafe(vertices->get_num_rows() - 1);
   int prev = from.get_data1i();
 
   GeomVertexWriter to(vertices, 0);
-  to.set_row(vertices->get_num_rows());
+  to.set_row_unsafe(vertices->get_num_rows());
 
   to.add_data1i(prev);
   to.add_data1i(vertex);

panda/src/gobj/geomVertexArrayFormat.cxx

@@ -526,7 +526,7 @@ write_with_data(ostream &out, int indent_level,
   for (int i = 0; i < num_rows; i++) {
     indent(out, indent_level)
       << "row " << i << ":\n";
-    reader.set_row(i);
+    reader.set_row_unsafe(i);
     Columns::const_iterator ci;
     for (ci = _columns.begin(); ci != _columns.end(); ++ci) {
       const GeomVertexColumn *column = (*ci);

panda/src/gobj/geomVertexData.cxx

@@ -1245,7 +1245,7 @@ describe_vertex(ostream &out, int row) const {
   out << "Vertex " << row << ":\n";
 
   GeomVertexReader reader(this);
-  reader.set_row(row);
+  reader.set_row_unsafe(row);
   const GeomVertexFormat *format = get_format();
 
   const TransformBlendTable *tb_table = NULL;
@@ -1476,8 +1476,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
                   for (int i = 0; i < num_subranges; ++i) {
                     int begin = rows.get_subrange_begin(i);
                     int end = rows.get_subrange_end(i);
-                    data.set_row(begin);
-                    delta.set_row(begin);
+                    data.set_row_unsafe(begin);
+                    delta.set_row_unsafe(begin);
                     for (int j = begin; j < end; ++j) {
                       LPoint4f vertex = data.get_data4f();
                       LPoint3f d = delta.get_data3f();
@@ -1493,8 +1493,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
                   for (int i = 0; i < num_subranges; ++i) {
                     int begin = rows.get_subrange_begin(i);
                     int end = rows.get_subrange_end(i);
-                    data.set_row(begin);
-                    delta.set_row(begin);
+                    data.set_row_unsafe(begin);
+                    delta.set_row_unsafe(begin);
                     for (int j = begin; j < end; ++j) {
                       const LPoint4f &vertex = data.get_data4f();
                       LPoint4f d = delta.get_data4f();
@@ -1508,8 +1508,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
                 for (int i = 0; i < num_subranges; ++i) {
                   int begin = rows.get_subrange_begin(i);
                   int end = rows.get_subrange_end(i);
-                  data.set_row(begin);
-                  delta.set_row(begin);
+                  data.set_row_unsafe(begin);
+                  delta.set_row_unsafe(begin);
                   for (int j = begin; j < end; ++j) {
                     const LPoint3f &vertex = data.get_data3f();
                     LPoint3f d = delta.get_data3f();
@@ -1591,7 +1591,7 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
           for (int i = 0; i < num_subranges; ++i) {
             int begin = rows.get_subrange_begin(i);
             int end = rows.get_subrange_end(i);
-            data.set_row(begin);
+            data.set_row_unsafe(begin);
             for (int j = begin; j < end; ++j) {
               LPoint4f vertex = data.get_data4f();
               int bi = blendt[j];
@@ -1606,7 +1606,7 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
           for (int i = 0; i < num_subranges; ++i) {
             int begin = rows.get_subrange_begin(i);
             int end = rows.get_subrange_end(i);
-            data.set_row(begin);
+            data.set_row_unsafe(begin);
             for (int j = begin; j < end; ++j) {
               LPoint3f vertex = data.get_data3f();
               int bi = blendt[j];
@@ -1648,7 +1648,7 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
           for (int i = 0; i < num_subranges; ++i) {
             int begin = rows.get_subrange_begin(i);
             int end = rows.get_subrange_end(i);
-            data.set_row(begin);
+            data.set_row_unsafe(begin);
             for (int j = begin; j < end; ++j) {
               LVector3f vertex = data.get_data3f();
               int bi = blendt[j];
@@ -1674,8 +1674,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
           for (int i = 0; i < num_subranges; ++i) {
             int begin = rows.get_subrange_begin(i);
             int end = rows.get_subrange_end(i);
-            data.set_row(begin);
-            blendi.set_row(begin);
+            data.set_row_unsafe(begin);
+            blendi.set_row_unsafe(begin);
             for (int j = begin; j < end; ++j) {
               LPoint4f vertex = data.get_data4f();
               int bi = blendi.get_data1i();
@@ -1687,8 +1687,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
           for (int i = 0; i < num_subranges; ++i) {
             int begin = rows.get_subrange_begin(i);
             int end = rows.get_subrange_end(i);
-            data.set_row(begin);
-            blendi.set_row(begin);
+            data.set_row_unsafe(begin);
+            blendi.set_row_unsafe(begin);
             for (int j = begin; j < end; ++j) {
               LPoint3f vertex = data.get_data3f();
               int bi = blendi.get_data1i();
@@ -1703,8 +1703,8 @@ update_animated_vertices(GeomVertexData::CData *cdata, Thread *current_thread) {
         for (int i = 0; i < num_subranges; ++i) {
           int begin = rows.get_subrange_begin(i);
           int end = rows.get_subrange_end(i);
-          data.set_row(begin);
-          blendi.set_row(begin);
+          data.set_row_unsafe(begin);
+          blendi.set_row_unsafe(begin);
           for (int j = begin; j < end; ++j) {
             LVector3f vertex = data.get_data3f();
             int bi = blendi.get_data1i();

panda/src/gobj/geomVertexReader.I

@@ -374,6 +374,25 @@ get_column() const {
   return NULL;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: GeomVertexReader::set_row_unsafe
+//       Access: Published
+//  Description: Sets the start row to the indicated value, without
+//               internal checks.  This is the same as set_row(), but
+//               it does not check for the possibility that the array
+//               has been reallocated internally for some reason; use
+//               only when you are confident that the array is
+//               unchanged and you really need every bit of available
+//               performance.
+////////////////////////////////////////////////////////////////////
+INLINE void GeomVertexReader::
+set_row_unsafe(int row) {
+  _start_row = row;
+  if (has_column()) {
+    quick_set_pointer(_start_row);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: GeomVertexReader::set_row
 //       Access: Published
@@ -387,7 +406,8 @@ INLINE void GeomVertexReader::
 set_row(int row) {
   _start_row = row;
   if (has_column()) {
-    quick_set_pointer(_start_row);
+    bool result = set_pointer(_start_row);
+    nassertv(result);
   }
 }
 
@@ -556,12 +576,13 @@ get_packer() const {
 INLINE bool GeomVertexReader::
 set_pointer(int row) {
   _pointer_begin = _handle->get_read_pointer(_force);
-  if (_pointer_begin == NULL) {
+  if (_pointer_begin == NULL && _handle->get_data_size_bytes() != 0) {
     // Vertex data is not resident.
     set_column(0, NULL);
     return false;
   }
 
+  // Vertex data is resident, or just empty.
   _pointer_end = _pointer_begin + _handle->get_data_size_bytes();
   quick_set_pointer(row);
   return true;
@@ -576,7 +597,7 @@ set_pointer(int row) {
 ////////////////////////////////////////////////////////////////////
 INLINE void GeomVertexReader::
 quick_set_pointer(int row) {
-  nassertv(has_column() && _pointer_begin != NULL);
+  nassertv(has_column() && (_pointer_begin != NULL || row == 0));
 
 #if defined(_DEBUG)
   // Make sure we still have the same pointer as stored in the array.

panda/src/gobj/geomVertexReader.h

@@ -97,6 +97,7 @@ PUBLISHED:
   INLINE int get_array() const;
   INLINE const GeomVertexColumn *get_column() const;
 
+  INLINE void set_row_unsafe(int row);
   INLINE void set_row(int row);
 
   INLINE int get_start_row() const;

panda/src/gobj/geomVertexRewriter.I

@@ -295,6 +295,26 @@ get_column() const {
   return GeomVertexWriter::get_column();
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: GeomVertexRewriter::set_row_unsafe
+//       Access: Published
+//  Description: Sets the start row to the indicated value, without
+//               internal checks.  This is the same as set_row(), but
+//               it does not check for the possibility that the array
+//               has been reallocated internally for some reason; use
+//               only when you are confident that the array is
+//               unchanged and you really need every bit of available
+//               performance.
+////////////////////////////////////////////////////////////////////
+INLINE void GeomVertexRewriter::
+set_row_unsafe(int row) {
+  // It's important to invoke the Writer first, since that might force
+  // a recopy of the array, which might invalidate the pointer already
+  // stored by the Reader if we invoked the Reader first.
+  GeomVertexWriter::set_row_unsafe(row);
+  GeomVertexReader::set_row_unsafe(row);
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: GeomVertexRewriter::set_row
 //       Access: Published
@@ -304,9 +324,6 @@ get_column() const {
 ////////////////////////////////////////////////////////////////////
 INLINE void GeomVertexRewriter::
 set_row(int row) {
-  // It's important to invoke the Writer first, since that might force
-  // a recopy of the array, which might invalidate the pointer already
-  // stored by the Reader if we invoked the Reader first.
   GeomVertexWriter::set_row(row);
   GeomVertexReader::set_row(row);
 }

panda/src/gobj/geomVertexRewriter.h

@@ -64,6 +64,7 @@ PUBLISHED:
   INLINE int get_array() const;
   INLINE const GeomVertexColumn *get_column() const;
 
+  INLINE void set_row_unsafe(int row);
   INLINE void set_row(int row);
 
   INLINE int get_start_row() const;

panda/src/gobj/geomVertexWriter.I

@@ -335,6 +335,25 @@ get_column() const {
   return NULL;
 }
 
+////////////////////////////////////////////////////////////////////
+//     Function: GeomVertexWriter::set_row_unsafe
+//       Access: Published
+//  Description: Sets the start row to the indicated value, without
+//               internal checks.  This is the same as set_row(), but
+//               it does not check for the possibility that the array
+//               has been reallocated internally for some reason; use
+//               only when you are confident that the array is
+//               unchanged and you really need every bit of available
+//               performance.
+////////////////////////////////////////////////////////////////////
+INLINE void GeomVertexWriter::
+set_row_unsafe(int row) {
+  _start_row = row;
+  if (has_column()) {
+    quick_set_pointer(_start_row);
+  }
+}
+
 ////////////////////////////////////////////////////////////////////
 //     Function: GeomVertexWriter::set_row
 //       Access: Published
@@ -348,7 +367,7 @@ INLINE void GeomVertexWriter::
 set_row(int row) {
   _start_row = row;
   if (has_column()) {
-    quick_set_pointer(_start_row);
+    set_pointer(_start_row);
   }
 }
 

panda/src/gobj/geomVertexWriter.h

@@ -107,6 +107,7 @@ PUBLISHED:
   INLINE int get_array() const;
   INLINE const GeomVertexColumn *get_column() const;
 
+  INLINE void set_row_unsafe(int row);
   INLINE void set_row(int row);
 
   INLINE int get_start_row() const;

panda/src/gobj/shader.cxx

@@ -1360,6 +1360,7 @@ cg_compile_entry_point(const char *entry, const ShaderCaps &caps, ShaderType typ
     break;
 
   case ST_none:
+  default:
     active   = CG_PROFILE_UNKNOWN;
     ultimate = CG_PROFILE_UNKNOWN;
   };
@@ -1459,7 +1460,7 @@ cg_compile_shader(const ShaderCaps &caps) {
     }
   }
 
-  if ((_text->_separate && !_text->_geometry.empty()) || (!_text->_separate && _text->_shared.find("gshader") != -1)) {
+  if ((_text->_separate && !_text->_geometry.empty()) || (!_text->_separate && _text->_shared.find("gshader") != string::npos)) {
     _cg_gprogram = cg_compile_entry_point("gshader", caps, ST_geometry);
     if (_cg_gprogram == 0) {
       cg_release_resources();
@@ -1829,9 +1830,9 @@ cg_compile_for(const ShaderCaps &caps,
 ////////////////////////////////////////////////////////////////////
 Shader::
 Shader(CPT(ShaderFile) filename, CPT(ShaderFile) text, const ShaderLanguage &lang) :
-  _filename(filename),
-  _text(text),
   _error_flag(true),
+  _text(text),
+  _filename(filename),
   _parse(0),
   _loaded(false),
   _language(lang)

panda/src/gobj/shader.h

@@ -262,20 +262,20 @@ public:
   
   // Container structure for data of parameters ShaderPtrSpec.
   struct ShaderPtrData{
-  public:
-    ShaderPtrType _type;
-    int           _size; //number of elements vec3[4]=12
-    bool          _updated;
-    void*         _ptr; 
-
   private:
     PTA_float         _pta_float;
     PTA_double        _pta_double;
+    PTA_LMatrix4f     _pta_lmat4f;
+    PTA_LMatrix3f     _pta_lmat3f;
     PTA_LVecBase4f    _pta_lvec4f;
     PTA_LVecBase3f    _pta_lvec3f;
     PTA_LVecBase2f    _pta_lvec2f;
-    PTA_LMatrix4f     _pta_lmat4f;
-    PTA_LMatrix3f     _pta_lmat3f;
+
+  public:
+    void*         _ptr; 
+    ShaderPtrType _type;
+    bool          _updated;
+    int           _size; //number of elements vec3[4]=12
 
   public:
     INLINE ShaderPtrData();
@@ -459,7 +459,7 @@ public:
   CPT(ShaderFile) _text;
 
  protected:
-  CPT(ShaderFile)_filename;
+  CPT(ShaderFile) _filename; 
   int            _parse;
   bool           _loaded;
   ShaderLanguage _language;

panda/src/gobj/texture.cxx

@@ -2199,6 +2199,10 @@ format_compression_mode(CompressionMode cm) {
     return "dxt4";
   case CM_dxt5:
     return "dxt5";
+  case CM_pvr1_2bpp:
+    return "pvr1_2bpp";
+  case CM_pvr1_4bpp:
+    return "pvr1_4bpp";
   }
 
   return "**invalid**";
@@ -2230,6 +2234,10 @@ string_compression_mode(const string &str) {
     return CM_dxt4;
   } else if (cmp_nocase_uh(str, "dxt5") == 0) {
     return CM_dxt5;
+  } else if (cmp_nocase_uh(str, "pvr1_2bpp") == 0) {
+    return CM_pvr1_2bpp;
+  } else if (cmp_nocase_uh(str, "pvr1_4bpp") == 0) {
+    return CM_pvr1_4bpp;
   }
 
   gobj_cat->error()

panda/src/gobj/vertexDataBuffer.I

@@ -73,8 +73,9 @@ INLINE VertexDataBuffer::
 //               is not currently resident, this will implicitly
 //               request it to become resident soon.
 //
-//               If force is true, this method will never return NULL,
-//               but may block until the data is available.
+//               If force is true, this method will never return NULL
+//               (unless the data is actually empty), but may block
+//               until the data is available.
 ////////////////////////////////////////////////////////////////////
 INLINE const unsigned char *VertexDataBuffer::
 get_read_pointer(bool force) const {

panda/src/gobj/vertexDataPage.cxx

@@ -391,7 +391,6 @@ make_resident() {
     size_t new_allocated_size = round_up(_uncompressed_size);
     unsigned char *new_data = alloc_page_data(new_allocated_size);
     unsigned char *end_data = new_data + new_allocated_size;
-    uLongf dest_len = _uncompressed_size;
 
     z_stream z_source;
 #ifdef USE_MEMORY_NOWRAPPERS

panda/src/grutil/lineSegs.cxx

@@ -128,7 +128,7 @@ Vertexf LineSegs::
 get_vertex(int n) const {
   nassertr(_created_data != (GeomVertexData *)NULL, Vertexf::zero());
   GeomVertexReader vertex(_created_data, InternalName::get_vertex());
-  vertex.set_row(n);
+  vertex.set_row_unsafe(n);
   return vertex.get_data3f();
 }
 
@@ -145,7 +145,7 @@ void LineSegs::
 set_vertex(int n, const Vertexf &vert) {
   nassertv(_created_data != (GeomVertexData *)NULL);
   GeomVertexWriter vertex(_created_data, InternalName::get_vertex());
-  vertex.set_row(n);
+  vertex.set_row_unsafe(n);
   vertex.set_data3f(vert);
 }
 
@@ -158,7 +158,7 @@ Colorf LineSegs::
 get_vertex_color(int n) const {
   nassertr(_created_data != (GeomVertexData *)NULL, Colorf::zero());
   GeomVertexReader color(_created_data, InternalName::get_color());
-  color.set_row(n);
+  color.set_row_unsafe(n);
   return color.get_data4f();
 }
 
@@ -172,7 +172,7 @@ void LineSegs::
 set_vertex_color(int n, const Colorf &c) {
   nassertv(_created_data != (GeomVertexData *)NULL);
   GeomVertexWriter color(_created_data, InternalName::get_color());
-  color.set_row(n);
+  color.set_row_unsafe(n);
   color.set_data4f(c);
 }
 

panda/src/grutil/meshDrawer.cxx

@@ -413,8 +413,8 @@ void MeshDrawer::geometry(NodePath draw_node) {
           // process polygon
           for(int idx=s; idx<e; idx++) {
             int vidx = _prim->get_vertex(idx);
-            prim_vertex_reader->set_row(vidx);
-            prim_uv_reader->set_row(vidx);
+            prim_vertex_reader->set_row_unsafe(vidx);
+            prim_uv_reader->set_row_unsafe(vidx);
             vec[indx_over] = _render.get_relative_point(
               current_node_path,prim_vertex_reader->get_data3f());
             uv[indx_over] = prim_uv_reader->get_data2f();

panda/src/ode/odeTriMeshData.cxx

@@ -226,8 +226,8 @@ process_primitive(const GeomPrimitive *primitive,
       out.width(8); out << "" << "primitive " << i << ":" << "\n";
       for (int j = s, m = 0; j < e; j++, m++, _num_vertices++) {
         int vRowIndex = dPrimitive->get_vertex(j);
-        vReader.set_row(vRowIndex);
-        nReader.set_row(vRowIndex);
+        vReader.set_row_unsafe(vRowIndex);
+        nReader.set_row_unsafe(vRowIndex);
         vertex = vReader.get_data3f();
         //normal = nReader.get_data3f();
         _faces[_num_faces].Indices[m] = _num_vertices;
@@ -247,8 +247,8 @@ process_primitive(const GeomPrimitive *primitive,
       out.width(8); out << "" << "primitive " << i << ":" << "\n";
       for (int j = s, m = 0; j < e; j++, m++, _num_vertices++) {
         int vRowIndex = dPrimitive->get_vertex(j);
-        vReader.set_row(vRowIndex);
-        nReader.set_row(vRowIndex);
+        vReader.set_row_unsafe(vRowIndex);
+        nReader.set_row_unsafe(vRowIndex);
         vertex = vReader.get_data3f();
         //normal = nReader.get_data3f();
 

panda/src/particlesystem/spriteParticleRenderer.cxx

@@ -321,7 +321,7 @@ add_from_node(const NodePath &node_path, bool size_from_texels, bool resize) {
           primitive = geom->get_primitive(pi);
           for (int vi = 0; vi < primitive->get_num_vertices(); ++vi) {
             int vert = primitive->get_vertex(vi);
-            texcoord.set_row(vert);
+            texcoord.set_row_unsafe(vert);
             
             if (!got_texcoord) {
                 min_uv = max_uv = texcoord.get_data2f();
@@ -365,7 +365,7 @@ add_from_node(const NodePath &node_path, bool size_from_texels, bool resize) {
           primitive = geom->get_primitive(pi);
           for (int vi = 0; vi < primitive->get_num_vertices(); ++vi) {
             int vert = primitive->get_vertex(vi);
-            vertex.set_row(vert);
+            vertex.set_row_unsafe(vert);
             
             if (!got_vertex) {
               min_xyz = max_xyz = vertex.get_data3f();

panda/src/pgraph/geomTransformer.cxx

@@ -256,7 +256,6 @@ transform_texcoords(Geom *geom, const InternalName *from_name,
   }
   
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (st._vertex_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[st._vertex_data]._might_have_unused = true;
@@ -325,7 +324,6 @@ set_color(Geom *geom, const Colorf &color) {
   }
   
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (sc._vertex_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[sc._vertex_data]._might_have_unused = true;
@@ -391,7 +389,6 @@ transform_colors(Geom *geom, const LVecBase4f &scale) {
   }
   
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (sc._vertex_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[sc._vertex_data]._might_have_unused = true;
@@ -616,7 +613,6 @@ apply_texture_colors(Geom *geom, TextureStage *ts, Texture *tex,
   }
 
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (stc._vertex_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[stc._vertex_data]._might_have_unused = true;
@@ -753,7 +749,6 @@ set_format(Geom *geom, const GeomVertexFormat *new_format) {
   }
   
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (sf._vertex_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[sf._vertex_data]._might_have_unused = true;
@@ -920,7 +915,6 @@ reverse_normals(Geom *geom) {
   }
 
   geom->set_vertex_data(new_data._vdata);
-  VertexDataAssoc &assoc = _vdata_assoc[new_data._vdata];
   if (orig_data->get_ref_count() > 1) {
     _vdata_assoc[new_data._vdata]._might_have_unused = true;
     _vdata_assoc[orig_data]._might_have_unused = true;
@@ -1463,7 +1457,7 @@ append_vdata(const GeomVertexData *vdata, int vertex_offset) {
       int num_rows = vdata->get_num_rows();
       int new_index[4];
       
-      index.set_row(vertex_offset);
+      index.set_row_unsafe(vertex_offset);
       for (int ci = 0; ci < num_rows; ++ci) {
         const int *orig_index = index.get_data4i();
         for (int i = 0; i < num_values; i++) {
@@ -1511,7 +1505,7 @@ append_vdata(const GeomVertexData *vdata, int vertex_offset) {
     GeomVertexRewriter index(_new_data, InternalName::get_transform_blend());
     if (index.has_column()) {
       int num_rows = vdata->get_num_rows();
-      index.set_row(vertex_offset);
+      index.set_row_unsafe(vertex_offset);
 
       for (int ci = 0; ci < num_rows; ++ci) {
         int orig_index = index.get_data1i();

panda/src/pgraph/lightRampAttrib.cxx

@@ -200,6 +200,9 @@ void LightRampAttrib::
 output(ostream &out) const {
   out << get_type() << ":";
   switch (_mode) {
+  case LRT_default:
+    out << "default()";
+    break;
   case LRT_identity:
     out << "identity()";
     break;
@@ -209,6 +212,15 @@ output(ostream &out) const {
   case LRT_double_threshold:
     out << "double_threshold(" << _level[0] << "," << _level[1] << "," << _threshold[0] << "," << _threshold[1] << ")";
     break;
+  case LRT_hdr0:
+    out << "hdr0()";
+    break;
+  case LRT_hdr1:
+    out << "hdr1()";
+    break;
+  case LRT_hdr2:
+    out << "hdr2()";
+    break;
   }
 }
 

panda/src/pgraph/occluderNode.cxx

@@ -77,9 +77,9 @@ OccluderNode(const string &name) :
 OccluderNode::
 OccluderNode(const OccluderNode &copy) :
   PandaNode(copy),
-  _vertices(copy._vertices),
   _double_sided(copy._double_sided),
-  _min_coverage(copy._min_coverage)
+  _min_coverage(copy._min_coverage),
+  _vertices(copy._vertices)
 {
 }
 

panda/src/pgraph/pandaNode.cxx

@@ -646,7 +646,6 @@ __copy__() const {
   int num_children = children.get_num_children();
 
   for (int i = 0; i < num_children; ++i) {
-    PandaNode *child = children.get_child(i);
     node_dupe->add_child(children.get_child(i), children.get_child_sort(i));
   }
 

panda/src/pgraph/shaderAttrib.I

@@ -50,12 +50,12 @@ ShaderAttrib(const ShaderAttrib &copy) :
   _flags(copy._flags),
   _has_flags(copy._has_flags),
   _instance_count(copy._instance_count),
-  _inputs(copy._inputs),
   _auto_normal_on(copy._auto_normal_on),
   _auto_glow_on(copy._auto_glow_on),
   _auto_gloss_on(copy._auto_gloss_on),
   _auto_ramp_on(copy._auto_ramp_on),
-  _auto_shadow_on(copy._auto_shadow_on)
+  _auto_shadow_on(copy._auto_shadow_on),
+  _inputs(copy._inputs)
 {
 }
 

panda/src/pgraph/shaderInput.h

@@ -83,10 +83,10 @@ private:
   PT(InternalName) _name;
   int _type;
   int _priority;
+  Shader::ShaderPtrData _stored_ptr;
   PT(Texture)           _stored_texture;
   NodePath              _stored_nodepath;
   LVector4f             _stored_vector;
-  Shader::ShaderPtrData _stored_ptr;
 
 public:
   static TypeHandle get_class_type() {

panda/src/pgraphnodes/shaderGenerator.cxx

@@ -310,18 +310,20 @@ analyze_renderstate(const RenderState *rs) {
     }
     if (tex_gen->has_stage(stage)) {
       switch (tex_gen->get_mode(stage)) {
-        case TexGenAttrib::M_world_position:
-          _need_world_position = true;
-          break;
-        case TexGenAttrib::M_world_normal:
-          _need_world_normal = true;
-          break;
-        case TexGenAttrib::M_eye_position:
-          _need_eye_position = true;
-          break;
-        case TexGenAttrib::M_eye_normal:
-          _need_eye_normal = true;
-          break;
+      case TexGenAttrib::M_world_position:
+	_need_world_position = true;
+	break;
+      case TexGenAttrib::M_world_normal:
+	_need_world_normal = true;
+	break;
+      case TexGenAttrib::M_eye_position:
+	_need_eye_position = true;
+	break;
+      case TexGenAttrib::M_eye_normal:
+	_need_eye_normal = true;
+	break;
+      default:
+	break;
       }
     }
   }
@@ -917,11 +919,19 @@ synthesize_shader(const RenderState *rs) {
     nassertr(tex != NULL, NULL);
     text << "\t float4 tex" << _map_index_height << " = tex" << texture_type_as_string(tex->get_texture_type());
     text << "(tex_" << _map_index_height << ", l_texcoord" << _map_index_height << ".";
-    switch(tex->get_texture_type()) {
-      case Texture::TT_cube_map:
-      case Texture::TT_3d_texture: text << "xyz"; break;
-      case Texture::TT_2d_texture: text << "xy";  break;
-      case Texture::TT_1d_texture: text << "x";   break;
+    switch (tex->get_texture_type()) {
+    case Texture::TT_cube_map:
+    case Texture::TT_3d_texture: 
+      text << "xyz";
+      break;
+    case Texture::TT_2d_texture: 
+      text << "xy";  
+      break;
+    case Texture::TT_1d_texture:
+      text << "x";   
+      break;
+    default:
+      break;
     }
     text << ");\n\t float3 parallax_offset = l_eyevec.xyz * (tex" << _map_index_height;
     if (_map_height_in_alpha) {
@@ -952,10 +962,18 @@ synthesize_shader(const RenderState *rs) {
       text << "\t float4 tex" << i << " = tex" << texture_type_as_string(tex->get_texture_type());
       text << "(tex_" << i << ", l_texcoord" << i << ".";
       switch(tex->get_texture_type()) {
-        case Texture::TT_cube_map:
-        case Texture::TT_3d_texture: text << "xyz"; break;
-        case Texture::TT_2d_texture: text << "xy";  break;
-        case Texture::TT_1d_texture: text << "x";   break;
+      case Texture::TT_cube_map:
+      case Texture::TT_3d_texture: 
+	text << "xyz"; 
+	break;
+      case Texture::TT_2d_texture: 
+	text << "xy";
+	break;
+      case Texture::TT_1d_texture: 
+	text << "x";   
+	break;
+      default:
+	break;
       }
       text << ");\n";
     }

panda/src/pgraphnodes/uvScrollNode.I

@@ -21,10 +21,10 @@
 INLINE UvScrollNode::
 UvScrollNode(const string &name, float u_speed, float v_speed, float r_speed) :
   PandaNode(name),
-  _start_time(ClockObject::get_global_clock()->get_frame_time()),
   _u_speed(u_speed),
   _v_speed(v_speed),
-  _r_speed(r_speed)
+  _r_speed(r_speed),
+  _start_time(ClockObject::get_global_clock()->get_frame_time())
 {  
   set_cull_callback();
 }
@@ -37,10 +37,10 @@ UvScrollNode(const string &name, float u_speed, float v_speed, float r_speed) :
 INLINE UvScrollNode::
 UvScrollNode(const string &name) :
   PandaNode(name),
-  _start_time(ClockObject::get_global_clock()->get_frame_time()),
   _u_speed(0),
   _v_speed(0),
-  _r_speed(0)
+  _r_speed(0),
+  _start_time(ClockObject::get_global_clock()->get_frame_time())
 {  
   set_cull_callback();
 }

panda/src/physx/physxSoftBodyNode.cxx

@@ -238,9 +238,9 @@ remove_tris_related_to_vertex(const int vertexIndex) {
     if (vertexIndex == idx0 || vertexIndex == idx1 || vertexIndex == idx2) {
 
       // Make this triangle degenerated
-      vrewriter.set_row(idx0); v = vrewriter.get_data3f();
-      vrewriter.set_row(idx1); vrewriter.set_data3f(v.get_x(), v.get_y(), v.get_z());
-      vrewriter.set_row(idx2); vrewriter.set_data3f(v.get_x(), v.get_y(), v.get_z());
+      vrewriter.set_row_unsafe(idx0); v = vrewriter.get_data3f();
+      vrewriter.set_row_unsafe(idx1); vrewriter.set_data3f(v.get_x(), v.get_y(), v.get_z());
+      vrewriter.set_row_unsafe(idx2); vrewriter.set_data3f(v.get_x(), v.get_y(), v.get_z());
     }
   }
 }
@@ -288,9 +288,9 @@ update_normals() {
     int idx1 = _prim->get_vertex(s+1);
     int idx2 = _prim->get_vertex(s+2);
 
-    vreader.set_row(idx0); v0 = vreader.get_data3f();
-    vreader.set_row(idx1); v1 = vreader.get_data3f();
-    vreader.set_row(idx2); v2 = vreader.get_data3f();
+    vreader.set_row_unsafe(idx0); v0 = vreader.get_data3f();
+    vreader.set_row_unsafe(idx1); v1 = vreader.get_data3f();
+    vreader.set_row_unsafe(idx2); v2 = vreader.get_data3f();
 
     n = (v1 - v0).cross(v2 - v0);
 

panda/src/text/textAssembler.cxx

@@ -2382,7 +2382,7 @@ append_vertex(const GeomVertexData *orig_vdata, int orig_row,
   _vdata->copy_row_from(new_row, orig_vdata, orig_row, Thread::get_current_thread());
 
   GeomVertexRewriter vertex_rewriter(_vdata, InternalName::get_vertex());
-  vertex_rewriter.set_row(new_row);
+  vertex_rewriter.set_row_unsafe(new_row);
   LPoint3f point = vertex_rewriter.get_data3f();
   vertex_rewriter.set_data3f(point * xform);
 

panda/src/tinydisplay/tinyGraphicsStateGuardian.cxx

@@ -677,8 +677,8 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
 
       break;
     }
-    tcdata[si]._r1.set_row(_min_vertex);
-    tcdata[si]._r2.set_row(_min_vertex);
+    tcdata[si]._r1.set_row_unsafe(_min_vertex);
+    tcdata[si]._r2.set_row_unsafe(_min_vertex);
     if (!tcdata[si]._r1.has_column()) {
       texgen_func[si] = &texgen_null;
     }
@@ -687,7 +687,7 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
   bool needs_color = false;
   if (_vertex_colors_enabled) {
     rcolor = GeomVertexReader(data_reader, InternalName::get_color(), force);
-    rcolor.set_row(_min_vertex);
+    rcolor.set_row_unsafe(_min_vertex);
     needs_color = rcolor.has_column();
   }
 
@@ -703,12 +703,12 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
   bool needs_normal = false;
   if (_c->lighting_enabled) {
     rnormal = GeomVertexReader(data_reader, InternalName::get_normal(), force);
-    rnormal.set_row(_min_vertex);
+    rnormal.set_row_unsafe(_min_vertex);
     needs_normal = rnormal.has_column();
   }
 
   GeomVertexReader rvertex(data_reader, InternalName::get_vertex(), force); 
-  rvertex.set_row(_min_vertex);
+  rvertex.set_row_unsafe(_min_vertex);
 
   if (!rvertex.has_column()) {
     // Whoops, guess the vertex data isn't resident.