home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 March / Gamestar_82_2006-03_dvd.iso / DVDStar / Editace / quake4_sdkv10.exe / source / idlib / mapfile.cpp < prev    next >
C/C++ Source or Header  |  2005-11-14  |  34KB  |  1,367 lines
  1.  
  2. #include "precompiled.h"
  3. #pragma hdrstop
  4.  
  5. #ifdef _XENON
  6. #define PACIFIER_UPDATE session->PacifierUpdate()
  7. #else
  8. #define PACIFIER_UPDATE
  9. #endif
  10.  
  11.  
  12. /*
  13. ===============
  14. FloatCRC
  15. ===============
  16. */
  17. ID_INLINE unsigned int FloatCRC( float f ) {
  18.     return *(unsigned int *)&f;
  19. }
  20.  
  21. /*
  22. ===============
  23. StringCRC
  24. ===============
  25. */
  26. ID_INLINE unsigned int StringCRC( const char *str ) {
  27.     unsigned int i, crc;
  28.     const unsigned char *ptr;
  29.  
  30.     crc = 0;
  31.     ptr = reinterpret_cast<const unsigned char*>(str);
  32.     for ( i = 0; str[i]; i++ ) {
  33.         crc ^= str[i] << (i & 3);
  34.     }
  35.     return crc;
  36. }
  37.  
  38. /*
  39. =================
  40. ComputeAxisBase
  41.  
  42. WARNING : special case behaviour of atan2(y,x) <-> atan(y/x) might not be the same everywhere when x == 0
  43. rotation by (0,RotY,RotZ) assigns X to normal
  44. =================
  45. */
  46. static void ComputeAxisBase( const idVec3 &normal, idVec3 &texS, idVec3 &texT ) {
  47.     float RotY, RotZ;
  48.     idVec3 n;
  49.  
  50.     // do some cleaning
  51.     n[0] = ( idMath::Fabs( normal[0] ) < 1e-6f ) ? 0.0f : normal[0];
  52.     n[1] = ( idMath::Fabs( normal[1] ) < 1e-6f ) ? 0.0f : normal[1];
  53.     n[2] = ( idMath::Fabs( normal[2] ) < 1e-6f ) ? 0.0f : normal[2];
  54.  
  55.     RotY = -idMath::ATan( n[2], idMath::Sqrt( n[1] * n[1] + n[0] * n[0]) );
  56.     RotZ = idMath::ATan( n[1], n[0] );
  57.     // rotate (0,1,0) and (0,0,1) to compute texS and texT
  58. // RAVEN BEGIN
  59. // jscott: routed thru idMath
  60.     texS[0] = -idMath::Sin( RotZ );
  61.     texS[1] = idMath::Cos( RotZ );
  62.     texS[2] = 0;
  63.     // the texT vector is along -Z ( T texture coorinates axis )
  64.     texT[0] = -idMath::Sin( RotY ) * idMath::Cos( RotZ );
  65.     texT[1] = -idMath::Sin( RotY ) * idMath::Sin( RotZ );
  66.     texT[2] = -idMath::Cos( RotY );
  67. // RAVEN END
  68. }
  69.  
  70. // RAVEN BEGIN
  71. // rhummer: Trying to debug why func_groups disappear when editing a map when they shouldn't.
  72. idMapFile::~idMapFile( void ) 
  73. { 
  74.     entities.DeleteContents( true ); 
  75.     if ( cvarSystem->GetCVarBool( "developer" ) ) {
  76.         common->Printf( "^2done with .map file ^0%s\n", name.c_str() );
  77.     }
  78. }
  79. // RAVEN END
  80.  
  81. /*
  82. =================
  83. idMapBrushSide::GetTextureVectors
  84. =================
  85. */
  86. void idMapBrushSide::GetTextureVectors( idVec4 v[2] ) const {
  87.     int i;
  88.     idVec3 texX, texY;
  89.  
  90.     ComputeAxisBase( plane.Normal(), texX, texY );
  91.     for ( i = 0; i < 2; i++ ) {
  92.         v[i][0] = texX[0] * texMat[i][0] + texY[0] * texMat[i][1];
  93.         v[i][1] = texX[1] * texMat[i][0] + texY[1] * texMat[i][1];
  94.         v[i][2] = texX[2] * texMat[i][0] + texY[2] * texMat[i][1];
  95.         v[i][3] = texMat[i][2] + ( origin * v[i].ToVec3() );
  96.     }
  97. }
  98.  
  99. /*
  100. =================
  101. idMapPatch::Parse
  102. =================
  103. */
  104. // RAVEN BEGIN
  105. // jsinger: changed to be Lexer instead of idLexer so that we have the ability to read binary files
  106. idMapPatch *idMapPatch::Parse( Lexer &src, const idVec3 &origin, bool patchDef3, int version ) {
  107. // RAVEN END
  108.     
  109.     TIME_THIS_SCOPE( __FUNCLINE__);    
  110.     
  111.     float        info[7];
  112.     idDrawVert *vert;
  113.     idToken        token;
  114.     int            i, j;
  115.  
  116.     if ( !src.ExpectTokenString( "{" ) ) {
  117.         return NULL;
  118.     }
  119.  
  120.     // read the material (we had an implicit 'textures/' in the old format...)
  121.     if ( !src.ReadToken( &token ) ) {
  122.         src.Error( "idMapPatch::Parse: unexpected EOF" );
  123.         return NULL;
  124.     }
  125.  
  126.     // Parse it
  127.     if (patchDef3) {
  128.         if ( !src.Parse1DMatrix( 7, info ) ) {
  129.             src.Error( "idMapPatch::Parse: unable to Parse patchDef3 info" );
  130.             return NULL;
  131.         }
  132.     } else {
  133.         if ( !src.Parse1DMatrix( 5, info ) ) {
  134.             src.Error( "idMapPatch::Parse: unable to parse patchDef2 info" );
  135.             return NULL;
  136.         }
  137.     }
  138.  
  139.     idMapPatch *patch = new idMapPatch( info[0], info[1] );
  140.     patch->SetSize( info[0], info[1] );
  141.     if ( version < 2 ) {
  142.         patch->SetMaterial( "textures/" + token );
  143.     } else {
  144.         patch->SetMaterial( token );
  145.     }
  146.  
  147.     if ( patchDef3 ) {
  148.         patch->SetHorzSubdivisions( info[2] );
  149.         patch->SetVertSubdivisions( info[3] );
  150.         patch->SetExplicitlySubdivided( true );
  151.     }
  152.  
  153.     if ( patch->GetWidth() < 0 || patch->GetHeight() < 0 ) {
  154.         src.Error( "idMapPatch::Parse: bad size" );
  155.         delete patch;
  156.         return NULL;
  157.     }
  158.  
  159.     // these were written out in the wrong order, IMHO
  160.     if ( !src.ExpectTokenString( "(" ) ) {
  161.         src.Error( "idMapPatch::Parse: bad patch vertex data" );
  162.         delete patch;
  163.         return NULL;
  164.     }
  165.     for ( j = 0; j < patch->GetWidth(); j++ ) {
  166.         if ( !src.ExpectTokenString( "(" ) ) {
  167.             src.Error( "idMapPatch::Parse: bad vertex row data" );
  168.             delete patch;
  169.             return NULL;
  170.         }
  171.         for ( i = 0; i < patch->GetHeight(); i++ ) {
  172.             float v[5];
  173.  
  174.             if ( !src.Parse1DMatrix( 5, v ) ) {
  175.                 src.Error( "idMapPatch::Parse: bad vertex column data" );
  176.                 delete patch;
  177.                 return NULL;
  178.             }
  179.  
  180.             vert = &((*patch)[i * patch->GetWidth() + j]);
  181.             vert->xyz[0] = v[0] - origin[0];
  182.             vert->xyz[1] = v[1] - origin[1];
  183.             vert->xyz[2] = v[2] - origin[2];
  184.             vert->st[0] = v[3];
  185.             vert->st[1] = v[4];
  186.         }
  187.         if ( !src.ExpectTokenString( ")" ) ) {
  188.             delete patch;
  189.             src.Error( "idMapPatch::Parse: unable to parse patch control points" );
  190.             return NULL;
  191.         }
  192.     }
  193.     if ( !src.ExpectTokenString( ")" ) ||
  194.             !src.ExpectTokenString( "}" ) ||
  195.                 !src.ExpectTokenString( "}" ) ) {
  196.         src.Error( "idMapPatch::Parse: unable to parse patch control points, no closure" );
  197.         delete patch;
  198.         return NULL;
  199.     }
  200.  
  201.     return patch;
  202. }
  203.  
  204. /*
  205. ============
  206. idMapPatch::Write
  207. ============
  208. */
  209. bool idMapPatch::Write( idFile *fp, int primitiveNum, const idVec3 &origin ) const {
  210.     int i, j;
  211.     const idDrawVert *v;
  212.  
  213.     if ( GetExplicitlySubdivided() ) {
  214.         fp->WriteFloatString( "// primitive %d\n{\n patchDef3\n {\n", primitiveNum );
  215.         fp->WriteFloatString( "  \"%s\"\n  ( %d %d %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight(), GetHorzSubdivisions(), GetVertSubdivisions());
  216.     } else {
  217.         fp->WriteFloatString( "// primitive %d\n{\n patchDef2\n {\n", primitiveNum );
  218.         fp->WriteFloatString( "  \"%s\"\n  ( %d %d 0 0 0 )\n", GetMaterial(), GetWidth(), GetHeight());
  219.     }
  220.  
  221.     fp->WriteFloatString( "  (\n" );
  222.     for ( i = 0; i < GetWidth(); i++ ) {
  223.         fp->WriteFloatString( "   ( " );
  224.         for ( j = 0; j < GetHeight(); j++ ) {
  225.             v = &verts[ j * GetWidth() + i ];
  226.             fp->WriteFloatString( " ( %f %f %f %f %f )", v->xyz[0] + origin[0],
  227.                                 v->xyz[1] + origin[1], v->xyz[2] + origin[2], v->st[0], v->st[1] );
  228.         }
  229.         fp->WriteFloatString( " )\n" );
  230.     }
  231.     fp->WriteFloatString( "  )\n }\n}\n" );
  232.  
  233.     return true;
  234. }
  235.  
  236. // RAVEN BEGIN
  237. // rjohnson: added resolve for handling func_groups and other aspects.  Before, radiant would do this processing on a map destroying the original data
  238. /*
  239. ===============
  240. idMapPatch::AdjustOrigin
  241. ===============
  242. */
  243. void idMapPatch::AdjustOrigin( idVec3 &delta ) {
  244.     TranslateSelf( delta );
  245. }
  246. // RAVEN END
  247.  
  248. /*
  249. ===============
  250. idMapPatch::GetGeometryCRC
  251. ===============
  252. */
  253. unsigned int idMapPatch::GetGeometryCRC( void ) const {
  254.     int i, j;
  255.     unsigned int crc;
  256.  
  257.     crc = GetHorzSubdivisions() ^ GetVertSubdivisions();
  258.     for ( i = 0; i < GetWidth(); i++ ) {
  259.         for ( j = 0; j < GetHeight(); j++ ) {
  260.             crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.x );
  261.             crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.y );
  262.             crc ^= FloatCRC( verts[j * GetWidth() + i].xyz.z );
  263.         }
  264.     }
  265.  
  266.     crc ^= StringCRC( GetMaterial() );
  267.  
  268.     return crc;
  269. }
  270.  
  271. /*
  272. =================
  273. idMapBrush::Parse
  274. =================
  275. */
  276. // RAVEN BEGIN
  277. // jsinger: changed to be Lexer instead of idLexer so that we have the ability to read binary files
  278. idMapBrush *idMapBrush::Parse( Lexer &src, const idVec3 &origin, bool newFormat, int version ) {
  279. // RAVEN END
  280.     
  281.     TIME_THIS_SCOPE( __FUNCLINE__);    
  282.     
  283.     int i;
  284.     idVec3 planepts[3];
  285.     idToken token;
  286.     idList<idMapBrushSide*> sides;
  287.     idMapBrushSide    *side;
  288.     idDict epairs;
  289.  
  290.     if ( !src.ExpectTokenString( "{" ) ) {
  291.         return NULL;
  292.     }
  293.  
  294.     do {
  295.         if ( !src.ReadToken( &token ) ) {
  296.             src.Error( "idMapBrush::Parse: unexpected EOF" );
  297.             sides.DeleteContents( true );
  298.             return NULL;
  299.         }
  300.         if ( token == "}" ) {
  301.             break;
  302.         }
  303.  
  304.         // here we may have to jump over brush epairs ( only used in editor )
  305.         do {
  306.             // if token is a brace
  307.             if ( token == "(" ) {
  308.                 break;
  309.             }
  310.             // the token should be a key string for a key/value pair
  311.             if ( token.type != TT_STRING ) {
  312.                 src.Error( "idMapBrush::Parse: unexpected %s, expected ( or epair key string", token.c_str() );
  313.                 sides.DeleteContents( true );
  314.                 return NULL;
  315.             }
  316.  
  317.             idStr key = token;
  318.  
  319.             if ( !src.ReadTokenOnLine( &token ) || token.type != TT_STRING ) {
  320.                 src.Error( "idMapBrush::Parse: expected epair value string not found" );
  321.                 sides.DeleteContents( true );
  322.                 return NULL;
  323.             }
  324.  
  325.             epairs.Set( key, token );
  326.  
  327.             // try to read the next key
  328.             if ( !src.ReadToken( &token ) ) {
  329.                 src.Error( "idMapBrush::Parse: unexpected EOF" );
  330.                 sides.DeleteContents( true );
  331.                 return NULL;
  332.             }
  333.         } while (1);
  334.  
  335.         src.UnreadToken( &token );
  336.  
  337.         side = new idMapBrushSide();
  338.         sides.Append(side);
  339.  
  340.         if ( newFormat ) {
  341.             if ( !src.Parse1DMatrix( 4, side->plane.ToFloatPtr() ) ) {
  342.                 src.Error( "idMapBrush::Parse: unable to read brush side plane definition" );
  343.                 sides.DeleteContents( true );
  344.                 return NULL;
  345.             }
  346.         } else {
  347.             // read the three point plane definition
  348.             if (!src.Parse1DMatrix( 3, planepts[0].ToFloatPtr() ) ||
  349.                 !src.Parse1DMatrix( 3, planepts[1].ToFloatPtr() ) ||
  350.                 !src.Parse1DMatrix( 3, planepts[2].ToFloatPtr() ) ) {
  351.                 src.Error( "idMapBrush::Parse: unable to read brush side plane definition" );
  352.                 sides.DeleteContents( true );
  353.                 return NULL;
  354.             }
  355.  
  356.             planepts[0] -= origin;
  357.             planepts[1] -= origin;
  358.             planepts[2] -= origin;
  359.  
  360.             side->plane.FromPoints( planepts[0], planepts[1], planepts[2] );
  361.         }
  362.  
  363.         // read the texture matrix
  364.         // this is odd, because the texmat is 2D relative to default planar texture axis
  365.         if ( !src.Parse2DMatrix( 2, 3, side->texMat[0].ToFloatPtr() ) ) {
  366.             src.Error( "idMapBrush::Parse: unable to read brush side texture matrix" );
  367.             sides.DeleteContents( true );
  368.             return NULL;
  369.         }
  370.         side->origin = origin;
  371.         
  372.         // read the material
  373.         if ( !src.ReadTokenOnLine( &token ) ) {
  374.             src.Error( "idMapBrush::Parse: unable to read brush side material" );
  375.             sides.DeleteContents( true );
  376.             return NULL;
  377.         }
  378.  
  379.         // we had an implicit 'textures/' in the old format...
  380.         if ( version < 2 ) {
  381.             side->material = "textures/" + token;
  382.         } else {
  383.             side->material = token;
  384.         }
  385.  
  386. // RAVEN BEGIN
  387. // jscott: make sure the material is properly parsed
  388.         declManager->FindMaterial( token );
  389. // RAVEN END
  390.  
  391. // RAVEN BEGIN
  392. // jscott: removed these in later versions
  393.         if( version < 3 ) {
  394. // RAVEN END
  395.             // Q2 allowed override of default flags and values, but we don't any more
  396.             if ( src.ReadTokenOnLine( &token ) ) {
  397.                 if ( src.ReadTokenOnLine( &token ) ) {
  398.                     if ( src.ReadTokenOnLine( &token ) ) {
  399.                     }
  400.                 }
  401.             }
  402.         }
  403.     } while( 1 );
  404.  
  405.     if ( !src.ExpectTokenString( "}" ) ) {
  406.         sides.DeleteContents( true );
  407.         return NULL;
  408.     }
  409.  
  410.     idMapBrush *brush = new idMapBrush();
  411.     for ( i = 0; i < sides.Num(); i++ ) {
  412.         brush->AddSide( sides[i] );
  413.     }
  414.  
  415.     brush->epairs = epairs;
  416.  
  417.     return brush;
  418. }
  419.  
  420. /*
  421. =================
  422. idMapBrush::ParseQ3
  423. =================
  424. */
  425. // RAVEN BEGIN
  426. // jsinger: changed to be Lexer instead of idLexer so that we have the ability to read binary files
  427. idMapBrush *idMapBrush::ParseQ3( Lexer &src, const idVec3 &origin ) {
  428. // RAVEN END
  429.     int i, shift[2], rotate;
  430.     float scale[2];
  431.     idVec3 planepts[3];
  432.     idToken token;
  433.     idList<idMapBrushSide*> sides;
  434.     idMapBrushSide    *side;
  435.     idDict epairs;
  436.  
  437.     do {
  438.         if ( src.CheckTokenString( "}" ) ) {
  439.             break;
  440.         }
  441.  
  442.         side = new idMapBrushSide();
  443.         sides.Append( side );
  444.  
  445.         // read the three point plane definition
  446.         if (!src.Parse1DMatrix( 3, planepts[0].ToFloatPtr() ) ||
  447.             !src.Parse1DMatrix( 3, planepts[1].ToFloatPtr() ) ||
  448.             !src.Parse1DMatrix( 3, planepts[2].ToFloatPtr() ) ) {
  449.             src.Error( "idMapBrush::ParseQ3: unable to read brush side plane definition" );
  450.             sides.DeleteContents( true );
  451.             return NULL;
  452.         }
  453.  
  454.         planepts[0] -= origin;
  455.         planepts[1] -= origin;
  456.         planepts[2] -= origin;
  457.  
  458.         side->plane.FromPoints( planepts[0], planepts[1], planepts[2] );
  459.  
  460.         // read the material
  461.         if ( !src.ReadTokenOnLine( &token ) ) {
  462.             src.Error( "idMapBrush::ParseQ3: unable to read brush side material" );
  463.             sides.DeleteContents( true );
  464.             return NULL;
  465.         }
  466.  
  467.         // we have an implicit 'textures/' in the old format
  468.         side->material = "textures/" + token;
  469.  
  470.         // read the texture shift, rotate and scale
  471.         shift[0] = src.ParseInt();
  472.         shift[1] = src.ParseInt();
  473.         rotate = src.ParseInt();
  474.         scale[0] = src.ParseFloat();
  475.         scale[1] = src.ParseFloat();
  476.         side->texMat[0] = idVec3( 0.03125f, 0.0f, 0.0f );
  477.         side->texMat[1] = idVec3( 0.0f, 0.03125f, 0.0f );
  478.         side->origin = origin;
  479.         
  480.         // Q2 allowed override of default flags and values, but we don't any more
  481.         if ( src.ReadTokenOnLine( &token ) ) {
  482.             if ( src.ReadTokenOnLine( &token ) ) {
  483.                 if ( src.ReadTokenOnLine( &token ) ) {
  484.                 }
  485.             }
  486.         }
  487.     } while( 1 );
  488.  
  489.     idMapBrush *brush = new idMapBrush();
  490.     for ( i = 0; i < sides.Num(); i++ ) {
  491.         brush->AddSide( sides[i] );
  492.     }
  493.  
  494.     brush->epairs = epairs;
  495.  
  496.     return brush;
  497. }
  498.  
  499. /*
  500. ============
  501. idMapBrush::Write
  502. ============
  503. */
  504. bool idMapBrush::Write( idFile *fp, int primitiveNum, const idVec3 &origin ) const {
  505.     int i;
  506.     idMapBrushSide *side;
  507.  
  508.     fp->WriteFloatString( "// primitive %d\n{\n brushDef3\n {\n", primitiveNum );
  509.  
  510.     // write brush epairs
  511.     for ( i = 0; i < epairs.GetNumKeyVals(); i++) {
  512.         fp->WriteFloatString( "  \"%s\" \"%s\"\n", epairs.GetKeyVal(i)->GetKey().c_str(), epairs.GetKeyVal(i)->GetValue().c_str());
  513.     }
  514.  
  515.     // write brush sides
  516.     for ( i = 0; i < GetNumSides(); i++ ) {
  517.         side = GetSide( i );
  518.         fp->WriteFloatString( "  ( %f %f %f %f ) ", side->plane[0], side->plane[1], side->plane[2], side->plane[3] );
  519. // RAVEN BEGIN
  520.         fp->WriteFloatString( "( ( %f %f %f ) ( %f %f %f ) ) \"%s\"\n",
  521. // RAVEN END
  522.                             side->texMat[0][0], side->texMat[0][1], side->texMat[0][2],
  523.                                 side->texMat[1][0], side->texMat[1][1], side->texMat[1][2],
  524.                                     side->material.c_str() );
  525.     }
  526.  
  527.     fp->WriteFloatString( " }\n}\n" );
  528.  
  529.     return true;
  530. }
  531.  
  532. /*
  533. ===============
  534. idMapBrush::GetGeometryCRC
  535. ===============
  536. */
  537. unsigned int idMapBrush::GetGeometryCRC( void ) const {
  538.     int i, j;
  539.     idMapBrushSide *mapSide;
  540.     unsigned int crc;
  541.  
  542.     crc = 0;
  543.     for ( i = 0; i < GetNumSides(); i++ ) {
  544.         mapSide = GetSide(i);
  545.         for ( j = 0; j < 4; j++ ) {
  546.             crc ^= FloatCRC( mapSide->GetPlane()[j] );
  547.         }
  548.         crc ^= StringCRC( mapSide->GetMaterial() );
  549.     }
  550.  
  551.     return crc;
  552. }
  553.  
  554. // RAVEN BEGIN
  555. // rjohnson: added resolve for handling func_groups and other aspects.  Before, radiant would do this processing on a map destroying the original data
  556.  
  557. // This is taken from tools/radiant/EditorBrushPrimit.cpp
  558. float SarrusDet(idVec3 a, idVec3 b, idVec3 c) {
  559.     return (float)a[0] * (float)b[1] * (float)c[2] + (float)b[0] * (float)c[1] * (float)a[2] + (float)c[0] * (float)a[1] * (float)b[2] - (float)c[0] * (float)b[1] * (float)a[2] - (float)a[1] * (float)b[0] * (float)c[2] -    (float)a[0] * (float)b[2] * (float)c[1];
  560. }
  561.  
  562. /*
  563. ===============
  564. idMapBrush::AdjustOrigin
  565. ===============
  566. */
  567. void idMapBrush::AdjustOrigin( idVec3 &delta ) {
  568.     int                i;
  569.     idMapBrushSide    *mapSide;
  570.  
  571.     for ( i = 0; i < GetNumSides(); i++ ) {
  572.         mapSide = GetSide(i);
  573.  
  574.         mapSide->SetPlane( mapSide->GetPlane().Translate( delta ) );
  575.  
  576.         // This is taken from Face_MoveTexture_BrushPrimit() in tools/radiant/EditorBrushPrimit.cpp
  577.         idVec3    texS, texT;
  578.         float    tx, ty;
  579.         idVec3    M[3];    // columns of the matrix .. easier that way
  580.         float    det;
  581.         idVec3    D[2];
  582.  
  583.         // compute plane axis base ( doesn't change with translation )
  584.         ComputeAxisBase( mapSide->GetPlane().Normal(), texS, texT);
  585.  
  586.         // compute translation vector in plane axis base
  587.         tx = DotProduct(delta, texS);
  588.         ty = DotProduct(delta, texT);
  589.  
  590.         // fill the data vectors
  591.         M[0][0] = tx;
  592.         M[0][1] = 1.0f + tx;
  593.         M[0][2] = tx;
  594.         M[1][0] = ty;
  595.         M[1][1] = ty;
  596.         M[1][2] = 1.0f + ty;
  597.         M[2][0] = 1.0f;
  598.         M[2][1] = 1.0f;
  599.         M[2][2] = 1.0f;
  600.  
  601.         idVec3    tm[2];
  602.         mapSide->GetTextureMatrix( tm[0], tm[1] );
  603.  
  604.         D[0][0] = tm[0][2];
  605.         D[0][1] = tm[0][0] + tm[0][2];
  606.         D[0][2] = tm[0][1] + tm[0][2];
  607.         D[1][0] = tm[1][2];
  608.         D[1][1] = tm[1][0] + tm[1][2];
  609.         D[1][2] = tm[1][1] + tm[1][2];
  610.  
  611.         // solve
  612.         det = SarrusDet(M[0], M[1], M[2]);
  613.         if ( det != 0. ) {
  614.             tm[0][0] = SarrusDet(D[0], M[1], M[2]) / det;
  615.             tm[0][1] = SarrusDet(M[0], D[0], M[2]) / det;
  616.             tm[0][2] = SarrusDet(M[0], M[1], D[0]) / det;
  617.             tm[1][0] = SarrusDet(D[1], M[1], M[2]) / det;
  618.             tm[1][1] = SarrusDet(M[0], D[1], M[2]) / det;
  619.             tm[1][2] = SarrusDet(M[0], M[1], D[1]) / det;
  620.             mapSide->SetTextureMatrix(tm);
  621.         }
  622.     }
  623. }
  624. // RAVEN END
  625.  
  626. /*
  627. ================
  628. idMapEntity::Parse
  629. ================
  630. */
  631. // RAVEN BEGIN
  632. // jsinger: changed to be Lexer instead of idLexer so that we have the ability to read binary files
  633. idMapEntity *idMapEntity::Parse( Lexer &src, bool worldSpawn, int version ) {
  634. // RAVEN END
  635.     
  636.     TIME_THIS_SCOPE( __FUNCLINE__);    
  637.     
  638.     idToken    token;
  639.     idMapEntity *mapEnt;
  640.     idMapPatch *mapPatch;
  641.     idMapBrush *mapBrush;
  642.     bool worldent;
  643.     idVec3 origin;
  644.     double v1, v2, v3;
  645.  
  646.     if ( !src.ReadToken(&token) ) {
  647.         return NULL;
  648.     }
  649.  
  650.     if ( token != "{" ) {
  651.         src.Error( "idMapEntity::Parse: { not found, found %s", token.c_str() );
  652.         return NULL;
  653.     }
  654.  
  655.     mapEnt = new idMapEntity();
  656.  
  657.     if ( worldSpawn ) {
  658.         mapEnt->primitives.Resize( 1024, 256 );
  659.     }
  660.  
  661.     origin.Zero();
  662.     worldent = false;
  663.     do {
  664.         if ( !src.ReadToken(&token) ) {
  665.             src.Error( "idMapEntity::Parse: EOF without closing brace" );
  666.             return NULL;
  667.         }
  668.         if ( token == "}" ) {
  669.             break;
  670.         }
  671.  
  672.         if ( token == "{" ) {
  673.             // parse a brush or patch
  674.             if ( !src.ReadToken( &token ) ) {
  675.                 src.Error( "idMapEntity::Parse: unexpected EOF" );
  676.                 return NULL;
  677.             }
  678.  
  679.             if ( worldent ) {
  680.                 origin.Zero();
  681.             }
  682.  
  683.             // if is it a brush: brush, brushDef, brushDef2, brushDef3
  684.             if ( token.Icmpn( "brush", 5 ) == 0 ) {
  685.                 mapBrush = idMapBrush::Parse( src, origin, ( !token.Icmp( "brushDef2" ) || !token.Icmp( "brushDef3" ) ), version );
  686.                 if ( !mapBrush ) {
  687.                     return NULL;
  688.                 }
  689.                 mapEnt->AddPrimitive( mapBrush );
  690.             }
  691.             // if is it a patch: patchDef2, patchDef3
  692.             else if ( token.Icmpn( "patch", 5 ) == 0 ) {
  693.                 mapPatch = idMapPatch::Parse( src, origin, !token.Icmp( "patchDef3" ), version );
  694.                 if ( !mapPatch ) {
  695.                     return NULL;
  696.                 }
  697.                 mapEnt->AddPrimitive( mapPatch );
  698.             }
  699.             // assume it's a brush in Q3 or older style
  700.             else {
  701.                 src.UnreadToken( &token );
  702.                 mapBrush = idMapBrush::ParseQ3( src, origin );
  703.                 if ( !mapBrush ) {
  704.                     return NULL;
  705.                 }
  706.                 mapEnt->AddPrimitive( mapBrush );
  707.             }
  708.         } else {
  709.             idStr key, value;
  710.  
  711.             // parse a key / value pair
  712.             key = token;
  713.             src.ReadTokenOnLine( &token );
  714.             value = token;
  715.  
  716.             // strip trailing spaces that sometimes get accidentally
  717.             // added in the editor
  718.             value.StripTrailingWhitespace();
  719.             key.StripTrailingWhitespace();
  720.  
  721.             mapEnt->epairs.Set( key, value );
  722.  
  723.             if ( !idStr::Icmp( key, "origin" ) ) {
  724.                 // scanf into doubles, then assign, so it is idVec size independent
  725.                 v1 = v2 = v3 = 0;
  726.                 sscanf( value, "%lf %lf %lf", &v1, &v2, &v3 );
  727.                 origin.x = v1;
  728.                 origin.y = v2;
  729.                 origin.z = v3;
  730.             }
  731.             else if ( !idStr::Icmp( key, "classname" ) && !idStr::Icmp( value, "worldspawn" ) ) {
  732.                 worldent = true;
  733.             }
  734.         }
  735.     } while( 1 );
  736.  
  737.     return mapEnt;
  738. }
  739.  
  740. /*
  741. ============
  742. idMapEntity::Write
  743. ============
  744. */
  745. bool idMapEntity::Write( idFile *fp, int entityNum ) const {
  746.     int i;
  747.     idMapPrimitive *mapPrim;
  748.     idVec3 origin;
  749.  
  750.     fp->WriteFloatString( "// entity %d\n{\n", entityNum );
  751.  
  752.     // write entity epairs
  753.     for ( i = 0; i < epairs.GetNumKeyVals(); i++) {
  754.         fp->WriteFloatString( "\"%s\" \"%s\"\n", epairs.GetKeyVal(i)->GetKey().c_str(), epairs.GetKeyVal(i)->GetValue().c_str());
  755.     }
  756.  
  757.     epairs.GetVector( "origin", "0 0 0", origin );
  758.  
  759.     // write pritimives
  760.     for ( i = 0; i < GetNumPrimitives(); i++ ) {
  761.         mapPrim = GetPrimitive( i );
  762.  
  763.         switch( mapPrim->GetType() ) {
  764.             case idMapPrimitive::TYPE_BRUSH:
  765.                 static_cast<idMapBrush*>(mapPrim)->Write( fp, i, origin );
  766.                 break;
  767.             case idMapPrimitive::TYPE_PATCH:
  768.                 static_cast<idMapPatch*>(mapPrim)->Write( fp, i, origin );
  769.                 break;
  770.         }
  771.     }
  772.  
  773.     fp->WriteFloatString( "}\n" );
  774.  
  775.     return true;
  776. }
  777.  
  778. /*
  779. ===============
  780. idMapEntity::RemovePrimitiveData
  781. ===============
  782. */
  783. void idMapEntity::RemovePrimitiveData() {
  784.     primitives.DeleteContents(true);
  785. }
  786.  
  787. /*
  788. ===============
  789. idMapEntity::GetGeometryCRC
  790. ===============
  791. */
  792. unsigned int idMapEntity::GetGeometryCRC( void ) const {
  793.     int i;
  794.     unsigned int crc;
  795.     idMapPrimitive    *mapPrim;
  796.  
  797.     crc = 0;
  798.     for ( i = 0; i < GetNumPrimitives(); i++ ) {
  799.         mapPrim = GetPrimitive( i );
  800.  
  801.         switch( mapPrim->GetType() ) {
  802.             case idMapPrimitive::TYPE_BRUSH:
  803.                 crc ^= static_cast<idMapBrush*>(mapPrim)->GetGeometryCRC();
  804.                 if ( epairs.GetString( "model" ) ) {
  805.                     crc ^= StringCRC( epairs.GetString( "model" ) );
  806.                 }
  807.                 break;
  808.             case idMapPrimitive::TYPE_PATCH:
  809.                 crc ^= static_cast<idMapPatch*>(mapPrim)->GetGeometryCRC();
  810.                 if ( epairs.GetString( "model" ) ) {
  811.                     crc ^= StringCRC( epairs.GetString( "model" ) );
  812.                 }
  813.                 break;
  814.         }
  815.     }
  816.  
  817.     return crc;
  818. }
  819.  
  820. /*
  821. ===============
  822. idMapFile::Parse
  823. ===============
  824. */
  825. bool idMapFile::Parse( const char *filename, bool ignoreRegion, bool osPath ) {
  826.     // no string concatenation for epairs and allow path names for materials
  827. // RAVEN BEGIN
  828. // jsinger: Done this way to reduce the amount of code change.  The auto pointer will
  829. // delete the lexer when this method exits
  830.     idAutoPtr<Lexer> lexer(LexerFactory::MakeLexer( LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES ));
  831.     Lexer &src(*lexer);
  832. // RAVEN END
  833.     idToken token;
  834.     idStr fullName;
  835.     idMapEntity *mapEnt;
  836.     
  837.     TIME_THIS_SCOPE( __FUNCLINE__);    
  838.  
  839.     name = filename;
  840.     name.StripFileExtension();
  841.     fullName = name;
  842.     hasPrimitiveData = false;
  843.  
  844.     if ( !ignoreRegion ) {
  845.         // try loading a .reg file first
  846.         fullName.SetFileExtension( "reg" );
  847.         src.LoadFile( fullName, osPath );
  848.     }
  849.  
  850.     if ( !src.IsLoaded() ) {
  851.  
  852.         PACIFIER_UPDATE;
  853.         
  854.         // now try a .map file
  855.         fullName.SetFileExtension( "map" );
  856.         src.LoadFile( fullName, osPath );
  857.  
  858.         if ( !src.IsLoaded() ) {
  859.             // didn't get anything at all
  860.             return false;
  861.         }
  862.     }
  863.  
  864.     version = OLD_MAP_VERSION;
  865.     fileTime = src.GetFileTime();
  866.     entities.DeleteContents( true );
  867.  
  868.     if ( src.CheckTokenString( "Version" ) ) {
  869.         src.ReadTokenOnLine( &token );
  870.         version = token.GetIntValue();
  871.     }
  872.  
  873.     while( 1 ) {
  874.         PACIFIER_UPDATE;
  875.         mapEnt = idMapEntity::Parse( src, ( entities.Num() == 0 ), version );
  876.         if ( !mapEnt ) {
  877.             break;
  878.         }
  879. // RAVEN BEGIN
  880. // rhummer: Check to see if there are func_groups in the map file.
  881.         if ( !mHasFuncGroups && !idStr::Icmp( mapEnt->epairs.GetString( "classname" ), "func_group" ) ) {
  882.             mHasFuncGroups = true;
  883.         }
  884. // RAVEN END
  885.         entities.Append( mapEnt );
  886.     }
  887.  
  888.     PACIFIER_UPDATE;
  889.     ParseExport(filename, osPath);
  890.  
  891.     SetGeometryCRC();
  892. // RAVEN BEGIN
  893. // rhummer: Trying to debug why func_groups disappear when editing a map when they shouldn't.
  894.     if ( cvarSystem->GetCVarBool( "developer" ) ) {
  895.         common->Printf( "^2loaded .map file ^0%s\n", filename );
  896.     }
  897.     mHasBeenResolved = false;
  898. // RAVEN END
  899.  
  900.     hasPrimitiveData = true;
  901.     return true;
  902. }
  903.  
  904. // RAVEN BEGIN
  905. // rjohnson: added resolve for handling func_groups and other aspects.  Before, radiant would do this processing on a map destroying the original data
  906. void idMapFile::Resolve( void )
  907. {
  908.     int i, j, k;
  909.     idMapEntity *mapEnt;
  910.  
  911.     if ( !hasPrimitiveData ) {
  912.         return;
  913.     }
  914.  
  915.     // if the map has a worldspawn
  916.     if ( entities.Num() ) {
  917.  
  918.         // "removeEntities" "classname" can be set in the worldspawn to remove all entities with the given classname
  919.         const idKeyValue *removeEntities = entities[0]->epairs.MatchPrefix( "removeEntities", NULL );
  920.         while ( removeEntities ) {
  921.             RemoveEntities( removeEntities->GetValue() );
  922.             removeEntities = entities[0]->epairs.MatchPrefix( "removeEntities", removeEntities );
  923.         }
  924.  
  925.         // "overrideMaterial" "material" can be set in the worldspawn to reset all materials
  926.         idStr material;
  927.         if ( entities[0]->epairs.GetString( "overrideMaterial", "", material ) ) {
  928.             for ( i = 0; i < entities.Num(); i++ ) {
  929.                 mapEnt = entities[i];
  930.                 for ( j = 0; j < mapEnt->GetNumPrimitives(); j++ ) {
  931.                     idMapPrimitive *mapPrimitive = mapEnt->GetPrimitive( j );
  932.                     switch( mapPrimitive->GetType() ) {
  933.                         case idMapPrimitive::TYPE_BRUSH: {
  934.                             idMapBrush *mapBrush = static_cast<idMapBrush *>(mapPrimitive);
  935.                             for ( k = 0; k < mapBrush->GetNumSides(); k++ ) {
  936.                                 mapBrush->GetSide( k )->SetMaterial( material );
  937.                             }
  938.                             break;
  939.                         }
  940.                         case idMapPrimitive::TYPE_PATCH: {
  941.                             static_cast<idMapPatch *>(mapPrimitive)->SetMaterial( material );
  942.                             break;
  943.                         }
  944.                     }
  945.                 }
  946.             }
  947.         }
  948.  
  949.         // force all entities to have a name key/value pair
  950.         if ( entities[0]->epairs.GetBool( "forceEntityNames" ) ) {
  951.             for ( i = 1; i < entities.Num(); i++ ) {
  952.                 mapEnt = entities[i];
  953.                 if ( !mapEnt->epairs.FindKey( "name" ) ) {
  954.                     mapEnt->epairs.Set( "name", va( "%s%d", mapEnt->epairs.GetString( "classname", "forcedName" ), i ) );
  955.                 }
  956.             }
  957.         }
  958.  
  959.         // move the primitives of any func_group entities to the worldspawn
  960.         for ( i = 1; i < entities.Num(); i++ ) {
  961.             mapEnt = entities[i];
  962.             if ( idStr::Icmp( mapEnt->epairs.GetString( "classname" ), "func_group" ) == 0 ) {
  963.                 idVec3    delta;
  964.                 
  965.                 mapEnt->epairs.GetVector( "origin", "0 0 0", delta );
  966.  
  967.                 for( j = 0; j < mapEnt->primitives.Num(); j++ ) {
  968.                     idMapPrimitive    *mapPrim = mapEnt->primitives[j];
  969.  
  970.                     mapPrim->AdjustOrigin( delta );
  971.                 }
  972.                 entities[0]->primitives.Append( mapEnt->primitives );
  973.                 mapEnt->primitives.Clear();
  974.             }
  975.         }
  976.         RemoveEntities( "func_group" );
  977.     }
  978. // rhummer:
  979.     mHasBeenResolved = true;
  980.     if ( cvarSystem->GetCVarBool( "developer" ) ) {
  981.         common->Printf( "^2idMapFile::Resolve has been run on ^0%s^2 so no func_groups exist.\n", name.c_str() );
  982.     }
  983. }
  984.  
  985. // rjohnson: added export
  986. /*
  987. ============
  988. idMapFile::Write
  989. ============
  990. */
  991. bool idMapFile::Write( const char *fileName, const char *ext, bool fromBasePath, bool exportOnly ) {
  992.     int i;
  993.     idStr qpath;
  994.     idFile *fp;
  995. // RAVEN BEGIN
  996. // rhummer: Used to verify func_groups didn't disappear somehow.
  997.     bool funcGroupFound = false;
  998. // RAVEN END
  999.  
  1000.     qpath = fileName;
  1001.     qpath.SetFileExtension( ext );
  1002.  
  1003.     idLib::common->Printf( "writing %s...\n", qpath.c_str() );
  1004.  
  1005.     if ( fromBasePath ) {
  1006.         fp = idLib::fileSystem->OpenFileWrite( qpath, "fs_devpath" );
  1007.     }
  1008.     else {
  1009.         fp = idLib::fileSystem->OpenExplicitFileWrite( qpath );
  1010.     }
  1011.  
  1012.     if ( !fp ) {
  1013.         idLib::common->Warning( "Couldn't open %s\n", qpath.c_str() );
  1014.         return false;
  1015.     }
  1016.  
  1017.     fp->WriteFloatString( "Version %d\n", CURRENT_MAP_VERSION );
  1018.  
  1019.     if (exportOnly)
  1020.     {
  1021.         for ( i = 0; i < entities.Num(); i++ ) 
  1022.         {
  1023.             if (entities[i]->epairs.GetInt("export"))
  1024.             {
  1025.                 entities[i]->Write( fp, i );
  1026.             }
  1027.         }
  1028.     }
  1029.     else
  1030.     {
  1031.         for ( i = 0; i < entities.Num(); i++ ) {
  1032.             entities[i]->Write( fp, i );
  1033. // RAVEN BEGIN
  1034. // rhummer: See if there are func_groups, there should be if there was during loading..
  1035.             if ( !idStr::Icmp( entities[i]->epairs.GetString( "classname" ), "func_group" ) ) {
  1036.                 funcGroupFound = true;
  1037.             }
  1038. // RAVEN END
  1039.         }
  1040.     }
  1041.  
  1042. // RAVEN BEGIN
  1043. // rhummer: If this is true..something bad happened to cause all func_groups to go away between loading and saving.
  1044.     if ( mHasFuncGroups && !funcGroupFound && cvarSystem->GetCVarBool( "developer" ) ) {
  1045.         common->Warning( "^5Did not find any ^2func_groups^0 during save, but there were ^2func_groups^0 found during loading.  Was this intended?\n");
  1046.     }
  1047. // RAVEN END
  1048.  
  1049.     idLib::fileSystem->CloseFile( fp );
  1050.  
  1051.     return true;
  1052. }
  1053. // RAVEN END
  1054.  
  1055. /*
  1056. ===============
  1057. idMapFile::SetGeometryCRC
  1058. ===============
  1059. */
  1060. void idMapFile::SetGeometryCRC( void ) {
  1061.     int i;
  1062.  
  1063.     geometryCRC = 0;
  1064.     for ( i = 0; i < entities.Num(); i++ ) {
  1065.         geometryCRC ^= entities[i]->GetGeometryCRC();
  1066.     }
  1067. }
  1068.  
  1069. /*
  1070. ===============
  1071. idMapFile::AddEntity
  1072. ===============
  1073. */
  1074. int idMapFile::AddEntity( idMapEntity *mapEnt ) {
  1075.     int ret = entities.Append( mapEnt );
  1076.     return ret;
  1077. }
  1078.  
  1079. /*
  1080. ===============
  1081. idMapFile::FindEntity
  1082. ===============
  1083. */
  1084. idMapEntity *idMapFile::FindEntity( const char *name ) {
  1085.     for ( int i = 0; i < entities.Num(); i++ ) {
  1086.         idMapEntity *ent = entities[i];
  1087.         if ( idStr::Icmp( ent->epairs.GetString( "name" ), name ) == 0 ) {
  1088.             return ent;
  1089.         }
  1090.     }
  1091.     return NULL;
  1092. }
  1093.  
  1094. /*
  1095. ===============
  1096. idMapFile::RemoveEntity
  1097. ===============
  1098. */
  1099. void idMapFile::RemoveEntity( idMapEntity *mapEnt ) {
  1100.     entities.Remove( mapEnt );
  1101.     delete mapEnt;
  1102. }
  1103.  
  1104. /*
  1105. ===============
  1106. idMapFile::RemoveEntity
  1107. ===============
  1108. */
  1109. void idMapFile::RemoveEntities( const char *classname ) {
  1110.     for ( int i = 0; i < entities.Num(); i++ ) {
  1111.         idMapEntity *ent = entities[i];
  1112.         if ( idStr::Icmp( ent->epairs.GetString( "classname" ), classname ) == 0 ) {
  1113.             delete entities[i];
  1114.             entities.RemoveIndex( i );
  1115.             i--;
  1116.         }
  1117.     }
  1118. }
  1119.  
  1120. /*
  1121. ===============
  1122. idMapFile::RemoveAllEntities
  1123. ===============
  1124. */
  1125. void idMapFile::RemoveAllEntities() {
  1126.     entities.DeleteContents( true );
  1127.     hasPrimitiveData = false;
  1128. }
  1129.  
  1130. /*
  1131. ===============
  1132. idMapFile::RemovePrimitiveData
  1133. ===============
  1134. */
  1135. void idMapFile::RemovePrimitiveData() {
  1136.     for ( int i = 0; i < entities.Num(); i++ ) {
  1137.         idMapEntity *ent = entities[i];
  1138.         ent->RemovePrimitiveData();
  1139.     }
  1140.     hasPrimitiveData = false;
  1141. // RAVEN BEGIN
  1142. // rhummer: debugging stuff..
  1143.     if ( cvarSystem->GetCVarBool( "developer" ) ) {
  1144.         common->Printf( "^2Removed all primitive data from ^0%s\n", name.c_str() );
  1145.     }
  1146. // RAVEN END
  1147. }
  1148.  
  1149. /*
  1150. ===============
  1151. idMapFile::NeedsReload
  1152. ===============
  1153. */
  1154. bool idMapFile::NeedsReload() {
  1155.     if ( name.Length() ) {
  1156.         unsigned int time = (unsigned int)-1;
  1157.         if ( idLib::fileSystem->ReadFile( name, NULL, &time ) > 0 ) {
  1158.             return ( time > fileTime );
  1159.         }
  1160.     }
  1161.     return true;
  1162. }
  1163.  
  1164. bool idMapFile::WriteExport( const char *fileName, bool fromBasePath )
  1165. {
  1166.     int            i, j;
  1167.     idDict        newPairs;
  1168.  
  1169.     for ( i = 0; i < entities.Num(); i++ ) 
  1170.     {
  1171.         idMapEntity *ent = entities[i];
  1172.  
  1173.         if ( ent->epairs.GetInt("export") == 1 )
  1174.         {
  1175. /*            for ( j = 0; j < ent->epairs.GetNumKeyVals(); j++) 
  1176.             {
  1177.                 const idKeyValue    *kv = ent->epairs.GetKeyVal(j);
  1178.  
  1179.                 if (kv->key.CmpPrefix("export_") == 0)
  1180.                 {
  1181.                     ent->epairs.Delete(kv->key.c_str());
  1182.                     j--;
  1183.                     continue;
  1184.                 }
  1185.             }
  1186. */
  1187.             newPairs.Clear();
  1188.  
  1189.             for ( j = 0; j < ent->epairs.GetNumKeyVals(); j++) 
  1190.             {
  1191.                 const idKeyValue    *kv = ent->epairs.GetKeyVal(j);
  1192.  
  1193.                 if (kv->GetKey().CmpPrefix("export_") != 0)
  1194.                 {
  1195.                     char                newName[1024];
  1196.  
  1197.                     sprintf(newName, "export_%s", kv->GetKey().c_str());
  1198.  
  1199.                     if (!ent->epairs.GetString(newName, 0))
  1200.                     {    // don't overwrite an existing export
  1201.                         newPairs.Set (newName, kv->GetValue().c_str());
  1202.                     }
  1203.                 }
  1204.             }
  1205.  
  1206.             ent->epairs.Copy(newPairs);
  1207.         }
  1208.     }
  1209.  
  1210.     return Write(fileName, "export", fromBasePath, true);
  1211. }
  1212.  
  1213. bool idMapFile::ParseExport( const char *filename, bool osPath )
  1214. {
  1215.     // no string concatenation for epairs and allow path names for materials
  1216. // RAVEN BEGIN
  1217. // jsinger: Done this way to reduce the amount of code to change.
  1218. //          The auto pointer will delete the lexer when this method exits.
  1219.     idAutoPtr<Lexer>        lexer(LexerFactory::MakeLexer( LEXFL_NOSTRINGCONCAT | LEXFL_NOSTRINGESCAPECHARS | LEXFL_ALLOWPATHNAMES ) );
  1220.     Lexer &src(*lexer);
  1221. // RAVEN END
  1222.     idToken        token;
  1223.     idStr        fullName;
  1224.     idMapEntity *mapEnt;
  1225.     int            i, j;
  1226.     int            numMerged, numNotMerged, numAdded, numRemoved;
  1227.  
  1228.     numMerged = numNotMerged = numAdded = numRemoved = 0;
  1229.     mHasExportEntities = false;
  1230.     
  1231.     fullName = filename;
  1232.     fullName.StripFileExtension();
  1233.     fullName.SetFileExtension( "export" );
  1234.     src.LoadFile( fullName, osPath );
  1235.     if ( !src.IsLoaded() ) {
  1236.         // didn't get anything at all
  1237.         return false;
  1238.     }
  1239.  
  1240.     version = OLD_MAP_VERSION;
  1241.     fileTime = src.GetFileTime();
  1242.     mExportEntities.DeleteContents( true );
  1243.  
  1244.     if ( src.CheckTokenString( "Version" ) ) {
  1245.         src.ReadTokenOnLine( &token );
  1246.         version = token.GetIntValue();
  1247.     }
  1248.  
  1249.     while( 1 ) {
  1250.         mapEnt = idMapEntity::Parse( src, false, version );
  1251.         if ( !mapEnt ) {
  1252.             break;
  1253.         }
  1254.         mExportEntities.Append( mapEnt );
  1255.     }
  1256.  
  1257.     if (mExportEntities.Num())
  1258.     {
  1259.         mHasExportEntities = true;
  1260.     }
  1261.  
  1262.     for(i=0;i<mExportEntities.Num();i++)
  1263.     {
  1264.         idMapEntity *ent = mExportEntities[i];
  1265.         idMapEntity *mapEnt;
  1266.         const char    *name;
  1267.  
  1268.         name = ent->epairs.GetString("name");
  1269.         mapEnt = FindEntity(name);
  1270.  
  1271.         if (!mapEnt)
  1272.         {    // check to see if we have an export_name
  1273.             name = ent->epairs.GetString("export_name", 0);
  1274.             if (!name || ent->epairs.GetInt("original") )
  1275.             {    // this is a new entity
  1276.                 ent->epairs.SetInt("export", 2);            // 2 = when re-exporting, don't duplicated the export_ fields
  1277.                 ent->epairs.SetInt("merged", 1);
  1278.                 ent->epairs.SetInt("original", 0);            // 0 = now the entity in map is always treated as master
  1279.                 entities.Append(ent);
  1280.                 mExportEntities.RemoveIndex(i);
  1281.                 i--;
  1282.                 numAdded++;
  1283.                 continue;
  1284.             }
  1285.             else
  1286.             {
  1287.                 mapEnt = FindEntity(name);
  1288.             }
  1289.         }
  1290.  
  1291.         if (!mapEnt)
  1292.         {    // this export entity has been removed from the original map
  1293.             numNotMerged++;
  1294.         }
  1295.         else
  1296.         {    // exists in both, do a merge!
  1297.             mapEnt->epairs.SetInt("export", 2);            // 2 = when re-exporting, don't duplicated the export_ fields
  1298.             mapEnt->epairs.SetInt("merged", 1);
  1299.             for ( j = 0; j < ent->epairs.GetNumKeyVals(); j++) 
  1300.             {
  1301.                 char                origName[1024];
  1302.                 const idKeyValue    *exportKV = ent->epairs.GetKeyVal(j);
  1303.                 const idKeyValue    *origKV, *mapKV;
  1304.  
  1305.                 if (exportKV->GetKey().CmpPrefix("export_") != 0)
  1306.                 {
  1307.                     sprintf(origName, "export_%s", exportKV->GetKey().c_str());
  1308.                     origKV = ent->epairs.FindKey(origName);
  1309.                     mapKV = mapEnt->epairs.FindKey(exportKV->GetKey().c_str());
  1310.  
  1311.                     if (origKV && mapKV)
  1312.                     {    // keys exist in all spots, compare
  1313.                         if (origKV->GetValue() == exportKV->GetValue())
  1314.                         {    // export hasn't change
  1315.                         }
  1316.                         else if (mapKV->GetValue() == origKV->GetValue())
  1317.                         {    // map is same as the orig, yet export has changed, so bring it over
  1318.                             mapEnt->epairs.Set(exportKV->GetKey().c_str(), exportKV->GetValue().c_str());
  1319.                         }
  1320.                     }
  1321.                     else if (origKV)
  1322.                     {    // map has removed this key, so we shouldn't merge it
  1323.                     }
  1324.                     else if (mapKV)
  1325.                     {    // map has added this key, so we'll ignore the exported value, which has also been added
  1326.                     }
  1327.                     else
  1328.                     {    // this was added to the export, so merge it in
  1329.                         mapEnt->epairs.Set(exportKV->GetKey().c_str(), exportKV->GetValue().c_str());
  1330.                     }
  1331.                 }
  1332.                 else
  1333.                 {
  1334.                     mapEnt->epairs.Set(exportKV->GetKey().c_str(), exportKV->GetValue().c_str());
  1335.                 }
  1336.             }
  1337.             numMerged++;
  1338.         }
  1339.     }
  1340.  
  1341.     // check for any entities that have been marked as exported in the original map but have been removed from the export file
  1342.     for(i=0;i<entities.Num();i++)
  1343.     {
  1344.         idMapEntity *ent = entities[i];
  1345.  
  1346.         if (ent->epairs.GetInt("export"))
  1347.         {
  1348.             if (!ent->epairs.GetInt("merged"))
  1349.             {
  1350.                 entities.RemoveIndex(i);
  1351.                 numRemoved++;
  1352.                 i--;
  1353.             }
  1354.             else
  1355.             {
  1356.                 ent->epairs.Delete("merged");
  1357.             }
  1358.         }
  1359.     }
  1360.  
  1361.     common->Printf("Export Merge: %d added, %d merged, %d not merged, %d removed\n", numAdded, numMerged, numNotMerged, numRemoved);
  1362.  
  1363.     mExportEntities.DeleteContents( true );
  1364.  
  1365.     return true;
  1366. }
  1367.