okay, this is going to be a big commit. The basic idea here is to add transparent defines to allow for directory based dlls later. This will let us build tau again. ugggg

panda/src/audio/audioDSP.h

@@ -27,7 +27,7 @@
 class AudioManager;
 
 
-class EXPCL_PANDA AudioDSP : public TypedReferenceCount {
+class EXPCL_PANDA_AUDIO AudioDSP : public TypedReferenceCount {
 	PUBLISHED:
 	    virtual void reset();
 	    virtual void remove();

panda/src/audio/audioLoadRequest.h

@@ -35,7 +35,7 @@
 //               and add it to the loader via load_async(), to begin
 //               an asynchronous load.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AudioLoadRequest : public AsyncTask {
+class EXPCL_PANDA_AUDIO AudioLoadRequest : public AsyncTask {
 PUBLISHED:
   INLINE AudioLoadRequest(AudioManager *audio_manager, const string &filename, 
                           bool positional);

panda/src/audio/audioManager.h

@@ -27,7 +27,7 @@
 typedef PT(AudioManager) Create_AudioManager_proc();
 
 
-class EXPCL_PANDA AudioManager : public TypedReferenceCount {
+class EXPCL_PANDA_AUDIO AudioManager : public TypedReferenceCount {
 PUBLISHED:
 
 

panda/src/audio/audioSound.h

@@ -29,7 +29,7 @@
 class AudioManager;
 
 
-class EXPCL_PANDA AudioSound : public TypedReferenceCount {
+class EXPCL_PANDA_AUDIO AudioSound : public TypedReferenceCount {
 	PUBLISHED:
 		virtual ~AudioSound();
 		  

panda/src/audio/config_audio.h

@@ -31,31 +31,31 @@
 #pragma warning (disable : 4231)
 #endif
 
-NotifyCategoryDecl(audio, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(audio, EXPCL_PANDA_AUDIO, EXPTP_PANDA_AUDIO);
 
-extern EXPCL_PANDA ConfigVariableBool audio_active;
-extern EXPCL_PANDA ConfigVariableInt audio_cache_limit;
-extern EXPCL_PANDA ConfigVariableDouble audio_volume;
-extern EXPCL_PANDA ConfigVariableFilename audio_dls_file;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool audio_active;
+extern EXPCL_PANDA_AUDIO ConfigVariableInt audio_cache_limit;
+extern EXPCL_PANDA_AUDIO ConfigVariableDouble audio_volume;
+extern EXPCL_PANDA_AUDIO ConfigVariableFilename audio_dls_file;
 
 //We Need This one.
-extern EXPCL_PANDA ConfigVariableString audio_library_name;
+extern EXPCL_PANDA_AUDIO ConfigVariableString audio_library_name;
 
 // Config vars for Fmod:
 
-extern EXPCL_PANDA ConfigVariableInt fmod_number_of_sound_channels;
-extern EXPCL_PANDA ConfigVariableBool fmod_use_surround_sound;
+extern EXPCL_PANDA_AUDIO ConfigVariableInt fmod_number_of_sound_channels;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool fmod_use_surround_sound;
 
 // Config vars for Miles:
 
-extern EXPCL_PANDA ConfigVariableBool audio_software_midi;
-extern EXPCL_PANDA ConfigVariableFilename audio_dls_file;
-extern EXPCL_PANDA ConfigVariableBool audio_play_midi;
-extern EXPCL_PANDA ConfigVariableBool audio_play_wave;
-extern EXPCL_PANDA ConfigVariableBool audio_play_mp3;
-extern EXPCL_PANDA ConfigVariableInt audio_output_rate;
-extern EXPCL_PANDA ConfigVariableInt audio_output_bits;
-extern EXPCL_PANDA ConfigVariableInt audio_output_channels;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool audio_software_midi;
+extern EXPCL_PANDA_AUDIO ConfigVariableFilename audio_dls_file;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool audio_play_midi;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool audio_play_wave;
+extern EXPCL_PANDA_AUDIO ConfigVariableBool audio_play_mp3;
+extern EXPCL_PANDA_AUDIO ConfigVariableInt audio_output_rate;
+extern EXPCL_PANDA_AUDIO ConfigVariableInt audio_output_bits;
+extern EXPCL_PANDA_AUDIO ConfigVariableInt audio_output_channels;
 
 
 

panda/src/audio/nullAudioDSP.h

@@ -27,7 +27,7 @@
 class AudioManager;
 
 
-class EXPCL_PANDA nullAudioDSP : public TypedReferenceCount {
+class EXPCL_PANDA_AUDIO nullAudioDSP : public TypedReferenceCount {
 	PUBLISHED:
 	    virtual void reset();
 	    virtual void remove();

panda/src/audio/nullAudioManager.h

@@ -23,7 +23,7 @@
 #include "audioManager.h"
 #include "nullAudioSound.h"
 
-class EXPCL_PANDA NullAudioManager : public AudioManager {
+class EXPCL_PANDA_AUDIO NullAudioManager : public AudioManager {
   // All of these methods are stubbed out to some degree.
   // If you're looking for a starting place for a new AudioManager,
   // please consider looking at the milesAudioManager.

panda/src/audio/nullAudioSound.h

@@ -26,7 +26,7 @@
 // This class intentionally does next to nothing.
 // It's used as a placeholder when you don't want a sound
 // system.
-class EXPCL_PANDA NullAudioSound : public AudioSound {
+class EXPCL_PANDA_AUDIO NullAudioSound : public AudioSound {
   // All of these methods are stubbed out to some degree.
   // If you're looking for a starting place for a new AudioManager,
   // please consider looking at the milesAudioManager.

panda/src/chan/animBundle.h

@@ -32,7 +32,7 @@ class FactoryParams;
 //               knows the frame rate and number of frames of all the
 //               channels in the hierarchy (which must all match).
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimBundle : public AnimGroup {
+class EXPCL_PANDA_CHAN AnimBundle : public AnimGroup {
 protected:
   AnimBundle(AnimGroup *parent, const AnimBundle &copy);
 

panda/src/chan/animBundleNode.h

@@ -32,7 +32,7 @@
 //               AnimBundle.  Like AnimBundleNode, it exists solely to
 //               make it easy to store AnimBundles in the scene graph.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimBundleNode : public PandaNode {
+class EXPCL_PANDA_CHAN AnimBundleNode : public PandaNode {
 public:
   INLINE AnimBundleNode(const string &name, AnimBundle *bundle);
 

panda/src/chan/animChannel.h

@@ -82,7 +82,7 @@ private:
 
 // And now we instantiate a few useful types.
 
-class EXPCL_PANDA ACMatrixSwitchType {
+class EXPCL_PANDA_CHAN ACMatrixSwitchType {
 public:
   typedef LMatrix4f ValueType;
   static const char *get_channel_type_name() { return "AnimChannelMatrix"; }
@@ -100,11 +100,11 @@ public:
   }
 };
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, AnimChannel<ACMatrixSwitchType>);
+EXPORT_TEMPLATE_CLASS(EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN, AnimChannel<ACMatrixSwitchType>);
 typedef AnimChannel<ACMatrixSwitchType> AnimChannelMatrix;
 
 
-class EXPCL_PANDA ACScalarSwitchType {
+class EXPCL_PANDA_CHAN ACScalarSwitchType {
 public:
   typedef float ValueType;
   static const char *get_channel_type_name() { return "AnimChannelScalar"; }
@@ -123,7 +123,7 @@ public:
   }
 };
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, AnimChannel<ACScalarSwitchType>);
+EXPORT_TEMPLATE_CLASS(EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN, AnimChannel<ACScalarSwitchType>);
 typedef AnimChannel<ACScalarSwitchType> AnimChannelScalar;
 
 

panda/src/chan/animChannelBase.h

@@ -34,7 +34,7 @@
 //               a table read from an egg file (but possibly computed
 //               or generated in any other way).
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelBase : public AnimGroup {
+class EXPCL_PANDA_CHAN AnimChannelBase : public AnimGroup {
 protected:
   // The default constructor is protected: don't try to create an
   // AnimChannel without a parent.  To create an AnimChannel hierarchy,

panda/src/chan/animChannelMatrixDynamic.h

@@ -38,7 +38,7 @@
 //               the node whose transform will be copied to the joint
 //               each frame.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelMatrixDynamic : public AnimChannelMatrix {
+class EXPCL_PANDA_CHAN AnimChannelMatrixDynamic : public AnimChannelMatrix {
 protected:
   AnimChannelMatrixDynamic();
   AnimChannelMatrixDynamic(AnimGroup *parent, const AnimChannelMatrixDynamic &copy);

panda/src/chan/animChannelMatrixFixed.h

@@ -24,14 +24,14 @@
 #include "animChannel.h"
 #include "luse.h"
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, AnimChannel<ACMatrixSwitchType>);
+EXPORT_TEMPLATE_CLASS(EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN, AnimChannel<ACMatrixSwitchType>);
 
 ////////////////////////////////////////////////////////////////////
 //       Class : AnimChannelMatrixFixed
 // Description : A specialization on AnimChannel to add all the
 //               special matrix component operations.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelMatrixFixed : public AnimChannel<ACMatrixSwitchType> {
+class EXPCL_PANDA_CHAN AnimChannelMatrixFixed : public AnimChannel<ACMatrixSwitchType> {
 protected:
   AnimChannelMatrixFixed(AnimGroup *parent, const AnimChannelMatrixFixed &copy);
 

panda/src/chan/animChannelMatrixXfmTable.h

@@ -35,7 +35,7 @@
 //               sub-tables, each representing one component of the
 //               transform: scale, rotate, translate.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelMatrixXfmTable : public AnimChannelMatrix {
+class EXPCL_PANDA_CHAN AnimChannelMatrixXfmTable : public AnimChannelMatrix {
 protected:
   AnimChannelMatrixXfmTable();
   AnimChannelMatrixXfmTable(AnimGroup *parent, const AnimChannelMatrixXfmTable &copy);

panda/src/chan/animChannelScalarDynamic.h

@@ -38,7 +38,7 @@ class TransformState;
 //               the node whose X component will be copied to the
 //               scalar each frame.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelScalarDynamic : public AnimChannelScalar {
+class EXPCL_PANDA_CHAN AnimChannelScalarDynamic : public AnimChannelScalar {
 protected:
   AnimChannelScalarDynamic();
   AnimChannelScalarDynamic(AnimGroup *parent, const AnimChannelScalarDynamic &copy);

panda/src/chan/animChannelScalarTable.h

@@ -32,7 +32,7 @@
 //               read from a table such as might have been read from
 //               an egg file.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimChannelScalarTable : public AnimChannelScalar {
+class EXPCL_PANDA_CHAN AnimChannelScalarTable : public AnimChannelScalar {
 protected:
   AnimChannelScalarTable();
   AnimChannelScalarTable(AnimGroup *parent, const AnimChannelScalarTable &copy);

panda/src/chan/animControl.h

@@ -39,7 +39,7 @@ class AnimChannelBase;
 //               animation: whether started, stopped, or looping, and
 //               the current frame number and play rate.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimControl : public ReferenceCount, public AnimInterface {
+class EXPCL_PANDA_CHAN AnimControl : public ReferenceCount, public AnimInterface {
 public:
   AnimControl(PartBundle *part, AnimBundle *anim, int channel_index,
               const BitArray &bound_joints);

panda/src/chan/animControlCollection.h

@@ -38,7 +38,7 @@
 //               previous control's reference count (and possibly
 //               delete it, unbinding its animation).
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimControlCollection {
+class EXPCL_PANDA_CHAN AnimControlCollection {
 PUBLISHED:
   AnimControlCollection();
   ~AnimControlCollection();

panda/src/chan/animGroup.h

@@ -37,7 +37,7 @@ class FactoryParams;
 //               AnimChannels.  The root of the hierarchy must be an
 //               AnimBundle.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnimGroup : public TypedWritableReferenceCount, public Namable {
+class EXPCL_PANDA_CHAN AnimGroup : public TypedWritableReferenceCount, public Namable {
 protected:
   AnimGroup(const string &name = "");
   AnimGroup(AnimGroup *parent, const AnimGroup &copy);

panda/src/chan/auto_bind.h

@@ -36,7 +36,7 @@ BEGIN_PUBLISH
 //               The list of all resulting AnimControls created is
 //               filled into controls.
 ////////////////////////////////////////////////////////////////////
-EXPCL_PANDA void
+EXPCL_PANDA_CHAN void
 auto_bind(PandaNode *root_node, AnimControlCollection &controls,
           int hierarchy_match_flags = 0);
 END_PUBLISH

panda/src/chan/config_chan.h

@@ -25,11 +25,11 @@
 #include "configVariableInt.h"
 
 // Configure variables for chan package.
-NotifyCategoryDecl(chan, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(chan, EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN);
 
-EXPCL_PANDA extern ConfigVariableBool compress_channels;
-EXPCL_PANDA extern ConfigVariableInt compress_chan_quality;
-EXPCL_PANDA extern ConfigVariableBool read_compressed_channels;
-EXPCL_PANDA extern ConfigVariableBool interpolate_frames;
+EXPCL_PANDA_CHAN extern ConfigVariableBool compress_channels;
+EXPCL_PANDA_CHAN extern ConfigVariableInt compress_chan_quality;
+EXPCL_PANDA_CHAN extern ConfigVariableBool read_compressed_channels;
+EXPCL_PANDA_CHAN extern ConfigVariableBool interpolate_frames;
 
 #endif

panda/src/chan/movingPartBase.h

@@ -35,7 +35,7 @@
 //               MovingPartBase does not have a particular value type.
 //               See the derived template class, MovingPart, for this.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA MovingPartBase : public PartGroup {
+class EXPCL_PANDA_CHAN MovingPartBase : public PartGroup {
 protected:
   INLINE MovingPartBase(const MovingPartBase &copy);
 

panda/src/chan/movingPartMatrix.h

@@ -26,14 +26,14 @@
 #include "animChannelFixed.h"
 #include "cmath.h"
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, MovingPart<ACMatrixSwitchType>);
+EXPORT_TEMPLATE_CLASS(EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN, MovingPart<ACMatrixSwitchType>);
 
 ////////////////////////////////////////////////////////////////////
 //       Class : MovingPartMatrix
 // Description : This is a particular kind of MovingPart that accepts
 //               a matrix each frame.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA MovingPartMatrix : public MovingPart<ACMatrixSwitchType> {
+class EXPCL_PANDA_CHAN MovingPartMatrix : public MovingPart<ACMatrixSwitchType> {
 protected:
   INLINE MovingPartMatrix(const MovingPartMatrix &copy);
 

panda/src/chan/movingPartScalar.h

@@ -25,14 +25,14 @@
 #include "animChannel.h"
 #include "animChannelFixed.h"
 
-EXPORT_TEMPLATE_CLASS(EXPCL_PANDA, EXPTP_PANDA, MovingPart<ACScalarSwitchType>);
+EXPORT_TEMPLATE_CLASS(EXPCL_PANDA_CHAN, EXPTP_PANDA_CHAN, MovingPart<ACScalarSwitchType>);
 
 ////////////////////////////////////////////////////////////////////
 //       Class : MovingPartScalar
 // Description : This is a particular kind of MovingPart that accepts
 //               a scalar each frame.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA MovingPartScalar : public MovingPart<ACScalarSwitchType> {
+class EXPCL_PANDA_CHAN MovingPartScalar : public MovingPart<ACScalarSwitchType> {
 protected:
   INLINE MovingPartScalar(const MovingPartScalar &copy);
 

panda/src/chan/partBundle.h

@@ -44,7 +44,7 @@ class TransformState;
 //               defines the hierarchy of moving parts that make up an
 //               animatable object.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA PartBundle : public PartGroup {
+class EXPCL_PANDA_CHAN PartBundle : public PartGroup {
 public:
 
   // This is passed down through the MovingParts during the

panda/src/chan/partBundleNode.h

@@ -33,7 +33,7 @@
 //               PartBundle.  Like AnimBundleNode, it exists solely to
 //               make it easy to store PartBundles in the scene graph.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA PartBundleNode : public PandaNode {
+class EXPCL_PANDA_CHAN PartBundleNode : public PandaNode {
 public:
   INLINE PartBundleNode(const string &name, PartBundle *bundle);
 

panda/src/chan/partGroup.h

@@ -46,7 +46,7 @@ class AnimChannelBase;
 // Description : This is the base class for PartRoot and
 //               MovingPart.  It defines a hierarchy of MovingParts.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA PartGroup : public TypedWritableReferenceCount, public Namable {
+class EXPCL_PANDA_CHAN PartGroup : public TypedWritableReferenceCount, public Namable {
 public:
   // This enum defines bits which may be passed into check_hierarchy()
   // and PartBundle::bind_anim() to allow an inexact match of channel

panda/src/chan/partSubset.h

@@ -29,7 +29,7 @@
 //               Only those part names within the subset will be
 //               included in the bind.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA PartSubset {
+class EXPCL_PANDA_CHAN PartSubset {
 PUBLISHED:
   PartSubset();
   PartSubset(const PartSubset &copy);

panda/src/chan/vector_PartGroupStar.cxx

@@ -18,8 +18,8 @@
 
 #include "vector_PartGroupStar.h"
 
-#define EXPCL EXPCL_PANDA
-#define EXPTP EXPTP_PANDA
+#define EXPCL EXPCL_PANDA_CHAN
+#define EXPTP EXPTP_PANDA_CHAN
 #define TYPE PartGroup *
 #define NAME vector_PartGroupStar
 

panda/src/chan/vector_PartGroupStar.h

@@ -33,8 +33,8 @@
 //               vector again.
 ////////////////////////////////////////////////////////////////////
 
-#define EXPCL EXPCL_PANDA
-#define EXPTP EXPTP_PANDA
+#define EXPCL EXPCL_PANDA_CHAN
+#define EXPTP EXPTP_PANDA_CHAN
 #define TYPE PartGroup *
 #define NAME vector_PartGroupStar
 

panda/src/char/character.h

@@ -42,7 +42,7 @@ class ComputedVertices;
 // Description : An animated character, with skeleton-morph animation
 //               and either soft-skinned or hard-skinned vertices.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA Character : public PartBundleNode {
+class EXPCL_PANDA_CHAR Character : public PartBundleNode {
 protected:
   Character(const Character &copy, bool copy_bundles);
 

panda/src/char/characterJoint.h

@@ -33,7 +33,7 @@ class Character;
 // Description : This represents one joint of the character's
 //               animation, containing an animating transform matrix.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CharacterJoint : public MovingPartMatrix {
+class EXPCL_PANDA_CHAR CharacterJoint : public MovingPartMatrix {
 protected:
   CharacterJoint();
   CharacterJoint(const CharacterJoint &copy);

panda/src/char/characterJointBundle.h

@@ -32,7 +32,7 @@ class Character;
 // Description : The collection of all the joints and sliders in the
 //               character.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CharacterJointBundle : public PartBundle {
+class EXPCL_PANDA_CHAR CharacterJointBundle : public PartBundle {
 protected:
   INLINE CharacterJointBundle(const CharacterJointBundle &copy);
 

panda/src/char/characterJointEffect.h

@@ -38,7 +38,7 @@
 //               node will automatically force the indicated character
 //               to be updated first.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CharacterJointEffect : public RenderEffect {
+class EXPCL_PANDA_CHAR CharacterJointEffect : public RenderEffect {
 private:
   INLINE CharacterJointEffect();
 

panda/src/char/characterSlider.h

@@ -32,7 +32,7 @@ class CharacterVertexSlider;
 //               generally between 0 and 1, that controls the effects
 //               of one or more morphs within the character.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CharacterSlider : public MovingPartScalar {
+class EXPCL_PANDA_CHAR CharacterSlider : public MovingPartScalar {
 protected:
   CharacterSlider();
   CharacterSlider(const CharacterSlider &copy);

panda/src/char/characterVertexSlider.h

@@ -30,7 +30,7 @@
 //               returns the slider value associated with a particular
 //               CharacterSlider object.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CharacterVertexSlider : public VertexSlider {
+class EXPCL_PANDA_CHAR CharacterVertexSlider : public VertexSlider {
 private:
   CharacterVertexSlider();
 

panda/src/char/config_char.h

@@ -25,12 +25,12 @@
 
 // CPPParser can't handle token-pasting to a keyword.
 #ifndef CPPPARSER
-NotifyCategoryDecl(char, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(char, EXPCL_PANDA_CHAR, EXPTP_PANDA_CHAR);
 #endif
 
 // Configure variables for char package.
-extern EXPCL_PANDA ConfigVariableBool even_animation;
+extern EXPCL_PANDA_CHAR ConfigVariableBool even_animation;
 
-extern EXPCL_PANDA void init_libchar();
+extern EXPCL_PANDA_CHAR void init_libchar();
 
 #endif

panda/src/char/jointVertexTransform.h

@@ -38,7 +38,7 @@
 //               are used to implement soft-skinned vertices for an
 //               animated character.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA JointVertexTransform : public VertexTransform {
+class EXPCL_PANDA_CHAR JointVertexTransform : public VertexTransform {
 private:
   JointVertexTransform();
 

panda/src/collide/collisionDSSolid.h

@@ -30,7 +30,7 @@
 //               of two spheres (potentially a lens) and two half-spaces
 //               (planes).
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionDSSolid: public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionDSSolid: public CollisionSolid {
 PUBLISHED:
   INLINE CollisionDSSolid(
     const LPoint3f &center_a, float radius_a,

panda/src/collide/collisionEntry.h

@@ -47,7 +47,7 @@
 //               is up to the handler to determine what information is
 //               known and to do the right thing with it.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionEntry : public TypedWritableReferenceCount {
+class EXPCL_PANDA_COLLIDE CollisionEntry : public TypedWritableReferenceCount {
 public:
   INLINE CollisionEntry();
   CollisionEntry(const CollisionEntry &copy);

panda/src/collide/collisionFloorMesh.cxx

@@ -147,8 +147,7 @@ PT(CollisionEntry) CollisionFloorMesh::
 test_intersection_from_ray(const CollisionEntry &entry) const {
   const CollisionRay *ray;
   DCAST_INTO_R(ray, entry.get_from(), 0);
-  const LMatrix4f &wrt_mat = entry.get_wrt_mat();
-  LPoint3f from_origin = ray->get_origin() * wrt_mat;
+  LPoint3f from_origin = ray->get_origin() * entry.get_wrt_mat();
   
   double fx=from_origin[0];
   double fy=from_origin[1];

panda/src/collide/collisionFloorMesh.h

@@ -34,7 +34,7 @@ class GeomNode;
 // Description : This object represents a solid made entirely of triangles, which
 //               will only be tested again z axis aligned rays
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionFloorMesh : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionFloorMesh : public CollisionSolid {
 public:
   typedef struct {
     unsigned int p1;

panda/src/collide/collisionGeom.h

@@ -34,7 +34,7 @@
 //               directly; it is created only by the
 //               CollisionTraverser, as needed.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionGeom : public CollisionPolygon {
+class EXPCL_PANDA_COLLIDE CollisionGeom : public CollisionPolygon {
 private:
   INLINE CollisionGeom(const LVecBase3f &a, const LVecBase3f &b,
                        const LVecBase3f &c);

panda/src/collide/collisionHandler.h

@@ -33,7 +33,7 @@ class CollisionEntry;
 //               that is processing collisions in order to specify how
 //               to dispatch detected collisions.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandler : public TypedReferenceCount {
+class EXPCL_PANDA_COLLIDE CollisionHandler : public TypedReferenceCount {
 public:
   virtual void begin_group();
   virtual void add_entry(CollisionEntry *entry);

panda/src/collide/collisionHandlerEvent.h

@@ -37,7 +37,7 @@
 //               event will be a pointer to the CollisionEntry that
 //               triggered it.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerEvent : public CollisionHandler {
+class EXPCL_PANDA_COLLIDE CollisionHandlerEvent : public CollisionHandler {
 PUBLISHED:
   CollisionHandlerEvent();
 

panda/src/collide/collisionHandlerFloor.h

@@ -32,7 +32,7 @@
 //               of varying height by casting a ray down from the
 //               avatar's head.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerFloor : public CollisionHandlerPhysical {
+class EXPCL_PANDA_COLLIDE CollisionHandlerFloor : public CollisionHandlerPhysical {
 PUBLISHED:
   CollisionHandlerFloor();
   virtual ~CollisionHandlerFloor();

panda/src/collide/collisionHandlerGravity.h

@@ -32,7 +32,7 @@
 //               of varying height by casting a ray down from the
 //               avatar's head.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerGravity : public CollisionHandlerPhysical {
+class EXPCL_PANDA_COLLIDE CollisionHandlerGravity : public CollisionHandlerPhysical {
 PUBLISHED:
   CollisionHandlerGravity();
   virtual ~CollisionHandlerGravity();

panda/src/collide/collisionHandlerPhysical.h

@@ -35,7 +35,7 @@
 //               their moving bodies: they need to update the nodes'
 //               positions based on the effects of the collision.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerPhysical : public CollisionHandlerEvent {
+class EXPCL_PANDA_COLLIDE CollisionHandlerPhysical : public CollisionHandlerEvent {
 public:
   CollisionHandlerPhysical();
   virtual ~CollisionHandlerPhysical();

panda/src/collide/collisionHandlerPusher.h

@@ -30,7 +30,7 @@
 //               walls.  This is the simplest kind of "real-world"
 //               collisions you can have.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerPusher : public CollisionHandlerPhysical {
+class EXPCL_PANDA_COLLIDE CollisionHandlerPusher : public CollisionHandlerPhysical {
 PUBLISHED:
   CollisionHandlerPusher();
   virtual ~CollisionHandlerPusher();

panda/src/collide/collisionHandlerQueue.h

@@ -33,7 +33,7 @@
 //               useful when a simple intersection test is being made,
 //               e.g. for picking from the window.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionHandlerQueue : public CollisionHandler {
+class EXPCL_PANDA_COLLIDE CollisionHandlerQueue : public CollisionHandler {
 PUBLISHED:
   CollisionHandlerQueue();
 

panda/src/collide/collisionInvSphere.h

@@ -32,7 +32,7 @@
 //               constraining objects to remain within a spherical
 //               perimeter.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionInvSphere : public CollisionSphere {
+class EXPCL_PANDA_COLLIDE CollisionInvSphere : public CollisionSphere {
 PUBLISHED:
   INLINE CollisionInvSphere(const LPoint3f &center, float radius);
   INLINE CollisionInvSphere(float cx, float cy, float cz, float radius);

panda/src/collide/collisionLine.h

@@ -29,7 +29,7 @@
 //               that it extends in both directions.  It is, however,
 //               directional.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionLine : public CollisionRay {
+class EXPCL_PANDA_COLLIDE CollisionLine : public CollisionRay {
 PUBLISHED:
   INLINE CollisionLine();
   INLINE CollisionLine(const LPoint3f &origin, const LVector3f &direction);

panda/src/collide/collisionNode.h

@@ -34,7 +34,7 @@
 //               with, or an animated object twirling around in the
 //               world and running into things.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionNode : public PandaNode {
+class EXPCL_PANDA_COLLIDE CollisionNode : public PandaNode {
 PUBLISHED:
   CollisionNode(const string &name);
 

panda/src/collide/collisionPlane.h

@@ -30,7 +30,7 @@
 //       Class : CollisionPlane
 // Description :
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionPlane : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionPlane : public CollisionSolid {
 protected:
   INLINE CollisionPlane();
 

panda/src/collide/collisionPolygon.h

@@ -33,7 +33,7 @@ class GeomNode;
 //       Class : CollisionPolygon
 // Description :
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionPolygon : public CollisionPlane {
+class EXPCL_PANDA_COLLIDE CollisionPolygon : public CollisionPlane {
 PUBLISHED:
   INLINE CollisionPolygon(const LVecBase3f &a, const LVecBase3f &b,
                           const LVecBase3f &c);

panda/src/collide/collisionRay.h

@@ -33,7 +33,7 @@ class LensNode;
 //               Useful for picking from a window, or for gravity
 //               effects.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionRay : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionRay : public CollisionSolid {
 PUBLISHED:
   INLINE CollisionRay();
   INLINE CollisionRay(const LPoint3f &origin, const LVector3f &direction);

panda/src/collide/collisionRecorder.h

@@ -35,7 +35,7 @@ class CollisionEntry;
 //               class that just provides an interface for recording
 //               collisions tested and detected each frame.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionRecorder : public TypedObject {
+class EXPCL_PANDA_COLLIDE CollisionRecorder : public TypedObject {
 protected:
   CollisionRecorder();
 public:

panda/src/collide/collisionSegment.h

@@ -36,7 +36,7 @@ class LensNode;
 //               intersecting a solid, the reported intersection point
 //               is generally the closest on the segment to point A.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionSegment : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionSegment : public CollisionSolid {
 PUBLISHED:
   INLINE CollisionSegment();
   INLINE CollisionSegment(const LPoint3f &a, const LPoint3f &db);

panda/src/collide/collisionSolid.h

@@ -51,7 +51,7 @@ class CullTraverserData;
 //               function calls handle the subset of the N*N
 //               intersection tests that we care about.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionSolid : public CopyOnWriteObject {
+class EXPCL_PANDA_COLLIDE CollisionSolid : public CopyOnWriteObject {
 public:
   CollisionSolid();
   CollisionSolid(const CollisionSolid &copy);

panda/src/collide/collisionSphere.h

@@ -27,7 +27,7 @@
 //       Class : CollisionSphere
 // Description : A spherical collision volume or object.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionSphere : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionSphere : public CollisionSolid {
 PUBLISHED:
   INLINE CollisionSphere(const LPoint3f &center, float radius);
   INLINE CollisionSphere(float cx, float cy, float cz, float radius);

panda/src/collide/collisionTraverser.h

@@ -50,7 +50,7 @@ class CollisionEntry;
 //               indicated root, calling the appropriate
 //               CollisionHandler for each detected collision.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionTraverser : public Namable {
+class EXPCL_PANDA_COLLIDE CollisionTraverser : public Namable {
 PUBLISHED:
   CollisionTraverser(const string &name = "ctrav");
   ~CollisionTraverser();

panda/src/collide/collisionTube.h

@@ -31,7 +31,7 @@
 //               instead of flat ends.  It looks more like a Contac
 //               pill.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionTube : public CollisionSolid {
+class EXPCL_PANDA_COLLIDE CollisionTube : public CollisionSolid {
 PUBLISHED:
   INLINE CollisionTube(const LPoint3f &a, const LPoint3f &db,
                        float radius);

panda/src/collide/collisionVisualizer.h

@@ -38,7 +38,7 @@
 //               It may be parented anywhere in the scene graph where
 //               it will be rendered to achieve this.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CollisionVisualizer : public PandaNode, public CollisionRecorder {
+class EXPCL_PANDA_COLLIDE CollisionVisualizer : public PandaNode, public CollisionRecorder {
 PUBLISHED:
   CollisionVisualizer(const string &name);
   virtual ~CollisionVisualizer();

panda/src/collide/config_collide.h

@@ -23,13 +23,13 @@
 #include "notifyCategoryProxy.h"
 #include "configVariableBool.h"
 
-NotifyCategoryDecl(collide, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(collide, EXPCL_PANDA_COLLIDE, EXPTP_PANDA_COLLIDE);
 
-extern EXPCL_PANDA ConfigVariableBool respect_prev_transform;
-extern EXPCL_PANDA ConfigVariableBool respect_effective_normal;
-extern EXPCL_PANDA ConfigVariableBool allow_collider_multiple;
-extern EXPCL_PANDA ConfigVariableBool flatten_collision_nodes;
+extern EXPCL_PANDA_COLLIDE ConfigVariableBool respect_prev_transform;
+extern EXPCL_PANDA_COLLIDE ConfigVariableBool respect_effective_normal;
+extern EXPCL_PANDA_COLLIDE ConfigVariableBool allow_collider_multiple;
+extern EXPCL_PANDA_COLLIDE ConfigVariableBool flatten_collision_nodes;
 
-extern EXPCL_PANDA void init_libcollide();
+extern EXPCL_PANDA_COLLIDE void init_libcollide();
 
 #endif

panda/src/cull/binCullHandler.h

@@ -31,7 +31,7 @@
 //               drawing).  This is the kind of CullHandler to use for
 //               most normal rendering needs.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA BinCullHandler : public CullHandler {
+class EXPCL_PANDA_CULL BinCullHandler : public CullHandler {
 public:
   INLINE BinCullHandler(CullResult *cull_result);
 

panda/src/cull/config_cull.h

@@ -28,9 +28,9 @@
 
 class DSearchPath;
 
-ConfigureDecl(config_cull, EXPCL_PANDA, EXPTP_PANDA);
-NotifyCategoryDecl(cull, EXPCL_PANDA, EXPTP_PANDA);
+ConfigureDecl(config_cull, EXPCL_PANDA_CULL, EXPTP_PANDA_CULL);
+NotifyCategoryDecl(cull, EXPCL_PANDA_CULL, EXPTP_PANDA_CULL);
 
-extern EXPCL_PANDA void init_libcull();
+extern EXPCL_PANDA_CULL void init_libcull();
 
 #endif

panda/src/cull/cullBinBackToFront.h

@@ -35,7 +35,7 @@
 //               rendering transparent and semi-transparent geometry
 //               that must be sorted from back to front.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CullBinBackToFront : public CullBin {
+class EXPCL_PANDA_CULL CullBinBackToFront : public CullBin {
 public:
   INLINE CullBinBackToFront(const string &name, 
                             GraphicsStateGuardianBase *gsg,

panda/src/cull/cullBinFixed.h

@@ -38,7 +38,7 @@
 //               draw_order, they are drawn in scene-graph order (as
 //               with CullBinUnsorted).
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CullBinFixed : public CullBin {
+class EXPCL_PANDA_CULL CullBinFixed : public CullBin {
 public:
   INLINE CullBinFixed(const string &name, 
                       GraphicsStateGuardianBase *gsg,

panda/src/cull/cullBinFrontToBack.h

@@ -36,7 +36,7 @@
 //               This is useful for rendering opaque geometry, taking
 //               optimal advantage of a hierarchical Z-buffer.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CullBinFrontToBack : public CullBin {
+class EXPCL_PANDA_CULL CullBinFrontToBack : public CullBin {
 public:
   INLINE CullBinFrontToBack(const string &name, 
                             GraphicsStateGuardianBase *gsg,

panda/src/cull/cullBinStateSorted.h

@@ -40,7 +40,7 @@
 //               Z-buffer algorithms which can early-out when an
 //               object appears behind another one.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CullBinStateSorted : public CullBin {
+class EXPCL_PANDA_CULL CullBinStateSorted : public CullBin {
 public:
   INLINE CullBinStateSorted(const string &name, 
                             GraphicsStateGuardianBase *gsg,

panda/src/cull/cullBinUnsorted.h

@@ -31,7 +31,7 @@
 //               the same order it was encountered, which will be in
 //               scene-graph order.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA CullBinUnsorted : public CullBin {
+class EXPCL_PANDA_CULL CullBinUnsorted : public CullBin {
 public:
   INLINE CullBinUnsorted(const string &name, 
                          GraphicsStateGuardianBase *gsg,

panda/src/cull/drawCullHandler.h

@@ -35,7 +35,7 @@ class GraphicsStateGuardianBase;
 //               than separating out draw and cull, if state sorting
 //               and multiprocessing are not required.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DrawCullHandler : public CullHandler {
+class EXPCL_PANDA_CULL DrawCullHandler : public CullHandler {
 public:
   INLINE DrawCullHandler(GraphicsStateGuardianBase *gsg);
 

panda/src/device/analogNode.h

@@ -46,7 +46,7 @@
 //               position data.  In this way, an AnalogNode may be
 //               used in place of a mouse.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA AnalogNode : public DataNode {
+class EXPCL_PANDA_DEVICE AnalogNode : public DataNode {
 PUBLISHED:
   AnalogNode(ClientBase *client, const string &device_name);
   virtual ~AnalogNode();

panda/src/device/buttonNode.h

@@ -42,7 +42,7 @@
 //               down events on the data graph for each button state
 //               change.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ButtonNode : public DataNode {
+class EXPCL_PANDA_DEVICE ButtonNode : public DataNode {
 PUBLISHED:
   ButtonNode(ClientBase *client, const string &device_name);
   virtual ~ButtonNode();

panda/src/device/clientAnalogDevice.h

@@ -35,7 +35,7 @@
 //               to 1, reflecting the current position of the control
 //               within its total range of motion.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientAnalogDevice : public ClientDevice {
+class EXPCL_PANDA_DEVICE ClientAnalogDevice : public ClientDevice {
 protected:
   INLINE ClientAnalogDevice(ClientBase *client, const string &device_name);
 

panda/src/device/clientBase.h

@@ -48,7 +48,7 @@
 //               TrackerNode etc. to put these devices in the data
 //               graph.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientBase : public TypedReferenceCount {
+class EXPCL_PANDA_DEVICE ClientBase : public TypedReferenceCount {
 protected:
   ClientBase();
 

panda/src/device/clientButtonDevice.h

@@ -38,7 +38,7 @@
 //               class to a sequence of ButtonHandles specified by the
 //               user.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientButtonDevice : public ClientDevice {
+class EXPCL_PANDA_DEVICE ClientButtonDevice : public ClientDevice {
 protected:
   ClientButtonDevice(ClientBase *client, const string &device_name);
 

panda/src/device/clientDevice.h

@@ -36,7 +36,7 @@ class ClientBase;
 //               This is an abstract interface; the actual
 //               implementations are in ClientTrackerDevice, etc.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientDevice : public TypedReferenceCount {
+class EXPCL_PANDA_DEVICE ClientDevice : public TypedReferenceCount {
 protected:
   ClientDevice(ClientBase *client, TypeHandle device_type,
                const string &device_name);

panda/src/device/clientDialDevice.h

@@ -36,7 +36,7 @@
 //               Therefore it does not have a specific position at any
 //               given time, unlike an AnalogDevice.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientDialDevice : public ClientDevice {
+class EXPCL_PANDA_DEVICE ClientDialDevice : public ClientDevice {
 protected:
   INLINE ClientDialDevice(ClientBase *client, const string &device_name);
 

panda/src/device/clientTrackerDevice.h

@@ -30,7 +30,7 @@
 //               TrackerNode, that records the data from a single
 //               tracker device.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA ClientTrackerDevice : public ClientDevice {
+class EXPCL_PANDA_DEVICE ClientTrackerDevice : public ClientDevice {
 protected:
   INLINE ClientTrackerDevice(ClientBase *client, const string &device_name);
 

panda/src/device/config_device.h

@@ -23,10 +23,10 @@
 #include "notifyCategoryProxy.h"
 #include "configVariableBool.h"
 
-NotifyCategoryDecl(device, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(device, EXPCL_PANDA_DEVICE, EXPTP_PANDA_DEVICE);
 
 extern ConfigVariableBool asynchronous_clients;
 
-extern EXPCL_PANDA void init_libdevice();
+extern EXPCL_PANDA_DEVICE void init_libdevice();
 
 #endif

panda/src/device/dialNode.h

@@ -40,7 +40,7 @@
 //               Therefore it does not have a specific position at any
 //               given time, unlike an AnalogDevice.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DialNode : public DataNode {
+class EXPCL_PANDA_DEVICE DialNode : public DataNode {
 PUBLISHED:
   DialNode(ClientBase *client, const string &device_name);
   virtual ~DialNode();

panda/src/device/mouseAndKeyboard.h

@@ -47,7 +47,7 @@
 //               EventThrower to the MouseAndKeyboard object;
 //               otherwise, the events will be discarded.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA MouseAndKeyboard : public DataNode {
+class EXPCL_PANDA_DEVICE MouseAndKeyboard : public DataNode {
 PUBLISHED:
   MouseAndKeyboard(GraphicsWindow *window, int device, const string &name);
   void set_source(GraphicsWindow *window, int device);

panda/src/device/trackerData.h

@@ -26,7 +26,7 @@
 //       Class : TrackerData
 // Description : Stores the kinds of data that a tracker might output.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA TrackerData {
+class EXPCL_PANDA_DEVICE TrackerData {
 public:
   INLINE TrackerData();
   INLINE TrackerData(const TrackerData &copy);

panda/src/device/trackerNode.h

@@ -37,7 +37,7 @@
 //               makes it available as a transformation on the data
 //               graph.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA TrackerNode : public DataNode {
+class EXPCL_PANDA_DEVICE TrackerNode : public DataNode {
 PUBLISHED:
   TrackerNode(ClientBase *client, const string &device_name);
   virtual ~TrackerNode();

panda/src/device/virtualMouse.h

@@ -37,7 +37,7 @@
 //               the mouse wherever he/she wants, and to insert
 //               keypresses on demand.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA VirtualMouse : public DataNode {
+class EXPCL_PANDA_DEVICE VirtualMouse : public DataNode {
 PUBLISHED:
   VirtualMouse(const string &name);
 

panda/src/dgraph/config_dgraph.h

@@ -23,6 +23,6 @@
 
 #include "notifyCategoryProxy.h"
 
-NotifyCategoryDecl(dgraph, EXPCL_PANDA, EXPTP_PANDA);
+NotifyCategoryDecl(dgraph, EXPCL_PANDA_DGRAPH, EXPTP_PANDA_DGRAPH);
 
 #endif

panda/src/dgraph/dataGraphTraverser.h

@@ -36,7 +36,7 @@ class PandaNode;
 //               input devices, etc.  See the overview of the data
 //               graph in dataNode.h.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DataGraphTraverser {
+class EXPCL_PANDA_DGRAPH DataGraphTraverser {
 PUBLISHED:
   DataGraphTraverser(Thread *current_thread = Thread::get_current_thread());
   ~DataGraphTraverser();

panda/src/dgraph/dataNode.h

@@ -65,7 +65,7 @@ class DataNodeTransmit;
 //               PipelineCycler.  The data graph is intended to be
 //               used only within a single thread.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DataNode : public PandaNode {
+class EXPCL_PANDA_DGRAPH DataNode : public PandaNode {
 PUBLISHED:
   INLINE DataNode(const string &name);
 

panda/src/dgraph/dataNodeTransmit.h

@@ -36,7 +36,7 @@ class BamWriter;
 //               array of EventParameters, one for each registered
 //               input or output wire.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DataNodeTransmit : public TypedWritable {
+class EXPCL_PANDA_DGRAPH DataNodeTransmit : public TypedWritable {
 public:
   INLINE DataNodeTransmit();
   INLINE DataNodeTransmit(const DataNodeTransmit &copy);

panda/src/display/config_display.h

@@ -33,63 +33,63 @@
 
 #include "pvector.h"
 
-ConfigureDecl(config_display, EXPCL_PANDA, EXPTP_PANDA);
-NotifyCategoryDecl(display, EXPCL_PANDA, EXPTP_PANDA);
-NotifyCategoryDecl(gsg, EXPCL_PANDA, EXPTP_PANDA);
+ConfigureDecl(config_display, EXPCL_PANDA_DISPLAY, EXPTP_PANDA_DISPLAY);
+NotifyCategoryDecl(display, EXPCL_PANDA_DISPLAY, EXPTP_PANDA_DISPLAY);
+NotifyCategoryDecl(gsg, EXPCL_PANDA_DISPLAY, EXPTP_PANDA_DISPLAY);
 
-extern EXPCL_PANDA ConfigVariableBool view_frustum_cull;
-extern EXPCL_PANDA ConfigVariableBool pstats_unused_states;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool view_frustum_cull;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool pstats_unused_states;
 
-extern EXPCL_PANDA ConfigVariableString threading_model;
-extern EXPCL_PANDA ConfigVariableBool allow_nonpipeline_threads;
-extern EXPCL_PANDA ConfigVariableBool auto_flip;
-extern EXPCL_PANDA ConfigVariableBool sync_flip;
-extern EXPCL_PANDA ConfigVariableBool yield_timeslice;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString threading_model;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool allow_nonpipeline_threads;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool auto_flip;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool sync_flip;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool yield_timeslice;
 
-extern EXPCL_PANDA ConfigVariableString screenshot_filename;
-extern EXPCL_PANDA ConfigVariableString screenshot_extension;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString screenshot_filename;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString screenshot_extension;
 
-extern EXPCL_PANDA ConfigVariableBool prefer_texture_buffer;
-extern EXPCL_PANDA ConfigVariableBool prefer_parasite_buffer;
-extern EXPCL_PANDA ConfigVariableBool prefer_single_buffer;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool prefer_texture_buffer;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool prefer_parasite_buffer;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool prefer_single_buffer;
 
-extern EXPCL_PANDA ConfigVariableBool support_render_texture;
-extern EXPCL_PANDA ConfigVariableBool support_rescale_normal;
-extern EXPCL_PANDA ConfigVariableBool copy_texture_inverted;
-extern EXPCL_PANDA ConfigVariableBool window_inverted;
-extern EXPCL_PANDA ConfigVariableBool red_blue_stereo;
-extern EXPCL_PANDA ConfigVariableString red_blue_stereo_colors;
-extern EXPCL_PANDA ConfigVariableBool auto_generate_mipmaps;
-extern EXPCL_PANDA ConfigVariableBool color_scale_via_lighting;
-extern EXPCL_PANDA ConfigVariableBool alpha_scale_via_texture;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool support_render_texture;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool support_rescale_normal;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool copy_texture_inverted;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool window_inverted;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool red_blue_stereo;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString red_blue_stereo_colors;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool auto_generate_mipmaps;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool color_scale_via_lighting;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool alpha_scale_via_texture;
 
-extern EXPCL_PANDA ConfigVariableInt win_size;
-extern EXPCL_PANDA ConfigVariableInt win_origin;
-extern EXPCL_PANDA ConfigVariableBool fullscreen;
-extern EXPCL_PANDA ConfigVariableBool undecorated;
-extern EXPCL_PANDA ConfigVariableBool cursor_hidden;
-extern EXPCL_PANDA ConfigVariableFilename icon_filename;
-extern EXPCL_PANDA ConfigVariableFilename cursor_filename;
-extern EXPCL_PANDA ConfigVariableEnum<WindowProperties::ZOrder> z_order;
-extern EXPCL_PANDA ConfigVariableString window_title;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt win_size;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt win_origin;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool fullscreen;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool undecorated;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool cursor_hidden;
+extern EXPCL_PANDA_DISPLAY ConfigVariableFilename icon_filename;
+extern EXPCL_PANDA_DISPLAY ConfigVariableFilename cursor_filename;
+extern EXPCL_PANDA_DISPLAY ConfigVariableEnum<WindowProperties::ZOrder> z_order;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString window_title;
 
-extern EXPCL_PANDA ConfigVariableString framebuffer_mode;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_hardware;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_software;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_multisample;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_depth;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_alpha;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_stencil;
-extern EXPCL_PANDA ConfigVariableBool framebuffer_stereo;
-extern EXPCL_PANDA ConfigVariableInt depth_bits;
-extern EXPCL_PANDA ConfigVariableInt color_bits;
-extern EXPCL_PANDA ConfigVariableInt alpha_bits;
-extern EXPCL_PANDA ConfigVariableInt stencil_bits;
-extern EXPCL_PANDA ConfigVariableInt multisamples;
+extern EXPCL_PANDA_DISPLAY ConfigVariableString framebuffer_mode;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_hardware;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_software;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_multisample;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_depth;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_alpha;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_stencil;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool framebuffer_stereo;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt depth_bits;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt color_bits;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt alpha_bits;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt stencil_bits;
+extern EXPCL_PANDA_DISPLAY ConfigVariableInt multisamples;
 
-extern EXPCL_PANDA ConfigVariableDouble background_color;
-extern EXPCL_PANDA ConfigVariableBool sync_video;
+extern EXPCL_PANDA_DISPLAY ConfigVariableDouble background_color;
+extern EXPCL_PANDA_DISPLAY ConfigVariableBool sync_video;
 
-extern EXPCL_PANDA void init_libdisplay();
+extern EXPCL_PANDA_DISPLAY void init_libdisplay();
 
 #endif /* CONFIG_DISPLAY_H */

panda/src/display/displayInformation.h

@@ -36,7 +36,7 @@ DisplayMode;
 // Description : This class contains various display information.
 ////////////////////////////////////////////////////////////////////
 
-class EXPCL_PANDA DisplayInformation {
+class EXPCL_PANDA_DISPLAY DisplayInformation {
 
 PUBLISHED:
 

panda/src/display/displayRegion.h

@@ -58,7 +58,7 @@ class CullTraverser;
 //               glass, usually for layering 2-d interfaces on top of
 //               a 3-d scene.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DisplayRegion : public ReferenceCount, public DrawableRegion {
+class EXPCL_PANDA_DISPLAY DisplayRegion : public ReferenceCount, public DrawableRegion {
 protected:
   DisplayRegion(GraphicsOutput *window);
   DisplayRegion(GraphicsOutput *window,
@@ -155,7 +155,7 @@ private:
   // needs to be cycled every frame, but represents the parameters as
   // specified by the user, and which probably will not change that
   // often.
-  class EXPCL_PANDA CData : public CycleData {
+  class EXPCL_PANDA_DISPLAY CData : public CycleData {
   public:
     CData();
     CData(const CData &copy);
@@ -198,7 +198,7 @@ private:
   // own cycler because it will certainly change every frame, so we
   // don't need to lump all the heavy data above in with this
   // lightweight cycler.
-  class EXPCL_PANDA CDataCull : public CycleData {
+  class EXPCL_PANDA_DISPLAY CDataCull : public CycleData {
   public:
     CDataCull();
     CDataCull(const CDataCull &copy);
@@ -240,7 +240,7 @@ private:
 // Description : Encapsulates the data from a DisplayRegion,
 //               pre-fetched for one stage of the pipeline.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DisplayRegionPipelineReader {
+class EXPCL_PANDA_DISPLAY DisplayRegionPipelineReader {
 public:
   INLINE DisplayRegionPipelineReader(DisplayRegion *object, Thread *current_thread);
 private:

panda/src/display/displaySearchParameters.h

@@ -26,7 +26,7 @@
 //       Class : DisplaySearchParameters
 // Description : Parameters used for searching display capabilities.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DisplaySearchParameters {
+class EXPCL_PANDA_DISPLAY DisplaySearchParameters {
 
 PUBLISHED:
   DisplaySearchParameters();

panda/src/display/drawableRegion.h

@@ -34,7 +34,7 @@
 //               to deal with the whole window at once, particularly
 //               for issuing clear commands and capturing screenshots.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA DrawableRegion {
+class EXPCL_PANDA_DISPLAY DrawableRegion {
 public:
   INLINE DrawableRegion();
   INLINE DrawableRegion(const DrawableRegion &copy);

panda/src/display/frameBufferProperties.h

@@ -28,7 +28,7 @@
 //               might ask to have on a graphics frameBuffer before we
 //               create a GSG.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA FrameBufferProperties {
+class EXPCL_PANDA_DISPLAY FrameBufferProperties {
 
 private:
   enum FrameBufferProperty {

panda/src/display/graphicsBuffer.h

@@ -31,7 +31,7 @@
 //               similar in function to a GraphicsWindow, except that
 //               the output is not visible to the user.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA GraphicsBuffer : public GraphicsOutput {
+class EXPCL_PANDA_DISPLAY GraphicsBuffer : public GraphicsOutput {
 protected:
   GraphicsBuffer(GraphicsPipe *pipe, 
                  const string &name,

panda/src/display/graphicsDevice.h

@@ -34,7 +34,7 @@ class GraphicsPipe;
 //               than one adapters in the machine).   
 //
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA GraphicsDevice : public TypedReferenceCount {
+class EXPCL_PANDA_DISPLAY GraphicsDevice : public TypedReferenceCount {
 public:
   GraphicsDevice(GraphicsPipe *pipe);
 

panda/src/display/graphicsEngine.h

@@ -56,7 +56,7 @@ class Texture;
 //               simply calls engine->render_frame() and considers it
 //               done.
 ////////////////////////////////////////////////////////////////////
-class EXPCL_PANDA GraphicsEngine {
+class EXPCL_PANDA_DISPLAY GraphicsEngine {
 PUBLISHED:
   GraphicsEngine(Pipeline *pipeline = NULL);
   ~GraphicsEngine();