ModelSMF.cpp

Go to the documentation of this file.

/*
 * ModelSMF.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"


//
// Vertex information in a SMF part
//
typedef struct {
  float x, y, z;      // Vertex coordinates
  float nx, ny, nz;   // Normal coordinates
  float u, v;       // Texture coordinates
} SVertex;


CModelSMF::CModelSMF (const char* smfFilename)
{
  top = new ssgTransform;
  top->setName (smfFilename);

  // Open POD file
  PODFILE *p = popen (&globals->pfs, smfFilename);
  if (p == NULL) {
    gtfo ("CModelSMF : Could not open SMF model %s", smfFilename);
  }

  GLuint texid = 0;
  char texfilename[256];

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

  // Object type, this should be "C3DModel"
  pgets (s, LINE_LENGTH, p);
  if (strncmp (s, "C3DModel", strlen("C3DModel")) != 0) {
    globals->logWarning->Write ("CModelSMF : Incorrect object type in %s", smfFilename);
  }

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

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

  // Use automatic detail, detail pixel height
  int autoDetail;
  float detailPixelHeight;
  pgets (s, LINE_LENGTH, p);
  if (sscanf (s, "%d,%f", &autoDetail, &detailPixelHeight) != 2) {
    // Error
    gtfo ("CModelSMF : Invalid auto detail data in %s", smfFilename);
  }

  // Part list
  for (int i=0; i<nParts; i++) {
    // Part name, trim trailing whitespace
    char name[LINE_LENGTH];
    pgets (s, LINE_LENGTH, p);
    char *q = s + strlen(s) - 1;
    while (isspace(*q)) q--;
    q++;
    *q = '\0';
    strcpy (name, s);

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

    // Version (ignored)
    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 ("CModelSMF : Error parsing vertex and face counts in %s", smfFilename);
    }

    // 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 ("CModelSMF : Error parsing material parameters for part %d in %s",
        i, smfFilename) ;
    }

    // Load texture
    if (texid == 0) {
      // Construct full texture filename
      strcpy (texfilename, texturename);
      char texfullname[256];
      strcpy (texfullname, "Art\\");
      strcat (texfullname, texfilename);

      // Check extension of texture name
      char *p = strrchr (texturename, '.');
      if (p) {
        // File has an extension, now check for valid bitmaps
        if (stricmp (p, ".RAW") == 0) {
          CRawImage *raw = new CRawImage (texfullname);
          texid = raw->GetTexture (true);
          delete raw;
        } else if (stricmp (p, ".TIF") == 0) {
          CImageTIFF *tif = new CImageTIFF (texfullname);
          texid = tif->CreateTexture (true);
          delete tif;
        } else {
          gtfo ("SModelSMF : Unsupported texture %s in %s", texturename, smfFilename);
        }
      } else {
        gtfo ("SModelSMF : Invalid texture filename %s in %s",
          texturename, smfFilename);
      }
    } else {
      // Doublecheck that only one texture is used across all parts
      if (strcmp (texfilename, texturename) != 0) {
        globals->logWarning->Write ("CModelSMF : More than one texture filename at part %d in %s",
          i, smfFilename);
      }
    }

    // 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
    SVertex *vt = new SVertex[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 ("CModelSMF : Error parsing vertex %d for part %d in %s",
          j, i, smfFilename) ;
      }

      // Assign values to (temporary) vertex table
      SVertex *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 ("CModelSMF : Error parsing face %d for part %d in %s",
          k, i, smfFilename);
      }

      // 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 SVertex list
    delete vt;

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

    // Temporary : Only add high-detail parts OPAQUE and TRANSP
    if ((strcmp (name, "OPAQUE") == 0) ||
        (strcmp (name, "TRANSP") == 0) ||
        (nParts == 1))
    {
      // Add the part to the top-level transform
      top->addKid (vtab);
    } else {
      // vtab will not be automatically deleted when removed from the
      //   SSG tree, so it must be deleted
      delete vtab;
    }
  }

  // Close pod file
  pclose (p);

  // Set transform
  sgMat4 T;
  sgMakeIdentMat4 (T);
  top->setTransform (T);
}

CModelSMF::~CModelSMF (void)
{
  if (top->getRef() == 0) {
    top->removeAllKids();
    delete top;
  }
}

ssgEntity *CModelSMF::GetSSGEntity()
{
  return top;
}

Documentation generated by