From c67950561ef508a8e3f0ce1a7206c2b96130b1c3 Mon Sep 17 00:00:00 2001
From: Robert Osfield <robert@openscenegraph.com>
Date: Sat, 9 Mar 2002 10:52:01 +0000
Subject: [PATCH] TXP plugin changes submitted by Boris Bralo.

---
 src/osgPlugins/txp/trpage_compat.cpp | 283 ++++++++
 src/osgPlugins/txp/trpage_compat.h   |  96 +++
 src/osgPlugins/txp/trpage_light.cpp  | 973 +++++++++++++++++++++++++++
 src/osgPlugins/txp/trpage_pparse.cpp | 210 ++++++
 src/osgPlugins/txp/trpage_print.cpp  | 838 +++++++++++++++++++++++
 src/osgPlugins/txp/trpage_print.h    | 106 +++
 src/osgPlugins/txp/trpage_range.cpp  | 303 +++++++++
 7 files changed, 2809 insertions(+)
 create mode 100644 src/osgPlugins/txp/trpage_compat.cpp
 create mode 100644 src/osgPlugins/txp/trpage_compat.h
 create mode 100644 src/osgPlugins/txp/trpage_light.cpp
 create mode 100644 src/osgPlugins/txp/trpage_pparse.cpp
 create mode 100644 src/osgPlugins/txp/trpage_print.cpp
 create mode 100644 src/osgPlugins/txp/trpage_print.h
 create mode 100644 src/osgPlugins/txp/trpage_range.cpp

diff --git a/src/osgPlugins/txp/trpage_compat.cpp b/src/osgPlugins/txp/trpage_compat.cpp
new file mode 100644
index 000000000..ea37b993b
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_compat.cpp
@@ -0,0 +1,283 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* trpage_compat.cpp
+    This file and the accompanying trpage_compat.h contain objects and procedures
+    used to maintain compatibility between versions of TerraPage.  In particular, the
+    ability to read older versions of TerraPage and newer applications.
+   
+ */
+
+#include "trpage_geom.h"
+#include "trpage_read.h"
+#include "trpage_compat.h"
+
+/* Old short Material definition from 1.0.
+    {secret}
+ */
+class trpgShortMaterial {
+public:
+    // Full trpgMaterial definition this one is based on
+    int baseMat;
+    // Currently the only thing a short material overrides is texture
+    std::vector<int> texids;
+};
+
+trpgMatTable1_0::trpgMatTable1_0(const trpgMatTable &inTbl)
+{
+    *((trpgMatTable *)this) = inTbl;
+}
+
+bool trpgMatTable1_0::Read(trpgReadBuffer &buf)
+{
+    trpgMaterial mat;
+    trpgToken matTok;
+    int32 len;
+    bool status;
+    int i,j,k;
+
+    std::vector<trpgShortMaterial> shortTable;
+    std::vector<trpgMaterial> baseMats;
+
+    try {
+        buf.Get(numTable);
+        buf.Get(numMat);
+        if (numTable <= 0 || numMat < 0) throw 1;
+
+        // Short material tables are always full size
+        shortTable.resize(numTable*numMat);
+
+        // Look for short material table
+        buf.GetToken(matTok,len);
+        if (matTok == TRPGSHORTMATTABLE) {
+            int32 numTex,texId;
+            buf.PushLimit(len);
+            for (i=0;i<numTable;i++)
+                for (j=0;j<numMat;j++) {
+                    trpgShortMaterial &smat = shortTable[i*numMat+j];
+                    buf.Get(smat.baseMat);
+                    buf.Get(numTex);
+                    for (k=0;k<numTex;k++) {
+                        buf.Get(texId);
+                        smat.texids.push_back(texId);
+                    }
+                }
+            buf.PopLimit();
+
+            // Now read the base materials
+            int32 numBaseMat;
+            buf.Get(numBaseMat);
+            if (numBaseMat < 0) throw 1;
+            baseMats.resize(numBaseMat);
+            for (i=0;i<numBaseMat;i++) {
+                buf.GetToken(matTok,len);
+                if (matTok != TRPGMATERIAL) throw 1;
+                buf.PushLimit(len);
+                mat.Reset();
+                status = mat.Read(buf);
+                buf.PopLimit();
+                if (!status) throw 1;
+                baseMats[i] = mat;
+            }
+        }
+    }
+    catch (...) {
+        return false;
+    }
+
+    // Now convert to the new style material table
+    for (i=0;i<shortTable.size();i++) {
+        trpgShortMaterial &shortMat = shortTable[i];
+        trpgMaterial &baseMat = baseMats[shortMat.baseMat];
+        matTables.push_back(baseMat);
+        trpgMaterial &newMat = matTables[matTables.size()-1];
+        newMat.SetNumTexture(shortMat.texids.size());
+        for (j=0;j<shortMat.texids.size();j++) {
+        int texId;
+        trpgTextureEnv texEnv;
+        baseMat.GetTexture(j,texId,texEnv);
+        newMat.SetTexture(j,shortMat.texids[j],texEnv);
+        }
+    }
+
+    valid = true;
+    return true;
+}
+
+bool trpgMatTable1_0::Write(trpgWriteBuffer &buf)
+{
+    if (!isValid())
+    return false;
+
+    // Create one short material for every material
+    std::vector<trpgShortMaterial> shortMats;
+    shortMats.resize(numTable*numMat);
+
+    // Iterate over the existing materials
+    int i;
+    for (i=0;i<numTable*numMat;i++) {
+    trpgMaterial &mat = matTables[i];
+    // Fill in the short material
+    trpgShortMaterial &sMat = shortMats[i];
+    int numTex;
+    mat.GetNumTexture(numTex);
+    for (int j=0;j<numTex;j++) {
+        int texId;
+        trpgTextureEnv texEnv;
+        mat.GetTexture(j,texId,texEnv);
+        sMat.texids.push_back(texId);
+        sMat.baseMat = i;
+    }
+    }
+
+    // Write the 1.0 material table
+    buf.Begin(TRPGMATTABLE2);
+    buf.Add(numTable);
+    buf.Add(numMat);
+
+    // Write the short materials
+    buf.Begin(TRPGSHORTMATTABLE);
+    for (i=0;i<shortMats.size();i++) {
+    trpgShortMaterial &sMat = shortMats[i];
+    buf.Add(sMat.baseMat);
+    buf.Add((int)(sMat.texids.size()));
+    int j;
+    for (j=0;j<sMat.texids.size();j++)
+        buf.Add(sMat.texids[j]);
+    }
+    buf.End();
+
+    // Write the regular materials
+    buf.Add(numTable*numMat);
+    for (i=0;i<numTable*numMat;i++) {
+    trpgMaterial &mat = matTables[i];
+    // This will be bigger than the old 1.0 material, but it doesn't matter since
+    //  the new stuff is on the end.
+    mat.Write(buf);
+    }
+
+    // Close Mat Table
+    buf.End();
+
+    return true;
+}
+
+trpgTexture1_0 trpgTexture1_0::operator = (const trpgTexture &inTex)
+{
+    *((trpgTexture *)this) = inTex;
+
+    return *this;
+}
+
+bool trpgTexture1_0::Read(trpgReadBuffer &buf)
+{
+    mode = External;
+
+    try {
+        char texName[1024];
+        buf.Get(texName,1023);
+        SetName(texName);
+        buf.Get(useCount);
+    }
+    catch (...) {
+        return false;
+    }
+
+    return true;
+}
+
+bool trpgTexture1_0::Write(trpgWriteBuffer &buf)
+{
+    // Can only deal with external textures in 1.0
+    if (mode != External)
+    return false;
+
+    // Write the name and use count
+    buf.Add(name);
+    buf.Add(useCount);
+
+    return true;
+}
+
+trpgTexTable1_0::trpgTexTable1_0(const trpgTexTable &inTbl)
+{
+    *((trpgTexTable *)this) = inTbl;
+}
+
+bool trpgTexTable1_0::Read(trpgReadBuffer &buf)
+{
+    int32 numTex;
+
+    try {
+        buf.Get(numTex);
+        texList.resize(numTex);
+        for (unsigned int i=0;i<numTex;i++) {
+            trpgTexture1_0 tex1_0;
+            tex1_0.Read(buf);
+            texList[i] = tex1_0;
+        }
+    }
+    catch (...) {
+        return false;
+    }
+
+    valid = true;
+    return true;
+}
+
+bool trpgTexTable1_0::Write(trpgWriteBuffer &buf)
+{
+    int32 numTex;
+
+    if (!isValid())
+        return false;
+
+    buf.Begin(TRPGTEXTABLE);
+    numTex = texList.size();
+    buf.Add(numTex);
+    for (unsigned int i=0;i<texList.size();i++) {
+        trpgTexture1_0 tex1_0;
+        tex1_0 = texList[i];
+        if (!tex1_0.Write(buf))
+        return false;
+    }
+    buf.End();
+
+    return true;
+
+}
+
+trpgTileTable1_0::trpgTileTable1_0(const trpgTileTable &inTable)
+{
+    // Nothing to copy for now
+}
+
+bool trpgTileTable1_0::Write(trpgWriteBuffer &buf)
+{
+    try {
+    buf.Begin(TRPGTILETABLE);
+    buf.Add("");
+    buf.End();
+    }
+    catch (...) {
+    return false;
+    }
+
+    return true;
+}
diff --git a/src/osgPlugins/txp/trpage_compat.h b/src/osgPlugins/txp/trpage_compat.h
new file mode 100644
index 000000000..b128deace
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_compat.h
@@ -0,0 +1,96 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+#ifndef _trpage_compat_h_
+#define _trpage_compat_h_
+
+/* trpage_compat.h
+    This file and the accompanying trpage_compat.cpp contain objects and procedures
+    used to maintain compatibility between versions of TerraPage.  In particular, the
+    ability to read older versions of TerraPage and newer applications.
+ */
+
+/* Material Table 1.0.
+    This class is used to read old 1.0 material tables and convert them
+    into the 2.0 material table we're inheriting from.  Users should
+    never directly interact with this class.
+    {secret}
+ */
+class trpgMatTable1_0 : public trpgMatTable {
+public:
+    trpgMatTable1_0() { };
+    trpgMatTable1_0(const trpgMatTable &);
+
+    /* This read method overrides the one from trpgMatTable and knows
+    how to read the old school material tables.
+     */
+    bool    Read(trpgReadBuffer &);
+    /* This write method can write a 2.0 material table as 1.0
+    style for backward compatibility.
+     */
+    bool    Write(trpgWriteBuffer &);
+protected:
+};
+
+/* Texture Table 1.0.
+    This class is used to read old 1.0 texture tables and convert them
+    into 2.0 texture tables.  Users should never directly interact with
+    this class.
+    {secret}
+ */
+class trpgTexTable1_0 : public trpgTexTable {
+public:
+    trpgTexTable1_0() { };
+    trpgTexTable1_0(const trpgTexTable &);
+
+    /* This read method overrides the one from trpgTexTable and
+    knows how to read the old style texture table.
+     */
+    bool    Read(trpgReadBuffer &);
+    /* The write method can write a 2.0 texture table as 1.0
+    style for backward compatibility.
+     */
+    bool    Write(trpgWriteBuffer &);
+protected:
+};
+
+/* Texture 1.0.
+    Knows how to read an old style texture.
+    {secret}
+ */
+class trpgTexture1_0 : public trpgTexture {
+public:
+    // Assignment operator from a regular trpgTexture
+    trpgTexture1_0 operator = (const trpgTexture &);
+
+    // Knows how to read old style textures
+    bool    Read(trpgReadBuffer &);
+    // Can write old style textures
+    bool    Write(trpgWriteBuffer &);
+protected:
+};
+
+/* Tile Table 1.0
+    Knows how to write an old style tile table.
+    {secret}
+ */
+class trpgTileTable1_0 : public trpgTileTable {
+public:
+    trpgTileTable1_0(const trpgTileTable &);
+    // Can write old style tile table
+    bool    Write(trpgWriteBuffer &);
+};
+
+#endif
diff --git a/src/osgPlugins/txp/trpage_light.cpp b/src/osgPlugins/txp/trpage_light.cpp
new file mode 100644
index 000000000..4d4de9fa5
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_light.cpp
@@ -0,0 +1,973 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+/* trpage_light.cpp
+    Methods for the trpgLightAttr, trpgLight and trpgLightTable classes.
+    This includes read and write methods.
+    You should only need to change something in here if you want to modify
+     what any of the classes contains.
+    */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "trpage_geom.h"
+#include "trpage_read.h"
+
+#if defined(_WIN32)
+#define ALIGNMENT_WORKAROUND    false
+#else
+#define ALIGNMENT_WORKAROUND    true
+#endif
+
+/******
+    Lights Attribute
+******/
+
+trpgLightAttr::trpgLightAttr(void)
+{
+    Reset();
+}
+
+trpgLightAttr::trpgLightAttr(const trpgLightAttr &in)
+{
+    operator=(in);
+}
+
+trpgLightAttr::~trpgLightAttr(void)
+{
+}
+
+
+// Setters
+void trpgLightAttr::SetType( trpgLightAttr::LightType in_type )
+{
+    data.type = in_type;
+}
+void trpgLightAttr::SetDirectionality( trpgLightAttr::LightDirectionality in_directionality )
+{
+    data.directionality = in_directionality;
+}
+void trpgLightAttr::SetFrontColor( trpgColor in_frontColor )
+{
+    data.frontColor = in_frontColor;
+}
+void trpgLightAttr::SetFrontIntensity( float64 in_frontIntensity )
+{
+    data.frontIntensity = in_frontIntensity;
+}
+void trpgLightAttr::SetBackColor( trpgColor in_backColor )
+{
+    data.backColor = in_backColor;
+}
+void trpgLightAttr::SetBackIntensity( float64 in_backIntensity )
+{
+    data.backIntensity = in_backIntensity;
+}
+void trpgLightAttr::SetNormal( trpg3dPoint in_normal )
+{
+    data.normal = in_normal;
+}
+void trpgLightAttr::SetSMC( int32 in_smc )
+{
+    data.smc = in_smc;
+}
+void trpgLightAttr::SetFID( int32 in_fid )
+{
+    data.fid = in_fid;
+}
+void trpgLightAttr::SetFlags( int32 in_flags )
+{
+    data.flags = in_flags;
+}
+void trpgLightAttr::SetHLobeAngle( float64 in_hLobeAngle )
+{
+    data.horizontalLobeAngle = in_hLobeAngle;
+}
+void trpgLightAttr::SetVLobeAngle( float64 in_vLobeAngle )
+{
+    data.verticalLobeAngle = in_vLobeAngle;
+}
+void trpgLightAttr::SetLobeRollAngle( float64 in_lobeRollAngle )
+{
+    data.lobeRollAngle = in_lobeRollAngle;
+}
+void trpgLightAttr::SetLobeFalloff( float64 in_lobeFalloff )
+{
+    data.lobeFalloff = in_lobeFalloff;
+}
+void trpgLightAttr::SetAmbient( float64 in_ambientIntensity )
+{
+    data.ambientIntensity = in_ambientIntensity;
+}
+void trpgLightAttr::SetQuality( trpgLightAttr::LightQuality in_quality )
+{
+    data.quality = in_quality;
+}
+void trpgLightAttr::SetRascalSignificance( float64 in_rascalSignificance )
+{
+    data.rascalSignificance = in_rascalSignificance;
+}
+void trpgLightAttr::SetRandomIntensity( trpgLightAttr::LightQuality in_randomIntensity )
+{
+    data.randomIntensity = in_randomIntensity;
+}
+void trpgLightAttr::SetCalligraphicAttr( trpgLightAttr::CalligraphicAttr& in_calligraphicAttr )
+{
+    data.calligraphicAttr = in_calligraphicAttr;
+}
+void trpgLightAttr::SetCalligraphicDrawOrder( int32 in_drawOrder )
+{
+    data.calligraphicAttr.drawOrder = in_drawOrder;
+}
+void trpgLightAttr::SetCalligraphicMinDefocus( float64 in_minDefocus )
+{
+    data.calligraphicAttr.minDefocus = in_minDefocus;
+}
+void trpgLightAttr::SetCalligraphicMaxDefocus( float64 in_maxDefocus )
+{
+    data.calligraphicAttr.maxDefocus = in_maxDefocus;
+}
+void trpgLightAttr::SetPerformerAttr( trpgLightAttr::PerformerAttr& in_performerAttr )
+{
+    data.performerAttr = in_performerAttr;
+}
+void trpgLightAttr::SetPerformerFlags( int32 in_flags )
+{
+    data.performerAttr.flags = in_flags & trpgLightAttr::trpg_PerformerMask;
+    data.flags |= data.performerAttr.flags;
+}
+void trpgLightAttr::SetPerformerMinPixelSize( float64 in_minPxSize )
+{
+    data.performerAttr.minPixelSize = in_minPxSize;
+}
+void trpgLightAttr::SetPerformerMaxPixelSize( float64 in_maxPxSize )
+{
+    data.performerAttr.maxPixelSize = in_maxPxSize;
+}
+void trpgLightAttr::SetPerformerActualSize( float64 in_actualSize )
+{
+    data.performerAttr.actualSize = in_actualSize;
+}
+void trpgLightAttr::SetPerformerTpPixelSize( float64 in_tpPixelSize )
+{
+    data.performerAttr.transparentPixelSize = in_tpPixelSize;
+}
+void trpgLightAttr::SetPerformerTpFalloffExp( float64 in_tpFalloffExp )
+{
+    data.performerAttr.transparentFallofExp = in_tpFalloffExp;
+}
+void trpgLightAttr::SetPerformerTpScale( float64 in_tpScale )
+{
+    data.performerAttr.transparentScale = in_tpScale;
+}
+void trpgLightAttr::SetPerformerTpClamp( float64 in_tpClamp )
+{
+    data.performerAttr.transparentClamp = in_tpClamp;
+}
+void trpgLightAttr::SetPerformerFogScale( float64 in_fogScale )
+{
+    data.performerAttr.fogScale = in_fogScale;
+}
+void trpgLightAttr::SetAnimationAttr( trpgLightAttr::AnimationAttr& in_animationAttr )
+{
+    data.animationAttr = in_animationAttr;
+}
+void trpgLightAttr::SetAnimationPeriod( float64 in_period )
+{
+    data.animationAttr.period = in_period;
+}
+void trpgLightAttr::SetAnimationPhaseDelay( float64 in_phaseDelay )
+{
+    data.animationAttr.phaseDelay = in_phaseDelay;
+}
+void trpgLightAttr::SetAnimationTimeOn( float64 in_timeOn )
+{
+    data.animationAttr.timeOn = in_timeOn;
+}
+void trpgLightAttr::SetAnimationVector( trpg3dPoint in_vector )
+{
+    data.animationAttr.vector = in_vector;
+}
+void trpgLightAttr::SetAnimationFlags( int32 flags )
+{
+    data.animationAttr.flags = flags & trpgLightAttr::trpg_AnimationMask;
+    data.flags |= data.animationAttr.flags;
+}
+// Getters
+void trpgLightAttr::GetType( trpgLightAttr::LightType& out_type )
+{
+    out_type = data.type;
+}
+void trpgLightAttr::GetDirectionality( trpgLightAttr::LightDirectionality& out_directionality )
+{
+    out_directionality = data.directionality;
+}
+void trpgLightAttr::GetFrontColor( trpgColor& out_frontColor )
+{
+    out_frontColor = data.frontColor;
+}
+void trpgLightAttr::GetFrontIntensity( float64& out_frontIntensity )
+{
+    out_frontIntensity = data.frontIntensity;
+}
+void trpgLightAttr::GetBackColor( trpgColor& out_backColor )
+{
+    out_backColor = data.backColor;
+}
+void trpgLightAttr::GetBackIntensity( float64& out_backIntensity )
+{
+    out_backIntensity = data.backIntensity;
+}
+void trpgLightAttr::GetNormal( trpg3dPoint& out_normal )
+{
+    out_normal = data.normal;
+}
+void trpgLightAttr::GetSMC( int32& out_smc )
+{
+    out_smc = data.smc;
+}
+void trpgLightAttr::GetFID( int32& out_fid )
+{
+    out_fid = data.fid;
+}
+void trpgLightAttr::GetFlags( int32& out_flags )
+{
+    out_flags = data.flags;
+}
+void trpgLightAttr::GetHLobeAngle( float64& out_hLobeAngle )
+{
+    out_hLobeAngle = data.horizontalLobeAngle;
+}
+void trpgLightAttr::GetVLobeAngle( float64& out_vLobeAngle )
+{
+    out_vLobeAngle = data.verticalLobeAngle;
+}
+void trpgLightAttr::GetLobeRollAngle( float64& out_lobeRollAngle )
+{
+    out_lobeRollAngle = data.lobeRollAngle;
+}
+void trpgLightAttr::GetLobeFalloff( float64& out_lobeFalloff )
+{
+    out_lobeFalloff = data.lobeFalloff;
+}
+void trpgLightAttr::GetAmbient( float64& out_ambientIntensity )
+{
+    out_ambientIntensity = data.ambientIntensity;
+}
+void trpgLightAttr::GetQuality( trpgLightAttr::LightQuality& out_quality )
+{
+    out_quality = data.quality;
+}
+void trpgLightAttr::GetRascalSignificance( float64& out_rascalSignificance )
+{
+    out_rascalSignificance = data.rascalSignificance;
+}
+void trpgLightAttr::GetRandomIntensity( trpgLightAttr::LightQuality& out_randomIntensity )
+{
+    out_randomIntensity = data.randomIntensity;
+}
+void trpgLightAttr::GetCalligraphicAttr( trpgLightAttr::CalligraphicAttr& out_calligraphicAttr )
+{
+    out_calligraphicAttr = data.calligraphicAttr;
+}
+void trpgLightAttr::GetCalligraphicDrawOrder( int32& out_drawOrder )
+{
+    out_drawOrder = data.calligraphicAttr.drawOrder;
+}
+void trpgLightAttr::GetCalligraphicMinDefocus( float64& out_minDefocus )
+{
+    out_minDefocus = data.calligraphicAttr.minDefocus;
+}
+void trpgLightAttr::GetCalligraphicMaxDefocus( float64& out_maxDefocus )
+{
+    out_maxDefocus = data.calligraphicAttr.maxDefocus;
+}
+void trpgLightAttr::GetPerformerAttr( trpgLightAttr::PerformerAttr& out_performerAttr )
+{
+    out_performerAttr = data.performerAttr;
+}
+void trpgLightAttr::GetPerformerFlags( int32& out_flags )
+{
+    out_flags = data.performerAttr.flags;
+}
+void trpgLightAttr::GetPerformerMinPixelSize( float64& out_minPxSize )
+{
+    out_minPxSize = data.performerAttr.minPixelSize;
+}
+void trpgLightAttr::GetPerformerMaxPixelSize( float64& out_maxPxSize )
+{
+    out_maxPxSize = data.performerAttr.maxPixelSize;
+}
+void trpgLightAttr::GetPerformerActualSize( float64& out_actualSize )
+{
+    out_actualSize = data.performerAttr.actualSize;
+}
+void trpgLightAttr::GetPerformerTpPixelSize( float64& out_tpPixelSize )
+{
+    out_tpPixelSize = data.performerAttr.transparentPixelSize;
+}
+void trpgLightAttr::GetPerformerTpFalloffExp( float64& out_tpFalloffExp )
+{
+    out_tpFalloffExp = data.performerAttr.transparentFallofExp;
+}
+void trpgLightAttr::GetPerformerTpScale( float64& out_tpScale )
+{
+    out_tpScale = data.performerAttr.transparentScale;
+}
+void trpgLightAttr::GetPerformerTpClamp( float64& out_tpClamp )
+{
+    out_tpClamp = data.performerAttr.transparentClamp;
+}
+void trpgLightAttr::GetPerformerFogScale( float64& out_fogScale )
+{
+    out_fogScale = data.performerAttr.fogScale;
+}
+void trpgLightAttr::GetAnimationAttr( trpgLightAttr::AnimationAttr& out_animationAttr )
+{
+    out_animationAttr = data.animationAttr;
+}
+void trpgLightAttr::GetAnimationPeriod( float64& out_period )
+{
+    out_period = data.animationAttr.period;
+}
+void trpgLightAttr::GetAnimationPhaseDelay( float64& out_phaseDelay )
+{
+    out_phaseDelay = data.animationAttr.phaseDelay;
+}
+void trpgLightAttr::GetAnimationTimeOn( float64& out_timeOn )
+{
+    out_timeOn = data.animationAttr.timeOn;
+}
+void trpgLightAttr::GetAnimationVector( trpg3dPoint& out_vector )
+{
+    out_vector = data.animationAttr.vector;
+}
+void trpgLightAttr::GetAnimationFlags( int32& flags )
+{
+    flags = data.animationAttr.flags;
+}
+// Writes this class to a write buffer
+bool trpgLightAttr::Write(trpgWriteBuffer &buf)
+{
+    buf.Begin(TRPGLIGHTATTR);
+
+    buf.Begin(TRPGLIGHTATTR_BASIC);
+    buf.Add((int)data.type);
+    buf.Add((int)data.directionality);
+    buf.Add(data.frontColor);
+    buf.Add(data.frontIntensity);
+    buf.Add(data.backColor);
+    buf.Add(data.backIntensity);
+    buf.Add(data.normal);
+    buf.Add(data.smc);
+    buf.Add(data.fid);
+    buf.Add(data.flags);
+    buf.Add(data.horizontalLobeAngle);
+    buf.Add(data.verticalLobeAngle);
+    buf.Add(data.lobeRollAngle);
+    buf.Add(data.lobeFalloff);
+    buf.Add(data.ambientIntensity);
+    buf.Add((int)data.quality);
+    buf.Add((int)data.randomIntensity);
+    buf.End();
+
+    buf.Begin(TRPGLIGHTATTR_RASCAL);
+    buf.Add(data.rascalSignificance);
+    buf.End();
+
+    buf.Begin(TRPGLIGHTATTR_CALLIGRAPHIC);
+    buf.Add(data.calligraphicAttr.drawOrder);
+    buf.Add(data.calligraphicAttr.minDefocus);
+    buf.Add(data.calligraphicAttr.maxDefocus);
+    buf.End();
+
+    buf.Begin(TRPGLIGHTATTR_PERFORMER);
+    buf.Add(data.performerAttr.actualSize);
+    buf.Add(data.performerAttr.fogScale);
+    buf.Add(data.performerAttr.minPixelSize);
+    buf.Add(data.performerAttr.maxPixelSize);
+    buf.Add(data.performerAttr.transparentClamp);
+    buf.Add(data.performerAttr.transparentFallofExp);
+    buf.Add(data.performerAttr.transparentPixelSize);
+    buf.Add(data.performerAttr.transparentScale);
+    buf.End();
+
+    buf.Begin(TRPGLIGHTATTR_ANIMATION);
+    buf.Add(data.animationAttr.period);
+    buf.Add(data.animationAttr.phaseDelay);
+    buf.Add(data.animationAttr.timeOn);
+    buf.Add(data.animationAttr.vector);
+    buf.End();
+
+    buf.End();
+
+    return true;
+}
+
+/* LightAttr CB
+    Used to parse tokens for a light attribute.
+    */
+class lightAttrCB : public trpgr_Callback {
+public:
+    void * Parse(trpgToken,trpgReadBuffer &);
+    trpgLightAttr *lightAttr;
+};
+void * lightAttrCB::Parse(trpgToken tok,trpgReadBuffer &buf)
+{
+    int            type_data;
+    int            directionality_data;
+    trpgColor    color_data;;
+    float64        float64_data;
+    trpg3dPoint    point_data;;
+    int32        int32_data;
+    int            quality_data;
+
+    try {
+        switch (tok) {
+        case TRPGLIGHTATTR_BASIC:
+            buf.Get(type_data);
+            lightAttr->SetType((trpgLightAttr::LightType)type_data);
+            buf.Get(directionality_data);
+            lightAttr->SetDirectionality((trpgLightAttr::LightDirectionality)directionality_data);
+            buf.Get(color_data);
+            lightAttr->SetFrontColor(color_data);
+            buf.Get(float64_data);
+            lightAttr->SetFrontIntensity(float64_data);
+            buf.Get(color_data);
+            lightAttr->SetBackColor(color_data);
+            buf.Get(float64_data);
+            lightAttr->SetBackIntensity(float64_data);
+            buf.Get(point_data);
+            lightAttr->SetNormal(point_data);
+            buf.Get(int32_data);
+            lightAttr->SetSMC(int32_data);
+            buf.Get(int32_data);
+            lightAttr->SetFID(int32_data);
+            buf.Get(int32_data);
+            lightAttr->SetFlags(int32_data);
+            lightAttr->SetPerformerFlags(int32_data);
+            lightAttr->SetAnimationFlags(int32_data);
+            buf.Get(float64_data);
+            lightAttr->SetHLobeAngle(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetVLobeAngle(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetLobeRollAngle(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetLobeFalloff(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetAmbient(float64_data);
+            buf.Get(quality_data);
+            lightAttr->SetQuality((trpgLightAttr::LightQuality)quality_data);
+            buf.Get(quality_data);
+            lightAttr->SetRandomIntensity((trpgLightAttr::LightQuality)quality_data);
+            break;
+        case TRPGLIGHTATTR_RASCAL:
+            buf.Get(float64_data);
+            lightAttr->SetRascalSignificance(float64_data);
+            break;
+        case TRPGLIGHTATTR_PERFORMER:
+            buf.Get(float64_data);
+            lightAttr->SetPerformerActualSize(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerFogScale(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerMinPixelSize(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerMaxPixelSize(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerTpClamp(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerTpFalloffExp(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerTpPixelSize(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetPerformerTpScale(float64_data);
+            break;
+        case TRPGLIGHTATTR_CALLIGRAPHIC:
+            buf.Get(int32_data);
+            lightAttr->SetCalligraphicDrawOrder(int32_data);
+            buf.Get(float64_data);
+            lightAttr->SetCalligraphicMinDefocus(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetCalligraphicMaxDefocus(float64_data);
+            break;
+        case TRPGLIGHTATTR_ANIMATION:
+            buf.Get(float64_data);
+            lightAttr->SetAnimationPeriod(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetAnimationPhaseDelay(float64_data);
+            buf.Get(float64_data);
+            lightAttr->SetAnimationTimeOn(float64_data);
+            buf.Get(point_data);
+            lightAttr->SetAnimationVector(point_data);
+            break;
+        default:
+            break;
+        }
+    }
+    catch (...) {
+        return NULL;
+    }
+
+    return lightAttr;
+}
+
+// Reads this class from a read buffer
+bool trpgLightAttr::Read(trpgReadBuffer &buf)
+{
+    Reset();
+
+    trpgr_Parser parse;
+    lightAttrCB lightAttrCb;
+
+    // Light attribute is just a bunch of unordered tokens.
+    // Interface to it with a generic parser
+    lightAttrCb.lightAttr = this;
+    parse.AddCallback(TRPGLIGHTATTR_BASIC,&lightAttrCb,false);
+    parse.AddCallback(TRPGLIGHTATTR_PERFORMER,&lightAttrCb,false);
+    parse.AddCallback(TRPGLIGHTATTR_RASCAL,&lightAttrCb,false);
+    parse.AddCallback(TRPGLIGHTATTR_CALLIGRAPHIC,&lightAttrCb,false);
+    parse.AddCallback(TRPGLIGHTATTR_ANIMATION,&lightAttrCb,false);
+    parse.Parse(buf);
+
+    return isValid();
+}
+
+bool trpgLightAttr::isValid(void) const
+{
+    return true;
+}
+
+trpgLightAttr& trpgLightAttr::operator = (const trpgLightAttr& in)
+{
+    data = in.data;
+    return *this;
+}
+
+bool trpgLightAttr::operator == (const trpgLightAttr& in)
+{
+    // this doesn't work, so do it a hard way
+    // return memcmp( &data,&in.data,sizeof(data) ) == 0;
+
+    if ( data.type != in.data.type )
+        return false;
+    if ( data.directionality != in.data.directionality )
+        return false;
+    if ( data.frontColor != in.data.frontColor )
+        return false;
+    if ( data.frontIntensity != in.data.frontIntensity )
+        return false;
+    if ( data.backColor != in.data.backColor )
+        return false;
+    if ( data.backIntensity != in.data.backIntensity )
+        return false;
+    if ( data.normal != in.data.normal )
+        return false;
+    if ( data.smc != in.data.smc )
+        return false;
+    if ( data.fid != in.data.fid )
+        return false;
+    if ( data.flags != in.data.flags )
+        return false;
+    if ( data.horizontalLobeAngle != in.data.horizontalLobeAngle )
+        return false;
+    if ( data.verticalLobeAngle != in.data.verticalLobeAngle )
+        return false;
+    if ( data.lobeRollAngle != in.data.lobeRollAngle )
+        return false;
+    if ( data.lobeFalloff != in.data.lobeFalloff )
+        return false;
+    if ( data.ambientIntensity != in.data.ambientIntensity )
+        return false;
+    if ( data.quality != in.data.quality )
+        return false;
+    if ( data.randomIntensity != in.data.randomIntensity )
+        return false;
+    if ( data.rascalSignificance != in.data.rascalSignificance )
+        return false;
+    if ( data.calligraphicAttr.drawOrder != in.data.calligraphicAttr.drawOrder )
+        return false;
+    if ( data.calligraphicAttr.minDefocus != in.data.calligraphicAttr.minDefocus )
+        return false;
+    if ( data.calligraphicAttr.maxDefocus != in.data.calligraphicAttr.maxDefocus )
+        return false;
+    if ( data.performerAttr.flags != in.data.performerAttr.flags )
+        return false;
+    if ( data.performerAttr.minPixelSize != in.data.performerAttr.minPixelSize )
+        return false;
+    if ( data.performerAttr.maxPixelSize != in.data.performerAttr.maxPixelSize )
+        return false;
+    if ( data.performerAttr.actualSize != in.data.performerAttr.actualSize )
+        return false;
+    if ( data.performerAttr.transparentPixelSize != in.data.performerAttr.transparentPixelSize )
+        return false;
+    if ( data.performerAttr.transparentFallofExp != in.data.performerAttr.transparentFallofExp )
+        return false;
+    if ( data.performerAttr.transparentScale != in.data.performerAttr.transparentScale )
+        return false;
+    if ( data.performerAttr.transparentClamp != in.data.performerAttr.transparentClamp )
+        return false;
+    if ( data.performerAttr.fogScale != in.data.performerAttr.fogScale )
+        return false;
+    if ( data.animationAttr.period != in.data.animationAttr.period )
+        return false;
+    if ( data.animationAttr.phaseDelay != in.data.animationAttr.phaseDelay )
+        return false;
+    if ( data.animationAttr.timeOn != in.data.animationAttr.timeOn )
+        return false;
+    if ( data.animationAttr.vector != in.data.animationAttr.vector )
+        return false;
+    if ( data.animationAttr.flags != in.data.animationAttr.flags )
+        return false;
+
+    return true;
+}
+
+bool trpgLightAttr::operator != (const trpgLightAttr& in)
+{
+    return !operator==(in);
+}
+
+void trpgLightAttr::Reset(void)
+{
+    data.type = trpg_Raster;
+    data.directionality = trpg_Omnidirectional;
+    data.frontColor = trpgColor(0,0,0);
+    data.frontIntensity = 0;
+    data.backColor = trpgColor(0,0,0);
+    data.backIntensity = 0;
+    data.normal = trpg3dPoint(0,0,1);
+    data.smc = 0;
+    data.fid = 0;
+    data.flags = 0;
+    data.horizontalLobeAngle = 0;
+    data.verticalLobeAngle = 0;
+    data.lobeRollAngle = 0;
+    data.lobeFalloff = 0;
+    data.ambientIntensity = 0;
+    data.quality = trpg_Low;
+    data.randomIntensity = trpg_Low;
+    data.rascalSignificance = 0;
+    data.calligraphicAttr.drawOrder = 0;
+    data.calligraphicAttr.minDefocus = 0;
+    data.calligraphicAttr.maxDefocus = 0;
+    data.performerAttr.flags = 0;
+    data.performerAttr.minPixelSize = 0;
+    data.performerAttr.maxPixelSize = 0;
+    data.performerAttr.actualSize = 0;
+    data.performerAttr.transparentPixelSize = 0;
+    data.performerAttr.transparentFallofExp = 0;
+    data.performerAttr.transparentScale = 0;
+    data.performerAttr.transparentClamp = 0;
+    data.performerAttr.fogScale = 0;
+    data.animationAttr.period = 0;
+    data.animationAttr.phaseDelay = 0;
+    data.animationAttr.timeOn = 0;
+    data.animationAttr.vector = trpg3dPoint(0,0,1);
+    data.animationAttr.flags = 0;
+}
+
+/**************
+    Light
+*/
+
+trpgLight::trpgLight(void)
+{
+    index = -1;
+}
+
+trpgLight::trpgLight(const trpgLight &in)
+{
+    operator=(in);
+}
+
+trpgLight::~trpgLight(void)
+{
+    Reset();
+}
+
+// Set the index pointing into the Light Table
+void trpgLight::SetAttrIndex(int ix)
+{
+    index = ix;
+}
+
+// Add a new location this light is located at
+void trpgLight::AddVertex(trpg3dPoint pt)
+{
+    lightPoints.push_back(pt);
+}
+
+// Returns the number of locations, this light is located at
+void trpgLight::GetNumVertices(uint32 &nvertices) const
+{
+    nvertices = lightPoints.size();
+}
+
+// Returns the location at a given index
+bool trpgLight::GetVertex(uint32 ix, trpg3dPoint &pt) const
+{
+    if (ix < lightPoints.size() ) {
+        pt = lightPoints[ix];
+        return true;
+    }
+    else
+        return false;
+}
+
+bool trpgLight::GetVertices(trpg3dPoint *pts) const
+{
+    int i;
+
+    if (!isValid()) return false;
+
+    if (lightPoints.size() != 0)
+        for (i=0;i<lightPoints.size();i++)
+            pts[i] = lightPoints[i];
+
+    return true;
+}
+
+bool trpgLight::GetVertices(float64 *fts) const
+{
+    int i;
+    int j = 0;
+
+    if (!isValid()) return false;
+
+    if (lightPoints.size() != 0)
+        for (i=0;i<lightPoints.size();i++) {
+            fts[j++] = lightPoints[i].x;
+            fts[j++] = lightPoints[i].y;
+            fts[j++] = lightPoints[i].z;
+        }
+
+    return true;
+}
+
+bool trpgLight::GetVertices(float32 *fts) const
+{
+    int i;
+    int j = 0;
+
+    if (!isValid()) return false;
+
+    if (lightPoints.size() != 0)
+        for (i=0;i<lightPoints.size();i++) {
+            fts[j++] = (float32)lightPoints[i].x;
+            fts[j++] = (float32)lightPoints[i].y;
+            fts[j++] = (float32)lightPoints[i].z;
+        }
+
+    return true;
+}
+
+
+// Returns the index of the Light Attributes in the Light Table
+void trpgLight::GetAttrIndex(int &ix) const
+{
+    ix = index;
+}
+
+// Validity check
+bool trpgLight::isValid(void) const
+{
+    return true;
+}
+
+// Resets the contents back to empty
+void trpgLight::Reset(void)
+{
+    lightPoints.clear();
+    index =-1;
+}
+
+// Writes this class to a write buffer
+bool trpgLight::Write(trpgWriteBuffer &buf)
+{
+    int numVertices = lightPoints.size();
+
+    if (!isValid())
+        return false;
+
+    buf.Begin(TRPGLIGHT);
+
+    buf.Add(index);
+    buf.Add(numVertices);
+    for (unsigned int i=0;i<lightPoints.size();i++)
+        buf.Add(lightPoints[i]);
+
+    buf.End();
+
+    return true;
+}
+
+// Reads this class from a read buffer
+bool trpgLight::Read(trpgReadBuffer &buf)
+{
+    Reset();
+
+    int numVertices;
+    buf.Get(index);
+    buf.Get(numVertices);
+    for ( int i = 0; i < numVertices; i++ ) {
+        trpg3dPoint vx;
+        buf.Get(vx);
+        lightPoints.push_back(vx);
+    }
+
+    return isValid();
+}
+
+// operator
+trpgLight& trpgLight::operator = (const trpgLight &in)
+{
+    Reset();
+
+    index = in.index;
+    for ( int i = 0; i < in.lightPoints.size(); i++ )
+        lightPoints.push_back(in.lightPoints[i]);
+
+    return *this;
+}
+
+
+/* Light Attributes Table
+    Just a list of light attribs so we can index.
+    */
+
+// Constructor
+trpgLightTable::trpgLightTable()
+{
+}
+
+trpgLightTable::trpgLightTable(const trpgLightTable &in)
+{
+    *this = in;
+}
+
+// Reset function
+void trpgLightTable::Reset()
+{
+    lightList.clear();
+}
+
+// Destructor
+trpgLightTable::~trpgLightTable()
+{
+    Reset();
+}
+
+// Validity check
+bool trpgLightTable::isValid() const
+{
+    for (unsigned int i=0;i<lightList.size();i++)
+        if (!lightList[i].isValid())
+            return false;
+
+    return true;
+}
+
+// Set functions
+int trpgLightTable::AddLightAttr(const trpgLightAttr& inLight)
+{
+    lightList.push_back(inLight);
+    return lightList.size()-1;
+}
+int trpgLightTable::FindAddLightAttr(const trpgLightAttr& inLight)
+{
+    for (int i=0;i<lightList.size();i++)
+        if (lightList[i] == inLight)
+            return i;
+
+    return AddLightAttr(inLight);
+}
+
+
+// Copy operator
+trpgLightTable &trpgLightTable::operator = (const trpgLightTable &in)
+{
+    Reset();
+    for (int i=0;i<in.lightList.size();i++)
+        AddLightAttr(in.lightList[i]);
+
+    return *this;
+}
+
+// Write Light table
+bool trpgLightTable::Write(trpgWriteBuffer &buf)
+{
+    int32 numLights;
+
+    if (!isValid())
+        return false;
+
+    buf.Begin(TRPGLIGHTTABLE);
+    numLights = lightList.size();
+    buf.Add(numLights);
+    for (unsigned int i=0;i<lightList.size();i++)
+        lightList[i].Write(buf);
+    buf.End();
+
+    return true;
+}
+
+/* ***********
+    Read Light Table
+   ***********
+   */
+// Get functions
+bool trpgLightTable::GetNumLightAttrs(int &no) const
+{
+    if (!isValid()) return false;
+    no = lightList.size();
+    return true;
+}
+
+const trpgLightAttr* trpgLightTable::GetLightAttrRef(int id) const
+{
+    if (id < 0 || id >= lightList.size()) return NULL;
+    return &lightList[id];
+}
+
+bool trpgLightTable::Read(trpgReadBuffer &buf)
+{
+    int32        numLights;
+    trpgToken    lightTok;
+    int32        len;
+
+    try {
+        buf.Get(numLights);
+        lightList.resize(numLights);
+        for (unsigned int i=0;i<numLights;i++) {
+            buf.GetToken(lightTok,len);
+            if (lightTok != TRPGLIGHTATTR) throw 1;
+            buf.PushLimit(len);
+            trpgLightAttr &light = lightList[i];
+            bool status = light.Read(buf);
+            buf.PopLimit();
+            if (!status) throw 1;
+        }
+    }
+    catch (...) {
+        return false;
+    }
+
+    return true;
+}
+
diff --git a/src/osgPlugins/txp/trpage_pparse.cpp b/src/osgPlugins/txp/trpage_pparse.cpp
new file mode 100644
index 000000000..7ac09fbb7
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_pparse.cpp
@@ -0,0 +1,210 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* trpage_pparse.cpp
+    This file contains classes that can parse a TerraPage
+    archive for the purpose of printing it out.
+ */
+
+#include "trpage_print.h"
+#include "trpage_scene.h"
+
+/* Set up the callbacks for the scene graph parser.
+    In our case this is just one read helper with
+    a switch statement.
+ */
+trpgPrintGraphParser::trpgPrintGraphParser(trpgPrintBuffer *inBuf)
+{
+    printBuf = inBuf;
+
+    // Register the readers
+    AddCallback(TRPG_GEOMETRY,new ReadHelper(printBuf));
+    AddCallback(TRPG_GROUP,new ReadHelper(printBuf));
+    AddCallback(TRPG_ATTACH,new ReadHelper(printBuf));
+    AddCallback(TRPG_BILLBOARD,new ReadHelper(printBuf));
+    AddCallback(TRPG_LOD,new ReadHelper(printBuf));
+    AddCallback(TRPG_TRANSFORM,new ReadHelper(printBuf));
+    AddCallback(TRPG_MODELREF,new ReadHelper(printBuf));
+    AddCallback(TRPG_LAYER,new ReadHelper(printBuf));
+    AddCallback(TRPG_LIGHT,new ReadHelper(printBuf));
+    AddCallback(TRPGTILEHEADER,new ReadHelper(printBuf));
+}
+
+/* Start Children is called when the parser hits a Push
+    in the read buffer.  We just want to indent further when
+    that happens.
+ */
+bool trpgPrintGraphParser::StartChildren(void *)
+{
+    printBuf->IncreaseIndent();
+
+    return true;
+}
+
+
+/* End Children is called when the parser hits a Pop
+    in the read buffer.  We just want to reduce the indent
+    when that happens.
+ */
+bool trpgPrintGraphParser::EndChildren(void *)
+{
+    printBuf->DecreaseIndent();
+
+    return true;
+}
+
+/* Read Helper parse method sets up the correct class depending
+    on the token and asks it to read and print itself.
+ */
+void *trpgPrintGraphParser::ReadHelper::Parse(trpgToken tok,trpgReadBuffer &buf)
+{
+    trpgReadWriteable *obj = NULL;
+
+    switch (tok) {
+    case TRPG_GEOMETRY:
+        obj = new trpgGeometry();
+        break;
+    case TRPG_GROUP:
+        obj = new trpgGroup();
+        break;
+    case TRPG_ATTACH:
+        obj = new trpgAttach();
+        break;
+    case TRPG_BILLBOARD:
+        obj = new trpgBillboard();
+        break;
+    case TRPG_LOD:
+        obj = new trpgLod();
+        break;
+    case TRPG_TRANSFORM:
+        obj = new trpgTransform();
+        break;
+    case TRPG_MODELREF:
+        obj = new trpgModelRef();
+        break;
+    case TRPG_LAYER:
+        obj = new trpgLayer();
+        break;
+    case TRPG_LIGHT:
+        obj = new trpgLight();
+        break;
+    case TRPGTILEHEADER:
+        obj = new trpgTileHeader();
+        break;
+    };
+
+    if (obj) {
+        if (obj->Read(buf))
+            obj->Print(*pBuf);
+        delete obj;
+    }
+
+    // Need to return non-zero.  Otherwise it's interpreted as an error
+    return (void *)1;
+}
+
+// The following routine is not compiled if there's no _splitpath
+#ifdef _splitpath
+/* This is a convenience function to print out the contents
+    of an entire TerraPage archive.
+
+   There are two versions of this function.  The first takes
+   a file name and the second an opened archive where the header
+   has already been read.
+ */
+bool trpgPrintArchive(char *filename,trpgPrintBuffer &pBuf,int flags)
+{
+    trpgr_Archive archive;
+
+    // Break path apart so we can find the directory
+    char drive[100],dir[1024],fname[1024],ext[1024];
+    _splitpath(filename,drive,dir,fname,ext);
+
+    char rname[1024],baseDir[1024];
+    sprintf(baseDir,"%s%s",drive,dir);
+    sprintf(rname,"%s%s",fname,ext);
+
+    if (!*baseDir) strcpy(baseDir,".");
+    archive.SetDirectory(baseDir);
+    if (!archive.OpenFile(rname)) {
+        fprintf(stdout,"Failed to open archive.\n");
+        return false;
+    }
+    if (!archive.ReadHeader()) {
+        fprintf(stdout,"Failed to read header.\n");
+        return false;
+    }
+
+    bool status = trpgPrintArchive(&archive,pBuff,flags);
+    return status;
+}
+#endif
+
+bool trpgPrintArchive(trpgr_Archive *archive,trpgPrintBuffer &pBuf,int flags)
+{
+    char ls[1024];
+
+    if (!archive->isValid())  return false;    
+    
+    pBuf.prnLine("====Header Structures====");
+
+    // Print out the header portion
+    archive->GetHeader()->Print(pBuf);
+    archive->GetMaterialTable()->Print(pBuf);
+    archive->GetTexTable()->Print(pBuf);
+    archive->GetModelTable()->Print(pBuf);
+    archive->GetTileTable()->Print(pBuf);
+    archive->GetLightTable()->Print(pBuf);
+    archive->GetRangeTable()->Print(pBuf);
+    pBuf.prnLine();
+
+    // Now do the tiles
+    if (!archive->isValid())  return false;    
+
+    // Parser that prints out a tile scene graph
+    trpgPrintGraphParser parser(&pBuf);
+
+    pBuf.prnLine("====Tile Data====");
+    int nl,x,y;
+    trpgMemReadBuffer buf(archive->GetEndian());
+    // Iterate over the terrain lods
+    int numLod;
+    archive->GetHeader()->GetNumLods(numLod);
+    trpg2iPoint tileSize;
+    for (nl=0;nl<numLod;nl++) {
+        archive->GetHeader()->GetLodSize(nl,tileSize);
+        // Iterate over the tiles
+        for (x=tileSize.x-1;x>=0;x--)
+            for (y=0;y<tileSize.y;y++) {
+                sprintf(ls,"Tile (lod) (x,y) = (%d) (%d,%d)",nl,x,y);
+                pBuf.prnLine(ls);
+                if (archive->ReadTile(x,y,nl,buf)) {
+                    if (flags & TRPGPRN_BODY) {
+                        pBuf.IncreaseIndent();
+                        // Parse it (also prints it
+                        parser.Parse(buf);
+                        pBuf.DecreaseIndent();
+                    }
+                } else
+                    pBuf.prnLine("  Couldn't read tile.");
+            }
+    }
+
+    return true;
+}
diff --git a/src/osgPlugins/txp/trpage_print.cpp b/src/osgPlugins/txp/trpage_print.cpp
new file mode 100644
index 000000000..abcf2e7f6
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_print.cpp
@@ -0,0 +1,838 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* trpage_print.cpp
+    Print out the contents of a TerraPage archive.
+    This module provides an example of how to access each of the classes
+    within a TerraPage archive.
+ */
+
+#include "trpage_print.h"
+
+/* ******************************************
+   Print Buffer implementation
+    The print buffer is a way to dump debugging data out
+    to a file (or console).  You can make your own subclass
+    of trpgPrintBuffer if you have specific needs.
+   ******************************************
+ */
+
+trpgPrintBuffer::trpgPrintBuffer()
+{
+    curIndent = 0;
+    indentStr[0] = 0;
+}
+
+// Increase the current indent
+void trpgPrintBuffer::IncreaseIndent(int amount)
+{
+    curIndent+=amount;
+    updateIndent();
+}
+
+// Decrease the current indent
+void trpgPrintBuffer::DecreaseIndent(int amount)
+{
+    curIndent-=amount;
+    curIndent = MAX(0,curIndent);
+    updateIndent();
+}
+
+// Reprint the indent string
+void trpgPrintBuffer::updateIndent()
+{
+    int i;
+    for (i=0;i<MIN(199,curIndent);i++)
+        indentStr[i] = ' ';
+    indentStr[i] = 0;
+}
+
+// Constructors for File Print Buffer
+
+trpgFilePrintBuffer::trpgFilePrintBuffer(FILE *inFp)
+{
+    isMine = false;
+    fp = inFp;
+    valid = true;
+}
+
+trpgFilePrintBuffer::trpgFilePrintBuffer(char *file)
+{
+    isMine = true;
+    fp = fopen(file,"w");
+    valid = fp != NULL;
+}
+
+// Destructor for File Print Buffer
+
+trpgFilePrintBuffer::~trpgFilePrintBuffer()
+{
+    if (isMine && fp)
+        fclose(fp);
+    fp = NULL;
+    valid = false;
+}
+
+// Print out a line of text
+
+bool trpgFilePrintBuffer::prnLine(char *str)
+{
+    if (!fp)
+        return false;
+
+    if (str) {
+        fprintf(fp,indentStr);
+        fprintf(fp,str);
+        fprintf(fp,"\n");
+    } else
+        fprintf(fp,"\n");
+
+    return true;
+}
+
+/* *************************************
+   Print Methods for TerraPage constructs
+   All the print methods for every TerraPage object that
+   is readable/writeable are here.  These are used for
+   debugging.
+   *************************************
+ */
+
+/* Print out the header information.
+ */
+bool trpgHeader::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+    buf.prnLine("----Archive Header----");
+    buf.IncreaseIndent();
+    sprintf(ls,"verMinor = %d, verMajor = %d",verMinor,verMajor); buf.prnLine(ls);
+    sprintf(ls,"dbVerMinor = %d, dbVerMajor = %d",dbVerMinor,dbVerMajor); buf.prnLine(ls);
+    sprintf(ls,"maxGroupID = %d",maxGroupID); buf.prnLine(ls);
+    sprintf(ls,"sw = (%f,%f), ne = (%f,%f)",sw.x,sw.y,ne.x,ne.y); buf.prnLine(ls);
+    sprintf(ls,"tileType = %d, origin = (%f,%f,%f)",tileType,origin.x,origin.y,origin.z); buf.prnLine(ls);
+
+    sprintf(ls,"numLods = %d",numLods); buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (int i=0;i<numLods;i++) {
+        sprintf(ls,"tileSize = (%f,%f), lodSizes = (%d,%d), lodRanges = %f",tileSize[i].x,tileSize[i].y,lodSizes[i].x,lodSizes[i].y,lodRanges[i]); buf.prnLine(ls);
+    }
+    buf.DecreaseIndent(2);
+    buf.prnLine("");
+
+    return true;
+}
+
+/* Print out texture environment information
+ */
+bool trpgTextureEnv::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+    buf.prnLine("----Texture Environment----");
+    buf.IncreaseIndent();
+    sprintf(ls,"envMode = %d",envMode); buf.prnLine(ls);
+    sprintf(ls,"minFilter = %d, magFilter = %d",minFilter,magFilter);  buf.prnLine(ls);
+    sprintf(ls,"wrapS = %d, wrapT = %d",wrapS,wrapT);  buf.prnLine(ls);
+    buf.DecreaseIndent();
+    buf.prnLine("");
+
+    return true;
+}
+
+/* Print out the material information
+ */
+bool trpgMaterial::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+    buf.prnLine("----Material----");
+    buf.IncreaseIndent();
+    sprintf(ls,"isBumpMap = %d",(int)isBump);
+    sprintf(ls,"color = (%f,%f,%f)",color.red,color.green,color.blue); buf.prnLine(ls);
+    sprintf(ls,"ambient = (%f,%f,%f)",ambient.red,ambient.green,ambient.blue); buf.prnLine(ls);
+    sprintf(ls,"diffuse = (%f,%f,%f)",diffuse.red,diffuse.green,diffuse.blue); buf.prnLine(ls);
+    sprintf(ls,"specular = (%f,%f,%f)",specular.red,specular.green,specular.blue); buf.prnLine(ls);
+    sprintf(ls,"emission = (%f,%f,%f)",emission.red,emission.green,emission.blue); buf.prnLine(ls);
+    sprintf(ls,"shininess = %f, shadeModel = %d",shininess,shadeModel); buf.prnLine(ls);
+    sprintf(ls,"pointSize = %f, lineWidth = %f",pointSize,lineWidth); buf.prnLine(ls);
+    sprintf(ls,"cullMode = %d, alphaFunc = %d",cullMode,alphaFunc); buf.prnLine(ls);
+    sprintf(ls,"alpha = %f, alphaRef = %f",alpha,alphaRef); buf.prnLine(ls);
+    sprintf(ls,"autoNormal = %d",autoNormal); buf.prnLine(ls);
+    sprintf(ls,"numTile = %d",numTile); buf.prnLine(ls);
+    sprintf(ls,"numTex = %d",numTex); buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (int i=0;i<numTex;i++) {
+        sprintf(ls,"texID[%d] = %d",i,texids[i]); buf.prnLine(ls);
+        buf.IncreaseIndent();
+        texEnvs[i].Print(buf);
+        buf.DecreaseIndent();
+    }
+    buf.DecreaseIndent(2);
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out the material tables.
+ */
+bool trpgMatTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+    buf.prnLine("----Material Table----");
+    buf.IncreaseIndent();
+    sprintf(ls,"numTable = %d",numTable); buf.prnLine(ls);
+    sprintf(ls,"numMat = %d",numMat);  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (int j=0;j<numTable;j++) {
+        sprintf(ls,"----Sub Table %d----",j); buf.prnLine(ls);
+        buf.IncreaseIndent();
+        for (int i=0;i<numMat;i++) {
+            const trpgMaterial *mat;
+            sprintf(ls,"Material %d",i);  buf.prnLine(ls);
+            mat = (const_cast<trpgMatTable *>(this))->GetMaterialRef(j,i);
+            mat->Print(buf);
+        }
+        buf.DecreaseIndent();
+    }
+    buf.DecreaseIndent(2);
+
+    return true;
+}
+
+/* Print out texture.
+ */
+bool trpgTexture::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Texture----");
+    buf.IncreaseIndent();
+    sprintf(ls,"mode = %d, type = %d",mode,type);  buf.prnLine(ls);
+    sprintf(ls,"Name = %s",name); buf.prnLine(ls);
+    sprintf(ls,"useCount = %d",useCount);  buf.prnLine(ls);
+    sprintf(ls,"sizeX = %d, sizeY = %d",sizeX,sizeY);  buf.prnLine(ls);
+    sprintf(ls,"ismipmap = %d",isMipmap);  buf.prnLine(ls);
+    sprintf(ls,"addr.file = %d, addr.offset = %d",addr.file,addr.offset);  buf.prnLine(ls);
+    buf.DecreaseIndent();
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out texture table
+ */
+bool trpgTexTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Texture Table----");
+    buf.IncreaseIndent();
+    for (int i=0;i<texList.size();i++) {
+        sprintf(ls,"Texture %d",i); buf.prnLine(ls);
+        texList[i].Print(buf);
+    }
+    buf.DecreaseIndent();
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out model table
+ */
+bool trpgModelTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Model Table----");
+    buf.IncreaseIndent();
+    for (int i=0;i<models.size();i++) {
+        sprintf(ls,"Model %d",i);  buf.prnLine(ls);
+        models[i].Print(buf);
+    }
+    buf.DecreaseIndent();
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out a model
+ */
+bool trpgModel::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Model----");
+    buf.IncreaseIndent();
+    sprintf(ls,"type = %d",type); buf.prnLine(ls);
+    if (name) {
+        sprintf(ls,"name = %s",name); buf.prnLine(ls);
+    }
+    sprintf(ls,"diskRef = %d",(int)diskRef), buf.prnLine(ls);
+    sprintf(ls,"useCount = %d",useCount); buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out a tile header
+ */
+bool trpgTileHeader::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Tile Header----");
+    buf.IncreaseIndent();
+
+    sprintf(ls,"matList size = %d",matList.size()); buf.prnLine(ls);
+    buf.IncreaseIndent();
+    int i;
+    for (i=0;i<matList.size();i++) {
+        sprintf(ls,"matList[%d] = %d",i,matList[i]); buf.prnLine(ls);
+    }
+    buf.DecreaseIndent();
+
+    sprintf(ls,"modelList size = %d",modelList.size());  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (i=0;i<modelList.size();i++) {
+        sprintf(ls,"modelList[%d] = %d",i,modelList[i]); buf.prnLine(ls);
+    }
+    buf.DecreaseIndent();
+
+    sprintf(ls,"local material list size = %d",locMats.size());  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (i=0;i<locMats.size();i++)
+        locMats[i].Print(buf);
+    buf.DecreaseIndent();
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out color info
+ */
+bool trpgColorInfo::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Color Info----");
+    buf.IncreaseIndent();
+
+    sprintf(ls,"type = %d, bind = %d",type,bind);  buf.prnLine(ls);
+    sprintf(ls,"colorData size = %d",data.size());
+    buf.IncreaseIndent();
+    for (int i=0;i<data.size();i++) {
+        sprintf(ls,"color[%d] = (%f,%f,%f)",i,data[i].red,data[i].blue,data[i].green); buf.prnLine(ls);
+    }
+    buf.DecreaseIndent(2);
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out tex data info
+ */
+bool trpgTexData::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Tex Data----");
+    buf.IncreaseIndent();
+
+    sprintf(ls,"bind = %d",bind);  buf.prnLine(ls);
+    if (floatData.size()) {
+        sprintf(ls,"tex coords (float) = %d",floatData.size()); buf.prnLine(ls);
+        buf.IncreaseIndent();
+        for (int i=0;i<floatData.size()/2;i++) {
+            sprintf(ls,"tex coord[%d] = (%f,%f)",i,floatData[i*2+0],floatData[i*2+1]);  buf.prnLine(ls);
+        }
+        buf.DecreaseIndent();
+    } else {
+        if (doubleData.size()) {
+            sprintf(ls,"tex coords (double) = %d",doubleData.size());
+            buf.IncreaseIndent();
+            for (int i=0;i<doubleData.size()/2;i++) {
+                sprintf(ls,"tex coord[%d] = (%f,%f)",i,doubleData[i*2+0],doubleData[i*2+1]),  buf.prnLine(ls);
+            }
+            buf.DecreaseIndent();
+        }
+    }
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out geometry data
+ */
+bool trpgGeometry::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Geometry Node----");
+    buf.IncreaseIndent();
+
+    sprintf(ls,"Material size = %d",materials.size());  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    ls[0] = 0;
+    int i;
+    for (i=0;i<materials.size();i++) {
+        char locStr[100];
+        sprintf(locStr,"%d ",materials[i]);
+        strcat(ls,locStr);
+    }
+    buf.prnLine(ls);
+    buf.DecreaseIndent();
+
+    sprintf(ls,"primType = %d, numPrim = %d",primType,numPrim);  buf.prnLine(ls);
+    sprintf(ls,"primLength size = %d",primLength.size());  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    ls[0] = 0;
+    for (i=0;i<primLength.size();i++) {
+        char locStr[100];
+        sprintf(locStr,"%d ",primLength[i]);
+        strcat(ls,locStr);
+    }
+    buf.prnLine(ls);
+    buf.DecreaseIndent();
+
+    if (vertDataFloat.size()) {
+        sprintf(ls,"vert data (float) length = %d",vertDataFloat.size());
+        buf.prnLine(ls);
+        buf.IncreaseIndent();
+        for (i=0;i<vertDataFloat.size();i++) {
+            sprintf(ls,"(%f, %f, %f)",vertDataFloat[3*i],vertDataFloat[3*i+1],vertDataFloat[3*i+2]);
+            buf.prnLine(ls);
+        }
+        buf.DecreaseIndent();
+    } else {
+        if (vertDataDouble.size()) {
+            sprintf(ls,"vert data (double) length = %d",vertDataDouble.size());
+            buf.prnLine(ls);
+            buf.IncreaseIndent();
+            for (i=0;i<vertDataDouble.size();i++) {
+                sprintf(ls,"(%f, %f, %f)",vertDataDouble[3*i],vertDataDouble[3*i+1],vertDataDouble[3*i+2]);
+                buf.prnLine(ls);
+            }
+            buf.DecreaseIndent();
+        }
+    }
+
+    sprintf(ls,"normBind = %d",normBind);  buf.prnLine(ls);
+
+    if (normDataFloat.size()) {
+        sprintf(ls,"norm data (float) length = %d",normDataFloat.size());
+        buf.prnLine(ls);
+        buf.IncreaseIndent();
+        for (i=0;i<normDataFloat.size()/3;i++) {
+            sprintf(ls,"(%f, %f, %f)",normDataFloat[3*i],normDataFloat[3*i+1],normDataFloat[3*i+2]);
+            buf.prnLine(ls);
+        }
+        buf.DecreaseIndent();
+    } else {
+        if (normDataDouble.size()) {
+            sprintf(ls,"norm data (double) length = %d",normDataDouble.size());
+            buf.prnLine(ls);
+            buf.IncreaseIndent();
+            for (i=0;i<normDataDouble.size()/3;i++) {
+                sprintf(ls,"(%f, %f, %f)",normDataDouble[3*i],normDataDouble[3*i+1],normDataDouble[3*i+2]);
+                buf.prnLine(ls);
+            }
+            buf.DecreaseIndent();
+        }
+    }
+
+    sprintf(ls,"color info size = %d",colors.size()); buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (i=0;i<colors.size();i++) {
+        colors[i].Print(buf);
+    }
+    buf.DecreaseIndent();
+
+    sprintf(ls,"tex data size = %d",texData.size());
+    buf.IncreaseIndent();
+    for (i=0;i<texData.size();i++) {
+        texData[i].Print(buf);
+    }
+    buf.DecreaseIndent();
+
+    // Note: Do edge flags
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print group info
+ */
+bool trpgGroup::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Group Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d, numChild = %d",id,numChild);  buf.prnLine(ls);
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print Attach info
+ */
+bool trpgAttach::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Attach Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d, parentID = %d, childPos = %d",id,parentID,childPos);  buf.prnLine(ls);
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print billboard info
+ */
+bool trpgBillboard::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Billboard Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d,  type = %d, mode = %d",id,type,mode);  buf.prnLine(ls);
+    sprintf(ls,"center = (%f,%f,%f)",center.x,center.y,center.z);  buf.prnLine(ls);
+    sprintf(ls,"axis = (%f,%f,%f)",axis.x,axis.y,axis.z);  buf.prnLine(ls);
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print LOD info
+ */
+bool trpgLod::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----LOD Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d",id);  buf.prnLine(ls);
+    sprintf(ls,"numRange (hint) = %d",numRange);  buf.prnLine(ls);
+    sprintf(ls,"switchIn = %f, switchOut = %f, width = %f",switchIn,switchOut,width);  buf.prnLine(ls);
+    sprintf(ls,"center = (%f,%f,%f)",center.x,center.y,center.z);
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+    sprintf(ls,"rangeIndex = %d",rangeIndex);  buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print Layer info
+ */
+bool trpgLayer::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Layer Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d",id);  buf.prnLine(ls);
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print Transform
+ */
+bool trpgTransform::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Transform Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"id = %d",id);  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (int i=0;i<4;i++) {
+        sprintf(ls,"%f %f %f %f",m[i][0],m[i][1],m[i][2],m[i][3]);
+        buf.prnLine(ls);
+    }
+    sprintf(ls,"name = %s", name ? name : "noname" );    buf.prnLine(ls);
+    
+    buf.DecreaseIndent(2);
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print Model Reference
+ */
+bool trpgModelRef::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Model Reference Node----");
+    buf.IncreaseIndent();
+    sprintf(ls,"modelRef = %d",modelRef);  buf.prnLine(ls);
+    buf.IncreaseIndent();
+    for (int i=0;i<4;i++) {
+        sprintf(ls,"%f %f %f %f",m[i][0],m[i][1],m[i][2],m[i][3]);
+        buf.prnLine(ls);
+    }
+    
+    buf.DecreaseIndent(2);
+    buf.prnLine();
+
+    return true;
+}
+
+/* Tile Table Print
+ */
+bool trpgTileTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Tile Table----");
+    buf.IncreaseIndent();
+    sprintf(ls,"mode = %d",mode);  buf.prnLine(ls);
+    sprintf(ls,"numLod = %d",lodInfo.size());  buf.prnLine(ls);
+    for (int i=0;i<lodInfo.size();i++) {
+        const LodInfo &li = lodInfo[i];
+        sprintf(ls,"LOD %d, numX = %d, numY = %d",i,li.numX,li.numY);  buf.prnLine(ls);
+        buf.prnLine("File ID, Offset, Zmin, Zmax");
+        buf.IncreaseIndent();
+        for (int j=0;j<li.addr.size();j++) {
+            sprintf(ls,"%d %d %f %f",li.addr[j].file,li.addr[j].offset,li.elev_min[j],li.elev_max[j]);  buf.prnLine(ls);
+        }
+        buf.DecreaseIndent();
+    }
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Local Material Print
+ */
+bool trpgLocalMaterial::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Local Material Definition----");
+    buf.IncreaseIndent();
+    sprintf(ls,"baseMat = %d",baseMat);  buf.prnLine(ls);
+    sprintf(ls,"(sx,sy) -> (ex,ey) = (%d,%d) -> (%d,%d)",sx,sy,ex,ey); buf.prnLine(ls);
+    sprintf(ls,"dest (width,height) = (%d,%d)",destWidth,destHeight); buf.prnLine(ls);
+    sprintf(ls,"addr (file,offset) = (%d,%d)",addr.file,addr.offset); buf.prnLine(ls);
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Light Attribute Print
+*/
+bool trpgLightAttr::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    const char* strType[] = {"Raster","Calligraphic","RASCAL"};
+    const char* strDirect[] = {"Omnidirectional","Bidirectional","Unidirectional"};
+    const char* strQuality[] = {"Off","Low","Medium","High","Undefined"};
+
+    buf.prnLine("----Light Attribute----");
+    buf.IncreaseIndent();
+    sprintf(ls,"type = %s",strType[(int)(data.type)]);                        buf.prnLine(ls);
+    sprintf(ls,"directionality = %s",strDirect[(int)(data.directionality)]);buf.prnLine(ls);
+    sprintf(ls,"front color (RGB) = %.2lf, %.2lf, %.2lf",
+        data.frontColor.red, data.frontColor.green,data.frontColor.blue );    buf.prnLine(ls);
+    sprintf(ls,"front intensity = %.2lf", data.frontIntensity );            buf.prnLine(ls);
+    sprintf(ls,"back color (RGB) = %.2lf, %.2lf, %.2lf",
+        data.backColor.red, data.backColor.green,data.backColor.blue );        buf.prnLine(ls);
+    sprintf(ls,"back intensity = %.2lf", data.backIntensity );                buf.prnLine(ls);
+    sprintf(ls,"normal (xyz) = %.2lf,%.2lf,%.2lf",
+        data.normal.x,data.normal.y,data.normal.z );                        buf.prnLine(ls);
+    sprintf(ls,"smc = %d",data.smc);                                        buf.prnLine(ls);
+    sprintf(ls,"fid = %d",data.fid);                                        buf.prnLine(ls);
+    sprintf(ls,"visible at DAY = %s",
+        (data.flags & trpgLightAttr::trpg_Day ? "yes" : "no") );                buf.prnLine(ls);
+    sprintf(ls,"visible at DUSK = %s",
+        (data.flags & trpgLightAttr::trpg_Dusk ? "yes" : "no") );            buf.prnLine(ls);
+    sprintf(ls,"visible at NIGHT = %s",
+        (data.flags & trpgLightAttr::trpg_Night ? "yes" : "no") );            buf.prnLine(ls);
+    sprintf(ls,"enable directionality = %s",
+        (data.flags & trpgLightAttr::trpg_Directional ? "yes" : "no" ));        buf.prnLine(ls);
+    sprintf(ls,"enable back color = %s",
+        (data.flags & trpgLightAttr::trpg_BackColor ? "yes" : "no" ));        buf.prnLine(ls);
+    sprintf(ls,"horizontal lobe angle = %.2lf",data.horizontalLobeAngle);    buf.prnLine(ls);
+    sprintf(ls,"vertical lobe angle = %.2lf",data.verticalLobeAngle);        buf.prnLine(ls);
+    sprintf(ls,"lobe roll angle = %.2lf",data.lobeRollAngle);                buf.prnLine(ls);
+    sprintf(ls,"lobe falloff = %.2lf",data.lobeFalloff);                    buf.prnLine(ls);
+    sprintf(ls,"ambient intensity = %.2lf",data.ambientIntensity);            buf.prnLine(ls);
+    sprintf(ls,"reflective only = %s",
+        (data.flags & trpgLightAttr::trpg_Reflective ? "yes" : "no") );        buf.prnLine(ls);
+    sprintf(ls,"quality = %s", strQuality[(int)(data.quality)]);            buf.prnLine(ls);
+    sprintf(ls,"significance for RASCAL lights = %.2lf",
+        data.rascalSignificance );                                            buf.prnLine(ls);
+    sprintf(ls,"calligraphic draw order = %d",
+        data.calligraphicAttr.drawOrder );                                    buf.prnLine(ls);
+    sprintf(ls,"calligraphic lights maximum defocus = %f",
+        data.calligraphicAttr.maxDefocus );                                    buf.prnLine(ls);
+    sprintf(ls,"calligraphic lights minimum defocus = %f",
+        data.calligraphicAttr.minDefocus );                                    buf.prnLine(ls);
+    sprintf(ls,"randomize intensity = %s",
+        strQuality[(int)(data.randomIntensity)]);                            buf.prnLine(ls);
+    sprintf(ls,"performer perspective mode = %s",
+        (data.flags & trpgLightAttr::trpg_Perspective ? "yes" : "no" ) );    buf.prnLine(ls);
+    sprintf(ls,"performer fade = %s",
+        (data.flags & trpgLightAttr::trpg_Fade ? "yes" : "no" ) );            buf.prnLine(ls);
+    sprintf(ls,"performer fog punch = %s",
+        (data.flags & trpgLightAttr::trpg_FogPunch ? "yes" : "no" ) );        buf.prnLine(ls);
+    sprintf(ls,"performer range mode enable Z buffer = %s",
+        (data.flags & trpgLightAttr::trpg_ZBuffer ? "yes" : "no" ) );        buf.prnLine(ls);
+    sprintf(ls,"performer maximum pixel size = %.2lf",
+        data.performerAttr.maxPixelSize );                                    buf.prnLine(ls);
+    sprintf(ls,"performer minimum pixel size = %.2lf",
+        data.performerAttr.minPixelSize );                                    buf.prnLine(ls);
+    sprintf(ls,"performer actual size = %.2lf",
+        data.performerAttr.actualSize );                                    buf.prnLine(ls);
+    sprintf(ls,"performer transparent pixel size = %.2lf",
+        data.performerAttr.transparentPixelSize );                            buf.prnLine(ls);
+    sprintf(ls,"performer transparent falloff exponent = %.2lf",
+        data.performerAttr.transparentFallofExp );                            buf.prnLine(ls);
+    sprintf(ls,"performer transparent scale = %.2lf",
+        data.performerAttr.transparentScale );                                buf.prnLine(ls);
+    sprintf(ls,"performer transparent clamp = %.2lf",
+        data.performerAttr.transparentClamp );                                buf.prnLine(ls);
+    sprintf(ls,"performer fog scale = %.2lf",
+        data.performerAttr.fogScale );                                        buf.prnLine(ls);
+    sprintf(ls,"animation period = %.2lf",data.animationAttr.period);        buf.prnLine(ls);
+    sprintf(ls,"animation phase delay = %.2lf",
+        data.animationAttr.phaseDelay );                                    buf.prnLine(ls);
+    sprintf(ls,"animation time on = %.2lf",data.animationAttr.timeOn);        buf.prnLine(ls);
+    sprintf(ls,"animation vector (ijk) = %.2lf, %.2lf, %.2lf",
+        data.animationAttr.vector.x,data.animationAttr.vector.y,
+        data.animationAttr.vector.z);                                        buf.prnLine(ls);
+    sprintf(ls,"animation - flashing = %s",
+        (data.flags & trpgLightAttr::trpg_Flashing ? "yes" : "no" ));        buf.prnLine(ls);
+    sprintf(ls,"animation - rotating = %s",
+        (data.flags & trpgLightAttr::trpg_Rotating ? "yes" : "no" ));        buf.prnLine(ls);
+    sprintf(ls,"animation - counter clockwise = %s",
+        (data.flags & trpgLightAttr::trpg_ClockWise ? "yes" : "no" ));        buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out light table
+ */
+bool trpgLightTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Light Table----");
+    buf.IncreaseIndent();
+    for (int i=0;i<lightList.size();i++) {
+        sprintf(ls,"Light %d",i); buf.prnLine(ls);
+        lightList[i].Print(buf);
+    }
+    buf.DecreaseIndent();
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out a light node
+*/
+
+bool trpgLight::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Light----");
+    buf.IncreaseIndent();
+
+    sprintf(ls,"Light Index = %d",index);                        buf.prnLine(ls);
+    sprintf(ls,"# Light Locations = %d",lightPoints.size() );    buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+
+    buf.prnLine();
+
+    return true;
+}
+
+/* Print out a single range
+ */
+
+bool trpgRange::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.IncreaseIndent();
+
+    sprintf(ls,"category = %s, subCategory = %s",category,subCategory);  buf.prnLine(ls);
+    sprintf(ls,"inLod = %f, outLod = %f",inLod,outLod);  buf.prnLine(ls);
+    sprintf(ls,"priority = %d",priority);  buf.prnLine(ls);
+
+    buf.DecreaseIndent();
+
+    return true;
+}
+
+/* Print out the whole range table
+ */
+
+bool trpgRangeTable::Print(trpgPrintBuffer &buf) const
+{
+    char ls[1024];
+
+    buf.prnLine("----Range Table----");
+    buf.IncreaseIndent();
+    for (int i=0;i<rangeList.size();i++) {
+        sprintf(ls,"----Range %d----",i);  buf.prnLine(ls);
+        rangeList[i].Print(buf);
+    }
+
+    buf.DecreaseIndent();
+
+    return true;
+}
diff --git a/src/osgPlugins/txp/trpage_print.h b/src/osgPlugins/txp/trpage_print.h
new file mode 100644
index 000000000..4f93645b7
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_print.h
@@ -0,0 +1,106 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+#ifndef trpage_print_h_
+#define trpage_print_h_
+
+#include "trpage_read.h"
+
+/* Print Buffer for TerraPage.  Subclasses of this object
+    are used to print out to stdout or disk (or whatever).
+    You won't create one of these directly, instead you'll create
+    something which inherits from it.
+ */
+TX_EXDECL class TX_CLDECL trpgPrintBuffer {
+public:
+    trpgPrintBuffer(void);
+    virtual ~trpgPrintBuffer(void) { };
+
+    // Check if print buffer is valid
+    virtual bool isValid(void) { return true; }
+
+    // The main print function.  Subclasses must fill this in.
+    virtual bool prnLine(char *str=NULL)=0;
+
+    // This increases the current indentation by the amount given (defaults to one)
+    virtual void IncreaseIndent(int amount=1);
+    // Decreases the current indentation by the amount given (defaults to one)
+    virtual void DecreaseIndent(int amount=1);
+protected:
+    void updateIndent(void);
+    int curIndent;
+    char indentStr[200];
+};
+
+/* File print buffer for TerraPage.  The file print buffer writes
+    debugging output to a file.
+ */
+TX_EXDECL class TX_CLDECL trpgFilePrintBuffer : public trpgPrintBuffer {
+public:
+    // This class can be constructed with either a FILE pointer or a file name
+    trpgFilePrintBuffer(FILE *);
+    trpgFilePrintBuffer(char *);
+    ~trpgFilePrintBuffer(void);
+
+    // Check if file print buffer is valid (i.e. if file was opened)
+    bool isValid(void) { return valid; };
+
+    // For a file printer buffer, this writes a string out to a file
+    bool prnLine(char *str = NULL);
+protected:
+    bool valid;
+    bool isMine;
+    FILE *fp;
+};
+
+/* The Print Graph Parser is a scene graph parser that
+    prints out the scene graph as it goes.  It's simpler
+    than the scene example in trpage_scene.cpp since it
+    isn't trying to build up a working scene graph.
+ */
+TX_EXDECL class TX_CLDECL trpgPrintGraphParser : public trpgSceneParser {
+public:
+    trpgPrintGraphParser(trpgPrintBuffer *);
+    virtual ~trpgPrintGraphParser(void) { };
+
+    /* The read helper class is the callback for all the various
+        token (node) types.  Normally we would use a number of
+        these, probably one per token.  However, since we're just
+        printing we can use a switch statement instead.
+     */
+    class ReadHelper : public trpgr_Callback {
+    public:
+        ReadHelper(trpgPrintBuffer *inBuf) {pBuf = inBuf;};
+        void *Parse(trpgToken,trpgReadBuffer &buf);
+    protected:
+        trpgPrintBuffer *pBuf;
+    };
+    
+protected:
+    bool StartChildren(void *);
+    bool EndChildren(void *);
+
+    trpgPrintBuffer *printBuf;
+};
+
+// Print utitility for while archive
+
+#define TRPGPRN_ALL -1
+#define TRPGPRN_HEADER (1<<0)
+#define TRPGPRN_BODY   (1<<1)
+TX_CPPDECL bool trpgPrintArchive(char *filename,trpgPrintBuffer &pBuf,int flags=TRPGPRN_ALL);
+TX_CPPDECL bool trpgPrintArchive(trpgr_Archive *,trpgPrintBuffer &pBuf,int flags=TRPGPRN_ALL);
+
+#endif
diff --git a/src/osgPlugins/txp/trpage_range.cpp b/src/osgPlugins/txp/trpage_range.cpp
new file mode 100644
index 000000000..14c35e06c
--- /dev/null
+++ b/src/osgPlugins/txp/trpage_range.cpp
@@ -0,0 +1,303 @@
+/* ************************
+   Copyright Terrain Experts Inc.
+   Terrain Experts Inc (TERREX) reserves all rights to this source code
+   unless otherwise specified in writing by the President of TERREX.
+   This copyright may be updated in the future, in which case that version
+   supercedes this one.
+   -------------------
+   Terrex Experts Inc.
+   4400 East Broadway #314
+   Tucson, AZ  85711
+   info@terrex.com
+   Tel: (520) 323-7990
+   ************************
+   */
+
+/* trpage_range.cpp
+    Methods for the Range Table.  Consult trpg_geom.h for details
+    on what this is and how it works.
+    */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "trpage_geom.h"
+#include "trpage_read.h"
+
+/* *******************
+    Range Methods
+   *******************
+ */
+
+trpgRange::trpgRange(void)
+{
+    category = NULL;
+    subCategory = NULL;
+    Reset();
+}
+
+trpgRange::~trpgRange(void)
+{
+    Reset();
+}
+
+trpgRange::trpgRange(const trpgRange &in)
+{
+    *this = in;
+}
+
+void trpgRange::Reset(void)
+{
+    if (category)
+        delete [] category;
+    category = NULL;
+    if (subCategory)
+        delete [] subCategory;
+    subCategory = NULL;
+
+    inLod = outLod = 0.0;
+    priority = 0;
+}
+
+void trpgRange::SetCategory(char *cat,char *subCat)
+{
+    if (category)  delete [] category;
+    category = NULL;
+    if (cat) {
+        category = new char[strlen(cat)+1];
+        strcpy(category,cat);
+    }
+
+    if (subCategory)  delete [] subCategory;
+    subCategory = NULL;
+    if (subCat) {
+        subCategory = new char[strlen(subCat)+1];
+        strcpy(subCategory,subCat);
+    }
+}
+
+void trpgRange::GetCategory(char *cat,int catLen,char *subCat,int subCatLen) const
+{
+    if (category && cat) {
+        strncpy(cat,category,catLen);
+    } else
+        *cat = 0;
+    if (subCategory && subCat) {
+        strncpy(subCat,subCategory,subCatLen);
+    } else
+        *subCat = 0;
+}
+
+void trpgRange::SetLodInfo(double in,double out)
+{
+    inLod = in;
+    outLod = out;
+}
+
+void trpgRange::GetLodInfo(double &in,double &out) const
+{
+    in = inLod;
+    out = outLod;
+}
+
+void trpgRange::SetPriority(int prior)
+{
+    priority = prior;
+}
+
+void trpgRange::GetPriority(int &prior) const
+{
+    prior = priority;
+}
+
+trpgRange & trpgRange::operator = (const trpgRange &other)
+{
+    Reset();
+    inLod = other.inLod;
+    outLod = other.outLod;
+    SetCategory(other.category,other.subCategory);
+    priority = other.priority;
+
+    return *this;
+}
+
+bool trpgRange::operator == (const trpgRange &in) const
+{
+    if (inLod != in.inLod || outLod != in.outLod)
+        return false;
+    if (priority != in.priority)  return false;
+
+    if (category && in.category) {
+        if (strcmp(category,in.category))
+            return false;
+    } else {
+        if (category && !in.category ||
+            !category && in.category)
+            return false;
+    }
+
+    if (subCategory && in.subCategory) {
+        if (strcmp(subCategory,in.subCategory))
+            return false;
+    } else {
+        if (subCategory && !in.subCategory ||
+            !subCategory && in.subCategory)
+            return false;
+    }
+
+    return true;
+}
+
+bool trpgRange::Write(trpgWriteBuffer &buf)
+{
+    buf.Begin(TRPG_RANGE);
+    buf.Add(inLod);
+    buf.Add(outLod);
+    buf.Add(priority);
+    buf.Add((category ? category : ""));
+    buf.Add((subCategory ? subCategory : ""));
+    buf.End();
+
+    return true;
+}
+
+bool trpgRange::Read(trpgReadBuffer &buf)
+{
+    char catStr[1024],subStr[1024];
+
+    Reset();
+    valid = false;
+
+    try {
+        buf.Get(inLod);
+        buf.Get(outLod);
+        buf.Get(priority);
+        buf.Get(catStr,1024);
+        buf.Get(subStr,1024);
+        SetCategory(catStr,subStr);
+        valid = true;
+    }
+
+    catch (...) {
+        return false;
+    }
+
+    return isValid();
+}
+
+/*  ***************
+    Range Table methods
+    ***************
+ */
+
+trpgRangeTable::trpgRangeTable(void)
+{
+    valid = true;
+}
+
+trpgRangeTable::~trpgRangeTable(void)
+{
+    // vector cleans up itself
+}
+
+void trpgRangeTable::Reset(void)
+{
+    rangeList.resize(0);
+    valid = true;
+}
+
+bool trpgRangeTable::GetRange(int id,trpgRange &ret) const
+{
+    if (!isValid())
+        return false;
+
+    if (id < 0 || id >= rangeList.size())
+        return false;
+
+    ret = rangeList[id];
+
+    return true;
+}
+
+bool trpgRangeTable::SetRange(int id,trpgRange &inRange)
+{
+    if (!isValid())
+        return false;
+
+    if (id < 0 || id >= rangeList.size())
+        return false;
+
+    rangeList[id] = inRange;
+
+    return true;
+}
+
+int trpgRangeTable::AddRange(trpgRange &range)
+{
+    rangeList.push_back(range);
+
+    return rangeList.size()-1;
+}
+
+int trpgRangeTable::FindAddRange(trpgRange &range)
+{
+    for (int i=0;i<rangeList.size();i++) {
+        if (range == rangeList[i])
+            return i;
+    }
+
+    return AddRange(range);
+}
+
+bool trpgRangeTable::Write(trpgWriteBuffer &buf)
+{
+    if (!isValid())
+        return false;
+
+    buf.Begin(TRPGRANGETABLE);
+    buf.Add((int32)rangeList.size());
+
+    for (int i=0;i<rangeList.size();i++) {
+        trpgRange &range = rangeList[i];
+        range.Write(buf);
+    }
+
+    buf.End();
+
+    return true;
+}
+
+bool trpgRangeTable::Read(trpgReadBuffer &buf)
+{
+    int32 numRange;
+    valid = false;
+
+    try {
+        buf.Get(numRange);
+        if (numRange < 0) throw 1;
+        for (int i=0;i<numRange;i++) {
+            trpgRange range;
+            if (!range.Read(buf)) throw 1;
+            rangeList.push_back(range);
+        }
+
+        valid = true;
+    }
+
+    catch (...) {
+        return false;
+    }
+
+    return isValid();
+}
+
+trpgRangeTable & trpgRangeTable::operator = (const trpgRangeTable &inTab)
+{
+    Reset();
+
+    for (int i=0;i<inTab.rangeList.size();i++)
+        rangeList.push_back(rangeList[i]);
+
+    return *this;
+}