ModelACM.cpp

Go to the documentation of this file.

/*
 * ModelACM.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 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/Globals.h"
#include "../Include/FlyLegacy.h"
#include "../Include/Utility.h"


//
// Single frame of keyframe animation data
//
typedef struct {
  float dx, dy, dz, p, b, h;
} SAcmKeyframe;

//
// Vertex information in an ACM part
//
typedef struct {
  float x, y, z;      // Vertex coordinates
  float nx, ny, nz;   // Normal coordinates
  float u, v;       // Texture coordinates
} SAcmVertex;



CModelACM::CModelACM (const char* acmFilename)
{
  top = new ssgTransform;
  top->setName (acmFilename);

  tifftexture = NULL;

  PODFILE *p = popen (&globals->pfs, acmFilename);
  if (p == NULL) {
    gtfo ("CModelACM : Could not open ACM model %s", acmFilename);
  }

  GLuint texid = 0;
  char texfilename[256];

  static const int LINE_LENGTH = 128;
  char s[LINE_LENGTH+1];

  // Object type, for aircraft this should be "CAircraftModel"
  pgets (s, LINE_LENGTH, p);
  if (strncmp (s, "CAircraftModel", strlen("CAircraftModel")) != 0) {
    // Warning
    globals->logWarning->Write ("CModelACM : Incorrect object type in %s", acmFilename);
  }

  // Version, always 1 (ignored)
  pgets (s, LINE_LENGTH, p);

  // Part count
  int nParts;
  pgets (s, LINE_LENGTH, p);
  if (sscanf (s, "%d", &nParts) != 1) {
    // Error
    gtfo ("CModelACM : Error parsing part count in %s", acmFilename);
  }

  // Before reading parts, create a table for storage of a reference
  //   to each part's ssg branch so that child parts are correctly linked
  ssgBranch **parentList = new ssgBranch*[nParts];

  // Part list
  for (int i=0; i<nParts; i++) {
    // Create a new ssg branch and transform for the part.  A branch is required
    //   since this part may be the parent of subsequent part(s)
    ssgKeyframeTransform *xform = new ssgKeyframeTransform (31, 0.0f, 1.0f);

    // Part name
    char name[LINE_LENGTH];
    pgets (s, LINE_LENGTH, p);
    TrimTrailingWhitespace (s);
    strcpy (name, s);

    // Part status (on/off)
    pgets (s, LINE_LENGTH, p);

    // Parent part index
    int parent_index = -1;
    pgets (s, LINE_LENGTH, p);
    if (sscanf (s, "%d", &parent_index) != 1) {
      // Error
      gtfo ("CModelACM : Error parsing parent index in %s", acmFilename);
    }

    // Get a reference to the parent's ssgEntity
    ssgBranch *parent = top;
    if (parent_index != -1) {
      parent = parentList[parent_index];
    }

    // Save a reference to this part in the parent table
    parentList[i] = xform;

    // Version, always 1
    pgets (s, LINE_LENGTH, p);

    // Vertex count, frame count, face count, unused value
    int nVerts, nFrames, nFaces, dummy;
    pgets (s, LINE_LENGTH, p);
    if (sscanf (s, "%d,%d,%d,%d", &nVerts, &nFrames, &nFaces, &dummy) != 4) {
      // Error
      gtfo ("CModelACM : Error parsing vertex and face counts in %s", acmFilename);
    }

    // Optional line "vl" ???
    bool v1flag = false;
    pgets (s, LINE_LENGTH, p);
    if (strncmp (s, "v1", 2) == 0) {
      //  ?? What does this mean?
      v1flag = true;
      //  Pre-read the next line
      pgets (s, LINE_LENGTH, p);
    }

    // Diffuse value, specular value, specular power, use transparency,
    //   use environment mapping, texture name
    int diffuse, specular, specpower, transparent, envmap;
    char texturename[LINE_LENGTH];
    if (sscanf (s, "%d,%d,%d,%d,%d,%s",
      &diffuse, &specular, &specpower, &transparent, &envmap, texturename) != 6) {
      // Error
      gtfo ("CModelACM : Error parsing material parameters in %s", acmFilename) ;
    }

    // Load TIFF texture
    if (texid == 0) {
      strcpy (texfilename, texturename);
      char texfullname[256];
      strcpy (texfullname, "Art\\");
      strcat (texfullname, texfilename);
      tifftexture = new CImageTIFF (texfullname);
      texid = tifftexture->CreateTexture (false);
      if (texid == 0) {
        gtfo ("CModelACM : Failed to create texture from %s in %s",
          texfullname, acmFilename);
      }
    } else {
      // Doublecheck that only one texture is used across all parts
      if (strcmp (texfilename, texturename) != 0) {
        gtfo ("CModelACM : More than one texture filename in %s", acmFilename);
      }
    }

    // Create state information about this part
    ssgSimpleState *state = new ssgSimpleState ();

    sgVec4 spec = { 0.0f, 0.0f, 0.0f, 1.0f };
    sgVec4 emis = { 0.0f, 0.0f, 0.0f, 1.0f } ;
    float  shi  = { 0.0f } ;

    state -> setMaterial ( GL_SPECULAR, spec ) ;
    state -> setMaterial ( GL_EMISSION, emis ) ;
    state -> setShininess ( shi ) ;
    state -> enable ( GL_COLOR_MATERIAL ) ;
    state -> setColourMaterial ( GL_AMBIENT_AND_DIFFUSE ) ;
    state -> enable  ( GL_LIGHTING ) ;
    state -> setShadeModel ( GL_SMOOTH ) ;

    if (texid != 0) {
      // Texture was loaded, attach it to the part
      state-> enable (GL_TEXTURE_2D);
      state-> setTexture (texid);

      // Set rendering states for transparent/opaque parts
      if (transparent) {
        state->enable (GL_BLEND);
        state->enable (GL_ALPHA_TEST);
        state->setTranslucent();
      } else {
        state->disable (GL_BLEND);
        state->disable (GL_ALPHA_TEST);
        state->setOpaque();
      }
    } else {
      state->disable (GL_TEXTURE_2D);
      state->disable (GL_BLEND);
    }

    // If the line before last was "v1" then skip the next line, which is
    //   always a blank string ""
    if (v1flag) {
      pgets (s, LINE_LENGTH, p);
    }

    // Before reading vertex list, allocate table of (temporary) structs
    //   to hold the vertex table until the face data is read
    SAcmVertex *vt = new SAcmVertex[nVerts];

    // Vertex list
    for (int j=0; j<nVerts; j++) {
      // x, y, z, nx, ny, nz, u, v
      float x, y, z, nx, ny, nz, u, v;
      pgets (s, LINE_LENGTH, p);
      if (sscanf (s, "%f,%f,%f,%f,%f,%f,%f,%f",
        &x, &y, &z, &nx, &ny, &nz, &u, &v) != 8) {
        // Error
        gtfo ("CModelACM : Error parsing vertex %d in %s", j, acmFilename) ;
      }

      // Assign values to (temporary) vertex table
      // The z-coordinate is negated to perform LHS-RHS system conversion
      SAcmVertex *pNext = &vt[j];
      pNext->x = x;
      pNext->y = z;
      pNext->z = y;
      pNext->nx = nx;
      pNext->ny = nz;
      pNext->nz = ny;
      pNext->u = u;
      pNext->v = v;
//      pNext->v = 1.0f - v;      // For libtiff loaded TIF textures
    }

    // Before beginning to parse the vertex and face lists, create arrays
    //   for storage of the vertices, normals, texcoords and face indices
    ssgVertexArray *va = new ssgVertexArray(nFaces*3);
    ssgNormalArray *na = new ssgNormalArray(nFaces*3);
    ssgTexCoordArray *tca = new ssgTexCoordArray(nFaces*3);

    // Face list
    for (int k=0; k<nFaces; k++) {
      // i1, i2, i3 (vertex indices, clockwise)
      int i1, i2, i3;
      pgets (s, LINE_LENGTH, p);
      if (sscanf (s, "%d,%d,%d",
        &i1, &i2, &i3) != 3)
      {
        // Error
        gtfo ("CModelACM : Error parsing face %d in %s", k, acmFilename) ;
      }

      // NOTE: ACM meshes are use left-hand coordinate system.
      //  In order to convert to OpenGL's right-hand system:
      //    - all triangle vertices are reversed order (3, 2, 1)

      // Add vertex coordinates to vertex array
      sgVec3 v1, v2, v3;
      sgSetVec3 (v1, vt[i1].x, vt[i1].y, vt[i1].z);
      sgSetVec3 (v2, vt[i2].x, vt[i2].y, vt[i2].z);
      sgSetVec3 (v3, vt[i3].x, vt[i3].y, vt[i3].z);
      va->add (v3);
      va->add (v2);
      va->add (v1);

      // Add normal coordinates to normal array
      sgVec3 n1, n2, n3;
      sgSetVec3 (n1, vt[i1].nx, vt[i1].ny, vt[i1].nz);
      sgSetVec3 (n2, vt[i2].nx, vt[i2].ny, vt[i2].nz);
      sgSetVec3 (n3, vt[i3].nx, vt[i3].ny, vt[i3].nz);
      na->add (n3);
      na->add (n2);
      na->add (n1);

      // Add texture coordinates to texcoord array
      sgVec2 tc1, tc2, tc3;
      sgSetVec2 (tc1, vt[i1].u, vt[i1].v);
      sgSetVec2 (tc2, vt[i2].u, vt[i2].v);
      sgSetVec2 (tc3, vt[i3].u, vt[i3].v);
      tca->add (tc3);
      tca->add (tc2);
      tca->add (tc1);
    }

    // Clean up ACM vertex list
    delete vt;

    // 31 Animation frames, each interval is therefore 1/30
    static const float epsilon = (float)1e-3;
    float kfStep = 1.0f / 30.0f;
    for (int m=0; m<31; m++) {
      // dx, dy, dz, p, b, h (???)
      float dx, dy, dz, pitch, bank, hdg;
      pgets (s, LINE_LENGTH, p);
      if (sscanf (s, "%f,%f,%f,%f,%f,%f",
        &dx, &dy, &dz, &pitch, &bank, &hdg) != 6)
      {
        // Error
        gtfo ("CModelACM : Error parsing animation frame %d for part %d in %s",
          m, i, acmFilename) ;
      }
      
      // Eliminate small spurious translations and rotations
      if (fabs(dx) < epsilon) dx = 0.0f;
      if (fabs(dy) < epsilon) dy = 0.0f;
      if (fabs(dz) < epsilon) dz = 0.0f;
      if (fabs(pitch) < epsilon) pitch = 0.0f;
      if (fabs(bank) < epsilon) bank = 0.0f;
      if (fabs(hdg) < epsilon) hdg = 0.0f;

      pitch = WrapTwoPi (pitch);
      bank = WrapTwoPi (bank);
      hdg = WrapTwoPi (hdg);

      // Store keyframe data
      // Convert from LHS-RHS coordinate system
      // Elevator pitch = 
      sgCoord kf;
      sgSetCoord (&kf,
        dx,
        dz,
        dy,
        -hdg * SG_RADIANS_TO_DEGREES,
        -pitch * SG_RADIANS_TO_DEGREES,
        -bank * SG_RADIANS_TO_DEGREES
        );

      xform->addKeyframe (kfStep * (float)m, &kf);
    }

    // Initialize to first keyframe
    xform->setKeyframe (0.0f);

    // Create vertex table leaf for this part
    ssgVtxTable *vtab = new ssgVtxTable (GL_TRIANGLES, va, na, tca, NULL);
    vtab->setName (name);
    vtab->setState (state);

    xform->setName (name);
    xform->addKid (vtab);

    // Add the part to the appropriate parent
    parent->addKid (xform);
  }

  // Delete parent list
  delete parentList;

  // Close pod file
  pclose (p);
}

CModelACM::~CModelACM (void)
{
  if (top->getRef() == 0) {
    top->removeAllKids();
    delete top;
  }
  if (tifftexture != NULL) delete tifftexture;
}

ssgEntity *CModelACM::GetSSGEntity (void)
{
  return top;
}

Documentation generated by