*** empty log message ***

dtool/src/dconfig/symbolEnt.cxx

@@ -5,6 +5,12 @@
 
 #include "symbolEnt.h"
 
+#define EXPCL EXPCL_DTOOLCONFIG 
+#define EXPTP EXPTP_DTOOLCONFIG 
+#define TYPE Config::SymbolEnt
+#define NAME vector_SymbolEnt
+#include "vector_src.cxx"
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

dtool/src/dconfig/symbolEnt.h

@@ -46,11 +46,11 @@ class EXPCL_DTOOLCONFIG SymbolEnt {
 
 } // close Config namespace
 
-#ifdef HAVE_DINKUM
-#define VV_SYMBOLENT std::_Vector_val<Config::SymbolEnt, std::allocator<Config::SymbolEnt> >
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOL, EXPTP_DTOOL, VV_SYMBOLENT)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOLCONFIG, EXPTP_DTOOLCONFIG, std::vector<Config::SymbolEnt>);
+#define EXPCL EXPCL_DTOOLCONFIG 
+#define EXPTP EXPTP_DTOOLCONFIG 
+#define TYPE Config::SymbolEnt
+#define NAME vector_SymbolEnt
+#include "vector_src.h"
 
 namespace Config {
 

dtool/src/dtoolutil/Sources.pp

@@ -9,12 +9,13 @@
     load_dso.cxx load_dso.h dSearchPath.I dSearchPath.cxx		\
     dSearchPath.h pfstream.h vector_string.cxx vector_string.h	        \
     gnu_getopt.c gnu_getopt.h gnu_getopt1.c pfstreamBuf.h pfstreamBuf.cxx \
-    pfstream.cxx
+    pfstream.cxx vector_src.h
 
   #define INSTALL_HEADERS \
     executionEnvironment.I executionEnvironment.h filename.I	\
     filename.h load_dso.h dSearchPath.I dSearchPath.h	\
     pfstream.h pfstream.I vector_string.h gnu_getopt.h \
-    pfstreamBuf.h
+    pfstreamBuf.h \
+    vector_src.cxx vector_src.h
 
 #end lib_target

dtool/src/dtoolutil/vector_src.cxx

@@ -0,0 +1,44 @@
+// Filename: vector_something_src.cxx
+// Created by:  drose (15May01)
+// 
+////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////
+//
+// This file defines the interface to declare and export from the DLL
+// an STL vector of some type.
+//
+// To use this file you must #define a number of symbols and then
+// #include it from a .cxx file.  You also must do the same thing with
+// vector_something_src.h from a .h file.
+//
+// This is necessary because of the complexity involved in exporting a
+// vector class from a DLL.  If we are using the Dinkumware STL
+// implementation, it is even more complex.  However, all this
+// complexity is only needed to support Windows builds; Unix shared
+// libraries are able to export symbols (including templates) without
+// any special syntax.
+//
+////////////////////////////////////////////////////////////////////
+
+
+// The following variables should be defined prior to including this
+// file:
+//
+//   EXPCL - the appropriate EXPCL_* symbol for this DLL.
+//   EXPTP - the appropriate EXPTP_* symbol for this DLL.
+//   TYPE - the type of thing we are building a vector on.
+//   NAME - The name of the resulting vector typedef, e.g. vector_int.
+//
+// They will automatically be undefined at the end of the file.
+
+void 
+insert_into_vector(NAME &vec, NAME::iterator where,
+		   NAME::const_pointer begin, NAME::const_pointer end) {
+  vec.insert(where, begin, end);
+}
+
+#undef EXPCL
+#undef EXPTP
+#undef TYPE
+#undef NAME

dtool/src/dtoolutil/vector_src.h

@@ -0,0 +1,69 @@
+// Filename: vector_something_src.h
+// Created by:  drose (15May01)
+// 
+////////////////////////////////////////////////////////////////////
+
+
+////////////////////////////////////////////////////////////////////
+//
+// This file defines the interface to declare and export from the DLL
+// an STL vector of some type.
+//
+// To use this file you must #define a number of symbols and then
+// #include it from a .h file.  You also must do the same thing with
+// vector_something_src.cxx from a .cxx file.
+//
+// This is necessary because of the complexity involved in exporting a
+// vector class from a DLL.  If we are using the Dinkumware STL
+// implementation, it is even more complex.  However, all this
+// complexity is only needed to support Windows builds; Unix shared
+// libraries are able to export symbols (including templates) without
+// any special syntax.
+//
+////////////////////////////////////////////////////////////////////
+
+// The following variables should be defined prior to including this
+// file:
+//
+//   EXPCL - the appropriate EXPCL_* symbol for this DLL.
+//   EXPTP - the appropriate EXPTP_* symbol for this DLL.
+//   TYPE - the type of thing we are building a vector on.
+//   NAME - The name of the resulting vector typedef, e.g. vector_int.
+//
+// They will automatically be undefined at the end of the file.
+
+#include <vector>
+
+#if defined(WIN32_VC) && !defined(CPPPARSER)
+
+  #ifdef HAVE_DINKUM
+// With the Dinkum library, we must first export the base class,
+// _Vector_val.
+    #define VV_BASE std::_Vector_val<TYPE, std::allocator<TYPE> >
+EXPORT_TEMPLATE_CLASS(EXPCL, EXPTP, VV_BASE)
+    #undef VV_BASE
+  #endif
+
+// Now we can export the vector class.
+EXPORT_TEMPLATE_CLASS(EXPCL, EXPTP, std::vector<TYPE>)
+
+#endif
+
+// Now make a typedef for the vector.
+typedef std::vector<TYPE> NAME;
+
+  // Finally, we must define a non-inline function that performs the
+  // insert operation given a range of pointers.  We do this because
+  // the Dinkum STL implementation uses member templates to handle
+  // this, but we cannot export the member templates from the DLL.
+
+extern EXPCL void
+insert_into_vector(NAME &vec, NAME::iterator where,
+		   const TYPE *begin, const TYPE *end);
+
+
+#undef EXPCL
+#undef EXPTP
+#undef TYPE
+#undef NAME
+

dtool/src/dtoolutil/vector_string.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_string.h"
 
+#define EXPCL EXPCL_DTOOLCONFIG 
+#define EXPTP EXPTP_DTOOLCONFIG 
+#define TYPE std::string
+#define NAME vector_string
+
+#include "vector_src.cxx"
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

dtool/src/dtoolutil/vector_string.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_STRING std::_Vector_val<std::string, std::allocator<std::string> >
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOL, EXPTP_DTOOL, VV_STRING)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOL, EXPTP_DTOOL, std::vector<std::string>)
-typedef vector<string> vector_string;
+#define EXPCL EXPCL_DTOOL 
+#define EXPTP EXPTP_DTOOL 
+#define TYPE std::string
+#define NAME vector_string
+
+#include "vector_src.h"
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

dtool/src/interrogatedb/Sources.pp

@@ -20,8 +20,8 @@
     vector_int.h
 
   #define INSTALL_HEADERS \
-    interrogate_interface.h interrogate_request.h \
-    vector_int.h config_interrogatedb.h
+    interrogate_interface.h interrogate_request.h vector_int.h \
+    config_interrogatedb.h
 
 // These are temporary; they need not be installed in the future.  These are
 // necessary only when using template stopgap.

dtool/src/interrogatedb/interrogateDatabase.cxx

@@ -34,6 +34,12 @@ InterrogateDatabase() {
 InterrogateDatabase *InterrogateDatabase::
 get_ptr() {
   if (_global_ptr == (InterrogateDatabase *)NULL) {
+#ifndef NDEBUG
+    if (interrogatedb_cat->is_debug()) {
+      interrogatedb_cat->debug()
+	<< "Creating interrogate database\n";
+    }
+#endif
     _global_ptr = new InterrogateDatabase;
   }
   return _global_ptr;
@@ -50,6 +56,7 @@ get_ptr() {
 ////////////////////////////////////////////////////////////////////
 void InterrogateDatabase::
 request_module(InterrogateModuleDef *def) {
+#ifndef NDEBUG
   if (interrogatedb_cat->is_debug()) {
     if (def->library_name == (const char *)NULL) {
       interrogatedb_cat->debug()
@@ -59,6 +66,7 @@ request_module(InterrogateModuleDef *def) {
 	<< "Got interrogate data for module " << def->library_name << "\n";
     }
   }
+#endif
 
   int num_indices = def->next_index - def->first_index;
   if (num_indices > 0) {
@@ -854,6 +862,7 @@ load_latest() {
   Requests::const_iterator ri;
   for (ri = copy_requests.begin(); ri != copy_requests.end(); ++ri) {
     InterrogateModuleDef *def = (*ri);
+
     if (def->database_filename != (char *)NULL) {
       Filename filename = def->database_filename;
       Filename pathname = filename;

dtool/src/interrogatedb/vector_int.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_int.h"
 
+#define EXPCL EXPCL_DTOOLCONFIG 
+#define EXPTP EXPTP_DTOOLCONFIG 
+#define TYPE int
+#define NAME vector_int
+
+#include "vector_src.cxx"
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

dtool/src/interrogatedb/vector_int.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_INT std::_Vector_val<int, std::allocator<int> >
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOLCONFIG, EXPTP_DTOOLCONFIG, VV_INT)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_DTOOLCONFIG, EXPTP_DTOOLCONFIG, std::vector<int>)
-typedef vector<int> vector_int;
+#define EXPCL EXPCL_DTOOLCONFIG 
+#define EXPTP EXPTP_DTOOLCONFIG 
+#define TYPE int
+#define NAME vector_int
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/chan/vector_PartGroupStar.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PartGroupStar.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE PartGroup *
+#define NAME vector_PartGroupStar
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/chan/vector_PartGroupStar.h

@@ -22,12 +22,12 @@
 //               vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PARTGROUPSTAR std::_Vector_val<PartGroup *, std::allocator<PartGroup *> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_PARTGROUPSTAR)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<PartGroup *>)
-typedef vector<PartGroup *> vector_PartGroupStar;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE PartGroup *
+#define NAME vector_PartGroupStar
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/display/graphicsWindowInputDevice.cxx

@@ -7,6 +7,12 @@
 #include <mouseButton.h>
 #include <keyboardButton.h>
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE GraphicsWindowInputDevice
+#define NAME vector_GraphicsWindowInputDevice
+
+#include <vector_src.cxx>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/display/graphicsWindowInputDevice.h

@@ -76,12 +76,12 @@ private:
 
 #include "graphicsWindowInputDevice.I"
 
-#ifdef HAVE_DINKUM
-#define VV_GRAPHICSWINDOWINPUTDEVICE std::_Vector_val<GraphicsWindowInputDevice, std::allocator<GraphicsWindowInputDevice> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_GRAPHICSWINDOWINPUTDEVICE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<GraphicsWindowInputDevice>)
-typedef vector<GraphicsWindowInputDevice> vector_GraphicsWindowInputDevice;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE GraphicsWindowInputDevice
+#define NAME vector_GraphicsWindowInputDevice
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/egg/Sources.pp

@@ -24,7 +24,7 @@
     eggMaterialCollection.h \
     eggMiscFuncs.I \
     eggMiscFuncs.cxx eggMiscFuncs.h \
-    eggMorph.I eggMorph.h eggMorphList.I eggMorphList.h \
+    eggMorph.I eggMorph.h eggMorphList.cxx eggMorphList.I eggMorphList.h \
     eggNamedObject.I eggNamedObject.cxx \
     eggNamedObject.h eggNameUniquifier.cxx eggNameUniquifier.h \
     eggNode.I eggNode.cxx eggNode.h eggNurbsCurve.I \

panda/src/egg/eggMorphList.cxx

@@ -0,0 +1,26 @@
+// Filename: eggMorphList.cxx
+// Created by:  drose (15May01)
+//
+////////////////////////////////////////////////////////////////////
+
+#include "eggMorphList.h"
+
+// Continue all of the vector import definitions.
+
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector3d
+#define NAME vector_LVector3d
+#include <vector_src.cxx>
+
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector2d
+#define NAME vector_LVector2d
+#include <vector_src.cxx>
+
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector4f
+#define NAME vector_LVector4f
+#include <vector_src.cxx>

panda/src/egg/eggMorphList.h

@@ -53,10 +53,27 @@ private:
   Morphs _morphs;
 };
 
+// Export all of the vectors.
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<LVector3d>)
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<LVector2d>)
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<LVector4f>)
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector3d
+#define NAME vector_LVector3d
+#include <vector_src.h>
+
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector2d
+#define NAME vector_LVector2d
+#include <vector_src.h>
+
+#define EXPCL EXPCL_PANDAEGG 
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE LVector4f
+#define NAME vector_LVector4f
+#include <vector_src.h>
+
+// Now export each EggMorphList.
 
 EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, EggMorphList<LVector3d>)
 EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, EggMorphList<LVector2d>)

panda/src/egg/vector_PT_EggMaterial.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PT_EggMaterial.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE PT_EggMaterial
+#define NAME vector_PT_EggMaterial
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/egg/vector_PT_EggMaterial.h

@@ -22,12 +22,12 @@
 //               file, rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_EGGMATERIAL std::_Vector_val<PT_EggMaterial, std::allocator<PT_EggMaterial> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, VV_PT_EGGMATERIAL)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<PT_EggMaterial>)
-typedef vector<PT_EggMaterial> vector_PT_EggMaterial;
+#define EXPCL EXPCL_PANDAEGG
+#define EXPTP EXPTP_PANDAEGG
+#define TYPE PT_EggMaterial
+#define NAME vector_PT_EggMaterial
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/egg/vector_PT_EggTexture.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PT_EggTexture.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE PT_EggTexture
+#define NAME vector_PT_EggTexture
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/egg/vector_PT_EggTexture.h

@@ -22,12 +22,12 @@
 //               file, rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_EGGTEXTURE std::_Vector_val<PT_EggTexture, std::allocator<PT_EggTexture> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, VV_PT_EGGTEXTURE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<PT_EggTexture>)
-typedef vector<PT_EggTexture> vector_PT_EggTexture;
+#define EXPCL EXPCL_PANDAEGG
+#define EXPTP EXPTP_PANDAEGG
+#define TYPE PT_EggTexture
+#define NAME vector_PT_EggTexture
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/egg/vector_PT_EggVertex.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PT_EggVertex.h"
 
+#define EXPCL EXPCL_PANDAEGG
+#define EXPTP EXPTP_PANDAEGG 
+#define TYPE PT_EggVertex
+#define NAME vector_PT_EggVertex
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/egg/vector_PT_EggVertex.h

@@ -22,12 +22,12 @@
 //               file, rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_EGGVERTEX std::_Vector_val<PT_EggVertex, std::allocator<PT_EggVertex> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, VV_PT_EGGVERTEX)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDAEGG, EXPTP_PANDAEGG, std::vector<PT_EggVertex>)
-typedef vector<PT_EggVertex> vector_PT_EggVertex;
+#define EXPCL EXPCL_PANDAEGG
+#define EXPTP EXPTP_PANDAEGG
+#define TYPE PT_EggVertex
+#define NAME vector_PT_EggVertex
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/egg2sg/eggLoader.cxx

@@ -1938,8 +1938,10 @@ create_collision_polygons(CollisionNode *cnode, EggPolygon *egg_poly,
     }
 
     if (vertices.size() >= 3) {
+      const Vertexf *vertices_begin = &vertices[0];
+      const Vertexf *vertices_end = vertices_begin + vertices.size();
       CollisionPolygon *cspoly = 
-	new CollisionPolygon(vertices.begin(), vertices.end());
+	new CollisionPolygon(vertices_begin, vertices_end);
       apply_collision_flags(cspoly, flags);
       cnode->add_solid(cspoly);
     }

panda/src/egg2sg/eggLoader.h

@@ -12,8 +12,10 @@
 
 #include <eggData.h>
 #include <eggTexture.h>
+#include <pt_EggTexture.h>
 #include <eggGroup.h>
 #include <eggMaterial.h>
+#include <pt_EggMaterial.h>
 #include <texture.h>
 #include <namedNode.h>
 #include <pt_NamedNode.h>
@@ -119,10 +121,10 @@ private:
   typedef set<PT(TextureApplyTransition), IndirectCompareTo<NodeTransition> > TextureApplies;
   TextureApplies _texture_applies;
 
-  typedef map<PT(EggTexture), TextureDef> Textures;
+  typedef map<PT_EggTexture, TextureDef> Textures;
   Textures _textures;
 
-  typedef map<CPT(EggMaterial), PT(MaterialTransition) > Materials;
+  typedef map<CPT_EggMaterial, PT(MaterialTransition) > Materials;
   Materials _materials;
   Materials _materials_bface;
 

panda/src/gobj/LOD.cxx

@@ -12,6 +12,13 @@
 #include <datagramIterator.h>
 #include <indent.h>
 
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE LODSwitch
+#define NAME LODSwitchVector
+
+#include <vector_src.cxx>
+
 ////////////////////////////////////////////////////////////////////
 // Static variables
 ////////////////////////////////////////////////////////////////////

panda/src/gobj/LOD.h

@@ -58,12 +58,12 @@ protected:
   float _out;
 };
 
-#ifdef HAVE_DINKUM
-#define VV_LODSWITCH std::_Vector_val<LODSwitch, std::allocator<LODSwitch> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_LODSWITCH)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<LODSwitch>)
-typedef vector<LODSwitch> LODSwitchVector;
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE LODSwitch
+#define NAME LODSwitchVector
+
+#include <vector_src.h>
 
 ////////////////////////////////////////////////////////////////////
 //       Class : LOD

panda/src/graph/vector_NodeRelation_star.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_NodeRelation_star.h"
 
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE NodeRelation *
+#define NAME vector_NodeRelation_star
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/graph/vector_NodeRelation_star.h

@@ -21,12 +21,12 @@ class NodeRelation;
 //               file, rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_NODERELATION_STAR std::_Vector_val<NodeRelation *, std::allocator<NodeRelation *> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_NODERELATION_STAR)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<NodeRelation *>)
-typedef vector<NodeRelation *> vector_NodeRelation_star;
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE NodeRelation *
+#define NAME vector_NodeRelation_star
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/graph/vector_PT_Node.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PT_Node.h"
 
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_Node
+#define NAME vector_PT_Node
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/graph/vector_PT_Node.h

@@ -22,12 +22,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_NODE std::_Vector_val<PT_Node, std::allocator<PT_Node> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_PT_NODE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<PT_Node>)
-typedef vector<PT_Node> vector_PT_Node;
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_Node
+#define NAME vector_PT_Node
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/graph/vector_PT_NodeRelation.cxx

@@ -6,6 +6,13 @@
 #include "node.h"
 #include "vector_PT_NodeRelation.h"
 
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_NodeRelation
+#define NAME vector_PT_NodeRelation
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/graph/vector_PT_NodeRelation.h

@@ -22,12 +22,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_NODERELATION std::_Vector_val<PT_NodeRelation, std::allocator<PT_NodeRelation> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_PT_NODERELATION)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<PT_NodeRelation>)
-typedef vector<PT_NodeRelation> vector_PT_NodeRelation;
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_NodeRelation
+#define NAME vector_PT_NodeRelation
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/light/vector_PT_Light.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_PT_Light.h"
 
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_Light
+#define NAME vector_PT_Light
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/light/vector_PT_Light.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_PT_LIGHT std::_Vector_val<PT_Light, std::allocator<PT_Light> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_PT_LIGHT)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<PT_Light>)
-typedef vector<PT_Light> vector_PT_Light;
+#define EXPCL EXPCL_PANDA
+#define EXPTP EXPTP_PANDA
+#define TYPE PT_Light
+#define NAME vector_PT_Light
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/linmath/vector_Colorf.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_Colorf.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Colorf
+#define NAME vector_Colorf
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/linmath/vector_Colorf.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_COLORF std::_Vector_val<Colorf, std::allocator<Colorf> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_COLORF)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<Colorf>)
-typedef vector<Colorf> vector_Colorf;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Colorf
+#define NAME vector_Colorf
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/linmath/vector_LPoint2f.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_LPoint2f.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE LPoint2f
+#define NAME vector_LPoint2f
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/linmath/vector_LPoint2f.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_LPOINT2F std::_Vector_val<LPoint2f, std::allocator<LPoint2f> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_LPOINT2F)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<LPoint2f>)
-typedef vector<LPoint2f> vector_LPoint2f;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE LPoint2f
+#define NAME vector_LPoint2f
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/linmath/vector_LVecBase3f.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_LVecBase3f.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE LVecBase3f
+#define NAME vector_LVecBase3f
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/linmath/vector_LVecBase3f.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_LVECBASE3F std::_Vector_val<LVecBase3f, std::allocator<LVecBase3f> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_LVECBASE3F)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<LVecBase3f>)
-typedef vector<LVecBase3f> vector_LVecBase3f;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE LVecBase3f
+#define NAME vector_LVecBase3f
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/linmath/vector_Normalf.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_Normalf.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Normalf
+#define NAME vector_Normalf
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/linmath/vector_Normalf.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_NORMALF std::_Vector_val<Normalf, std::allocator<Normalf> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_NORMALF)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<Normalf>)
-typedef vector<Normalf> vector_Normalf;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Normalf
+#define NAME vector_Normalf
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/linmath/vector_Vertexf.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_Vertexf.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Vertexf
+#define NAME vector_Vertexf
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/linmath/vector_Vertexf.h

@@ -21,12 +21,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_VERTEXF std::_Vector_val<Vertexf, std::allocator<Vertexf> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_VERTEXF)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<Vertexf>)
-typedef vector<Vertexf> vector_Vertexf;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Vertexf
+#define NAME vector_Vertexf
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/physics/physicsManager.cxx

@@ -3,12 +3,12 @@
 // 
 ////////////////////////////////////////////////////////////////////
 
-#include <algorithm>
-#include <vector>
-
 #include "physicsManager.h"
 #include "actorNode.h"
 
+#include <algorithm>
+#include <vector>
+
 ////////////////////////////////////////////////////////////////////
 //     Function : PhysicsManager
 //       Access : Public

panda/src/putil/pointerToArray.I

@@ -239,37 +239,6 @@ insert(iterator position, size_type n, const Element &x) const {
   _ptr->insert(position, n, x);
 }
 
-#ifdef HAVE_MEMBER_TEMPLATES
-////////////////////////////////////////////////////////////////////
-//     Function: PointerToArray::insert
-//       Access: Public
-//  Description: 
-////////////////////////////////////////////////////////////////////
-template<class Element>
-template<class InputIterator>
-INLINE void PointerToArray<Element>::
-insert(iterator position, InputIterator first, InputIterator last) const {
-  nassertv(_ptr != NULL);
-  nassertv(position >= _ptr->begin() &&
-	   position <= _ptr->end());
-  _ptr->insert(position, first, last);
-}
-#else
-////////////////////////////////////////////////////////////////////
-//     Function: PointerToArray::insert
-//       Access: Public
-//  Description: 
-////////////////////////////////////////////////////////////////////
-template<class Element>
-INLINE void PointerToArray<Element>::
-insert(iterator position, const Element *first, const Element *last) const {
-  nassertv(_ptr != NULL);
-  nassertv(position >= _ptr->begin() &&
-	   position <= _ptr->end());
-  _ptr->insert(position, first, last);
-}
-#endif
-
 ////////////////////////////////////////////////////////////////////
 //     Function: PointerToArray::erase
 //       Access: Public

panda/src/putil/pointerToArray.h

@@ -118,12 +118,12 @@ public:
   INLINE iterator insert(iterator position, const Element &x) const;
   INLINE void insert(iterator position, size_type n, const Element &x) const;
 
-#ifdef HAVE_MEMBER_TEMPLATES
-  template<class InputIterator>
-  INLINE void insert(iterator position, InputIterator first, InputIterator last) const;
-#else
-  INLINE void insert(iterator position, const Element *first, const Element *last) const;
-#endif
+  // We don't define the insert() method that accepts a pair of
+  // iterators to copy from.  That's problematic because of the whole
+  // member template thing.  If you really need this, use
+  // pta.v().insert(...); if you're doing this on a vector that has to
+  // be exported from the DLL, you should use
+  // insert_into_vector(pta.v(), ...).
 
   INLINE void erase(iterator position) const;
   INLINE void erase(iterator first, iterator last) const;
@@ -169,7 +169,6 @@ private:
   static vector<Element> _empty_array;
 };
 
-
 ////////////////////////////////////////////////////////////////////
 // 	 Class : ConstPointerToArray
 // Description : Similar to PointerToArray, except that its contents

panda/src/putil/vector_double.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_double.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE double
+#define NAME vector_double
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_double.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_DOUBLE std::_Vector_val<double, std::allocator<double> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_DOUBLE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<double>)
-typedef vector<double> vector_double;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE double
+#define NAME vector_double
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_float.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_float.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE float
+#define NAME vector_float
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_float.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_FLOAT std::_Vector_val<float, std::allocator<float> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_FLOAT)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<float>)
-typedef vector<float> vector_float;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE float
+#define NAME vector_float
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_typedWritable.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_typedWritable.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE TypedWritable *
+#define NAME vector_typedWritable
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_typedWritable.h

@@ -21,12 +21,12 @@ class TypedWritable;
 //               file, rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_TYPEDWRITABLE std::_Vector_val<TypedWritable *, std::allocator<TypedWritable *> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_TYPEDWRITABLE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<TypedWritable*>)
-typedef vector<TypedWritable*> vector_typedWritable;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE TypedWritable *
+#define NAME vector_typedWritable
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_uchar.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_uchar.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned char
+#define NAME vector_uchar
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_uchar.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_UCHAR std::_Vector_val<unsigned char, std::allocator<unsigned char> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_UCHAR)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<unsigned char>)
-typedef vector<unsigned char> vector_uchar;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned char
+#define NAME vector_uchar
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_ulong.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_ulong.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned long
+#define NAME vector_ulong
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_ulong.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_ULONG std::_Vector_val<unsigned long, std::allocator<unsigned long> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_ULONG)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<unsigned long>)
-typedef vector<unsigned long> vector_ulong;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned long
+#define NAME vector_ulong
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_ushort.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_ushort.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned short
+#define NAME vector_ushort
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_ushort.h

@@ -19,12 +19,12 @@
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_USHORT std::_Vector_val<unsigned short, std::allocator<unsigned short> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_USHORT)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<unsigned short>)
-typedef vector<unsigned short> vector_ushort;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE unsigned short
+#define NAME vector_ushort
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/putil/vector_writable.cxx

@@ -5,6 +5,13 @@
 
 #include "vector_writable.h"
 
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Writable *
+#define NAME vector_writable
+
+#include <vector_src.cxx>
+
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__
 #pragma implementation

panda/src/putil/vector_writable.h

@@ -21,12 +21,12 @@ class Writable;
 //               rather than defining the vector again.
 ////////////////////////////////////////////////////////////////////
 
-#ifdef HAVE_DINKUM
-#define VV_WRITABLE std::_Vector_val<Writable *, std::allocator<Writable *> >
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, VV_WRITABLE)
-#endif
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, std::vector<Writable*>)
-typedef vector<Writable*> vector_writable;
+#define EXPCL EXPCL_PANDA 
+#define EXPTP EXPTP_PANDA 
+#define TYPE Writable *
+#define NAME vector_writable
+
+#include <vector_src.h>
 
 // Tell GCC that we'll take care of the instantiation explicitly here.
 #ifdef __GNUC__

panda/src/sgraph/geomNode.cxx

@@ -212,7 +212,7 @@ void GeomNode::
 add_geoms_from(const GeomNode *other) {
   const PT(dDrawable) *geoms_begin = &other->_geoms[0];
   const PT(dDrawable) *geoms_end = geoms_begin + other->_geoms.size();
-  _geoms.insert(_geoms.end(), geoms_begin, geoms_end);
+  _geoms.v().insert(_geoms.end(), geoms_begin, geoms_end);
   mark_bound_stale();
 }