Merge branch 'release/1.9.x'

dtool/src/interrogate/interfaceMakerPythonNative.cxx

@@ -2862,9 +2862,10 @@ write_module_class(ostream &out, Object *obj) {
   }
 
   string gcflag;
-  if (obj->_protocol_types & Object::PT_python_gc) {
+  // Disabled for now because it's too unstable.
+  /*if (obj->_protocol_types & Object::PT_python_gc) {
     gcflag = " | Py_TPFLAGS_HAVE_GC";
-  }
+  }*/
 
   // long tp_flags;
   if (has_local_getbuffer) {

panda/src/egg2pg/eggLoader.cxx

@@ -2242,7 +2242,7 @@ make_vertex_data(const EggRenderState *render_state,
     PT(GeomVertexArrayFormat) anim_array_format = new GeomVertexArrayFormat;
     anim_array_format->add_column
       (InternalName::get_transform_blend(), 1,
-       Geom::NT_uint16, Geom::C_index);
+       Geom::NT_uint16, Geom::C_index, 0, 2);
     temp_format->add_array(anim_array_format);
 
     pmap<string, BitArray> slider_names;

panda/src/event/pythonTask.cxx

@@ -319,12 +319,14 @@ __getattr__(PyObject *attr) const {
  */
 int PythonTask::
 __traverse__(visitproc visit, void *arg) {
+/*
   Py_VISIT(_function);
   Py_VISIT(_args);
   Py_VISIT(_upon_death);
   Py_VISIT(_owner);
   Py_VISIT(__dict__);
   Py_VISIT(_generator);
+*/
   return 0;
 }
 
@@ -333,12 +335,14 @@ __traverse__(visitproc visit, void *arg) {
  */
 int PythonTask::
 __clear__() {
+/*
   Py_CLEAR(_function);
   Py_CLEAR(_args);
   Py_CLEAR(_upon_death);
   Py_CLEAR(_owner);
   Py_CLEAR(__dict__);
   Py_CLEAR(_generator);
+*/
   return 0;
 }
 

panda/src/gobj/geomVertexArrayFormat.cxx

@@ -363,7 +363,8 @@ align_columns_for_animation() {
       add_column(column->get_name(), 4, column->get_numeric_type(), column->get_contents(), -1, 16);
     } else {
       add_column(column->get_name(), column->get_num_components(),
-                 column->get_numeric_type(), column->get_contents());
+                 column->get_numeric_type(), column->get_contents(),
+                 -1, column->get_column_alignment());
     }
   }
 }

panda/src/gobj/texture.cxx

@@ -6652,25 +6652,84 @@ convert_from_pnmimage(PTA_uchar &image, size_t page_size,
 
   if (maxval == 255 && component_width == 1) {
     // Most common case: one byte per pixel, and the source image shows a
-    // maxval of 255.  No scaling is necessary.
+    // maxval of 255.  No scaling is necessary.  Because this is such a common
-    for (int j = y_size-1; j >= 0; j--) {
+    // case, we break it out per component for best performance.
-      for (int i = 0; i < x_size; i++) {
+    switch (num_components) {
-        if (is_grayscale) {
+    case 1:
-          store_unscaled_byte(p, pnmimage.get_gray_val(i, j));
+      for (int j = y_size-1; j >= 0; j--) {
-        } else {
+        xel *row = pnmimage.row(j);
-          store_unscaled_byte(p, pnmimage.get_blue_val(i, j));
+        for (int i = 0; i < x_size; i++) {
-          store_unscaled_byte(p, pnmimage.get_green_val(i, j));
+          *p++ = (uchar)PPM_GETB(row[i]);
-          store_unscaled_byte(p, pnmimage.get_red_val(i, j));
         }
-        if (has_alpha) {
+        p += row_skip;
-          if (img_has_alpha) {
+      }
-            store_unscaled_byte(p, pnmimage.get_alpha_val(i, j));
+      break;
-          } else {
+
-            store_unscaled_byte(p, 255);
+    case 2:
+      if (img_has_alpha) {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          xelval *alpha_row = pnmimage.alpha_row(j);
+          for (int i = 0; i < x_size; i++) {
+            *p++ = (uchar)PPM_GETB(row[i]);
+            *p++ = (uchar)alpha_row[i];
           }
+          p += row_skip;
+        }
+      } else {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          for (int i = 0; i < x_size; i++) {
+            *p++ = (uchar)PPM_GETB(row[i]);
+            *p++ = (uchar)255;
+          }
+          p += row_skip;
         }
       }
-      p += row_skip;
+      break;
+
+    case 3:
+      for (int j = y_size-1; j >= 0; j--) {
+        xel *row = pnmimage.row(j);
+        for (int i = 0; i < x_size; i++) {
+          *p++ = (uchar)PPM_GETB(row[i]);
+          *p++ = (uchar)PPM_GETG(row[i]);
+          *p++ = (uchar)PPM_GETR(row[i]);
+        }
+        p += row_skip;
+      }
+      break;
+
+    case 4:
+      if (img_has_alpha) {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          xelval *alpha_row = pnmimage.alpha_row(j);
+          for (int i = 0; i < x_size; i++) {
+            *p++ = (uchar)PPM_GETB(row[i]);
+            *p++ = (uchar)PPM_GETG(row[i]);
+            *p++ = (uchar)PPM_GETR(row[i]);
+            *p++ = (uchar)alpha_row[i];
+          }
+          p += row_skip;
+        }
+      } else {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          for (int i = 0; i < x_size; i++) {
+            *p++ = (uchar)PPM_GETB(row[i]);
+            *p++ = (uchar)PPM_GETG(row[i]);
+            *p++ = (uchar)PPM_GETR(row[i]);
+            *p++ = (uchar)255;
+          }
+          p += row_skip;
+        }
+      }
+      break;
+
+    default:
+      nassertv(num_components >= 1 && num_components <= 4);
+      break;
     }
 
   } else if (maxval == 65535 && component_width == 2) {
@@ -6845,17 +6904,44 @@ convert_to_pnmimage(PNMImage &pnmimage, int x_size, int y_size,
   const unsigned char *p = &image[idx];
 
   if (component_width == 1) {
-    for (int j = y_size-1; j >= 0; j--) {
+    if (is_grayscale) {
-      for (int i = 0; i < x_size; i++) {
+      if (has_alpha) {
-        if (is_grayscale) {
+        for (int j = y_size-1; j >= 0; j--) {
-          pnmimage.set_gray(i, j, get_unsigned_byte(p));
+          xel *row = pnmimage.row(j);
-        } else {
+          xelval *alpha_row = pnmimage.alpha_row(j);
-          pnmimage.set_blue(i, j, get_unsigned_byte(p));
+          for (int i = 0; i < x_size; i++) {
-          pnmimage.set_green(i, j, get_unsigned_byte(p));
+            PPM_PUTB(row[i], *p++);
-          pnmimage.set_red(i, j, get_unsigned_byte(p));
+            alpha_row[i] = *p++;
+          }
         }
-        if (has_alpha) {
+      } else {
-          pnmimage.set_alpha(i, j, get_unsigned_byte(p));
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          for (int i = 0; i < x_size; i++) {
+            PPM_PUTB(row[i], *p++);
+          }
+        }
+      }
+    } else {
+      if (has_alpha) {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          xelval *alpha_row = pnmimage.alpha_row(j);
+          for (int i = 0; i < x_size; i++) {
+            PPM_PUTB(row[i], *p++);
+            PPM_PUTG(row[i], *p++);
+            PPM_PUTR(row[i], *p++);
+            alpha_row[i] = *p++;
+          }
+        }
+      } else {
+        for (int j = y_size-1; j >= 0; j--) {
+          xel *row = pnmimage.row(j);
+          for (int i = 0; i < x_size; i++) {
+            PPM_PUTB(row[i], *p++);
+            PPM_PUTG(row[i], *p++);
+            PPM_PUTR(row[i], *p++);
+          }
         }
       }
     }
@@ -7773,11 +7859,15 @@ compare_images(const PNMImage &a, const PNMImage &b) {
 
   int delta = 0;
   for (int yi = 0; yi < a.get_y_size(); ++yi) {
+    xel *a_row = a.row(yi);
+    xel *b_row = b.row(yi);
+    xelval *a_alpha_row = a.alpha_row(yi);
+    xelval *b_alpha_row = b.alpha_row(yi);
     for (int xi = 0; xi < a.get_x_size(); ++xi) {
-      delta += abs(a.get_red_val(xi, yi) - b.get_red_val(xi, yi));
+      delta += abs(PPM_GETR(a_row[xi]) - PPM_GETR(b_row[xi]));
-      delta += abs(a.get_green_val(xi, yi) - b.get_green_val(xi, yi));
+      delta += abs(PPM_GETG(a_row[xi]) - PPM_GETG(b_row[xi]));
-      delta += abs(a.get_blue_val(xi, yi) - b.get_blue_val(xi, yi));
+      delta += abs(PPM_GETB(a_row[xi]) - PPM_GETB(b_row[xi]));
-      delta += abs(a.get_alpha_val(xi, yi) - b.get_alpha_val(xi, yi));
+      delta += abs(a_alpha_row[xi] - b_alpha_row[xi]);
     }
   }
 

panda/src/grutil/rigidBodyCombiner.cxx

@@ -210,9 +210,9 @@ convert_vd(const VertexTransform *transform, const GeomVertexData *orig) {
 
   PT(GeomVertexFormat) format = new GeomVertexFormat(*orig->get_format());
   if (!orig->get_format()->has_column(InternalName::get_transform_blend())) {
-    PT(GeomVertexArrayFormat) af =
+    PT(GeomVertexArrayFormat) af = new GeomVertexArrayFormat();
-      new GeomVertexArrayFormat(InternalName::get_transform_blend(), 1,
+    af->add_column(InternalName::get_transform_blend(), 1,
-                                Geom::NT_uint16, Geom::C_index);
+                   Geom::NT_uint16, Geom::C_index, 0, 2);
     format->add_array(af);
   }
 

panda/src/pnmimage/pnmImage.h

@@ -366,6 +366,7 @@ PUBLISHED:
 
 private:
   friend class Row;
+  friend class Texture;
 
   xel *_array;
   xelval *_alpha;