ScenerySet.cpp

Go to the documentation of this file.

/*
 * ScenerySet.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2004 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/FlyLegacy.h"
#include "../Include/Globals.h"
#include "../Include/Ui.h"
#include "../Include/Terrain.h"

using namespace std;

CScenerySet::CScenerySet (const char* baseFolder,
                          const char* scfFolder,
                          const char* scfFilename)
{
  char fullname[1024];
  strcpy (fullname, scfFolder);
  strcat (fullname, "\\");
  strcat (fullname, scfFilename);

  // Attempt to open scenery file stream
  SStream *s = new SStream;
  strcpy (s->filename, fullname);
  strcpy (s->mode, "r");
  if (OpenStream (s)) {
    ReadFrom (this, s);
    CloseStream (s);
  }
  delete s;

  // Save base pathname, SCF pathname and SCF filename
  strcpy (this->baseFolder, baseFolder);
  strcpy (this->scfFolder, scfFolder);
  strcpy (this->scfFilename, scfFilename);

  // Default state is unloaded
  refCount = 0;
  loaded = false;
  pfs = NULL;
}

CScenerySet::~CScenerySet (void)
{
  // Ensure scenery set is unloaded
  if (loaded) Unload ();
}

int CScenerySet::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  char file[64];

  switch (tag) {
  case 'call':
    ReadLatLon (&call, stream);
    rc = TAG_READ;
    break;
  case 'caur':
    ReadLatLon (&caur, stream);
    rc = TAG_READ;
    break;
  case 'ldll':
    ReadLatLon (&ldll, stream);
    rc = TAG_READ;
    break;
  case 'ldur':
    ReadLatLon (&ldur, stream);
    rc = TAG_READ;
    break;
  case 'file':
    {
      ReadString (file, 64, stream);
      podList.push_back (file);
    }
    rc = TAG_READ;
    break;
  }

  return rc;
}

//
// Check whether the given position is within the lower-left (SW) and upper-right (NE)
//   boundaries of the load area
//
bool CScenerySet::InLoadRange (SPosition pos)
{
  return ((pos.lat >= ldll.lat) && (pos.lat <= ldur.lat) &&
          (pos.lon >= ldll.lon) && (pos.lon <= ldur.lon));
}

//
// Check whether the given position is within the lower-left (SW) and upper-right (NE)
//   boundaries of the coverage
//
bool CScenerySet::InCoverageRange (SPosition pos)
{
  return ((pos.lat >= call.lat) && (pos.lat <= caur.lat) &&
          (pos.lon >= call.lon) && (pos.lon <= caur.lon));
}

bool CScenerySet::IsLoaded (void)
{
  return loaded;
}

int  CScenerySet::GetRefCount (void)
{
  return refCount;
}

void CScenerySet::IncRefCount (void)
{
  refCount++;
}

void CScenerySet::DecRefCount (void)
{
  --refCount;
}

void CScenerySet::Load (void)
{
  IncRefCount();

  // Check if set is already loaded
  if (!IsLoaded()) {
    // Add individual pods to the filesystem
    vector<string>::iterator i;
    for (i=podList.begin(); i!=podList.end(); i++) {
      char podName[1024];
      strcpy (podName, scfFolder);
      strcat (podName, "\\");
      strcat (podName, i->c_str());
      paddpod (&globals->pfs, podName);
    }

    // Set loaded flag
    loaded = true;

    // Debug
    char debug[80];
    sprintf (debug, "Loaded scenery set : %s", scfFilename);
    DrawNoticeToUser (debug, 5);
  }

  DEBUGLOG ("Load scenery set %s, ref count = %d", scfFilename, refCount);
}

void CScenerySet::Unload (void)
{
  if (IsLoaded()) {
    // Decrement reference count and unload if necessary
    DecRefCount();
    if (GetRefCount() <= 0) {
      // Remove individual pods from the scenery filesystem
      vector<string>::iterator i;
      for (i=podList.begin(); i!=podList.end(); i++) {
        premovepod (&globals->pfs, i->c_str());
      }
  
      // Clear loaded flag
      loaded = false;

      DEBUGLOG ("Unload scenery set %s, ref count = %d", scfFilename, refCount);
    }
  }
}

CScenerySetDatabase *ssdb;

//
// CScenerySetDatabase
//

CScenerySetDatabase::CScenerySetDatabase (void)
{
  Init ();
}

CScenerySetDatabase::~CScenerySetDatabase (void)
{
  Purge ();
}

//
// Unload and delete all scenery sets
//
void CScenerySetDatabase::Purge (void)
{
  set<CScenerySet*>::iterator i;
  for (i=setActive.begin(); i!=setActive.end(); i++) delete *i;
  setActive.empty();

  for (i=setInactive.begin(); i!=setInactive.end(); i++) delete *i;
  setInactive.empty();
}

//
// Search a directory for any scenery control files
//
void CScenerySetDatabase::LoadInFolder (const char* base, const char *path)
{
  char fullpath[1024];
  strcpy (fullpath, base);
  strcat (fullpath, "\\");
  strcat (fullpath, path);

  // Iterate over all files in this folder.  Sub-folders are ignored
  ulDir* dirp = ulOpenDir (fullpath);
  if (dirp != NULL) {
    ulDirEnt* dp;
    while ((dp = ulReadDir(dirp)) != NULL ) {
      if (dp->d_isdir) {
        // This is a sub-folder, ignore it
        continue;
      } else {
        // Check for file extension .SCF
        char *c = strrchr (dp->d_name, '.');
        if (stricmp (c, ".SCF") == 0) {
          CScenerySet *set = new CScenerySet (base, path, dp->d_name);
          setInactive.insert (set);
        }
      }
    }
    ulCloseDir(dirp);
  }
}

//
// Search for any scenery files that describe sliced scenery areas.
// Scenery files are stream files with no extension that reside in
//   a sub-directory from the \Scenery folder.
//


void CScenerySetDatabase::Init (void)
{
  char base[1024];
  strcpy (base, "");
  GetIniString ("UI", "flyRootFolder", base, 1024);
  if (strlen (base) == 0) {
    strcpy (base, "C:\\Program Files\\Terminal Reality\\Fly! II");
  }

  // Search the Scenery folder for any sub-directories, which are individually
  //   searched for SCF files
  char searchPath[1024];
  strcpy (searchPath, base);
  strcat (searchPath, "\\Scenery");
  ulDir* dirp = ulOpenDir (searchPath);
  if (dirp != NULL) {
    ulDirEnt* dp;
    while ((dp = ulReadDir(dirp)) != NULL )
    {
      if (dp->d_isdir &&
          (strcmp (dp->d_name, ".") != 0) &&
          (strcmp (dp->d_name, "..") != 0))
      {
        // This is a sub-folder, attempt to load scenery files in it
        char path[1024];
        strcpy (path, "Scenery\\");
        strcat (path, dp->d_name);
        LoadInFolder (base, path);
      }
    }
    ulCloseDir(dirp);
  }
}

//
//  Registration of a position is the trigger for loading of available
//    scenery sets.
//    1. Check the position against the load area boundaries for every
//         scenery set in the inactive set.  If a match is found, move
//         the scenery set to the active set with ref counter of 1.
//    2. Check the position against the load area boundaries of every
//         scenery set in the active set.  If a match is found, increment
//         the ref counter.
//
void CScenerySetDatabase::Register (SPosition pos)
{
  // Search inactive set list
  set<CScenerySet*>::iterator i;
  for (i=setInactive.begin(); i!=setInactive.end(); i++) {
    CScenerySet *cset = *i;
    if (cset->InLoadRange (pos)) {
      // Position is in the load region; move this set from the inactive
      //   to the active list and ensure it is loaded
      setInactive.erase(cset);
      setActive.insert(cset);
      cset->Load();
    }
  }
  
  // Search active set list
  for (i=setActive.begin(); i!=setActive.end(); i++) {
    CScenerySet *cset = *i;
    if (cset->InLoadRange (pos)) {
      // Position is in the load region for the set; the Load() method
      //   will ensure the set is loaded, or increment the ref count
      cset->Load();
    }
  }
}

//
//  Deregistration of a position is the trigger for unloading scenery sets.
//    1. Check the position against the load area boundaries for every
//         scenery set in the active set.  If a match is found, decrement
//         the ref counter.  If the counter is zero, unload the set and
//         move it to the inactive set.
//
void CScenerySetDatabase::Deregister (SPosition pos)
{
  // Search active set list
  set<CScenerySet*>::iterator i;
  for (i=setActive.begin(); i!=setActive.end(); i++) {
    CScenerySet *cset = *i;
    if (!(cset->InLoadRange (pos))) {
      // Position is not in the load region for the set; the Unload() method
      //   decrement the ref count and unload the set when ref count reaches 0
      cset->Unload();
      if (cset->GetRefCount() <= 0) {
        // Move the set from the active to inactive lists
        setActive.erase(cset);
        setInactive.insert(cset);
      }
    }
  }
}

Documentation generated by