ModelBIN.cpp

Go to the documentation of this file.

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


typedef struct {
  unsigned long scale;
  unsigned long unknown1;
  unsigned long unknown2;
  unsigned long nVertices;
} SBINHeader;

typedef struct {
  long x, y, z;      // Vertex coordinates
} SBINVertex;

#define BIN_DATA_BLOCK_EOF      0x00000000


CModelBIN::CModelBIN (const char* binFilename)
{
  top = new ssgBranch;
  top->setName (binFilename);

  rawtexture = NULL;

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

  // Read file signature
  unsigned long signature;
  pread (&signature, sizeof(unsigned long), 1, p);
  if (signature != 0x14) {
    gtfo ("CModelBIN : Invalid file signature (0x%08X) in %s", signature, binFilename);
  }

  // Read BIN header
  SBINHeader header;
  pread (&header, sizeof(SBINHeader), 1, p);

  // Read vertex table
  SBINVertex *v = new SBINVertex[header.nVertices];
  pread (v, sizeof(SBINVertex), header.nVertices, p);

  // Read data blocks until EOF block
  bool eof = false;
  while (!eof) {
    // Read block type
    unsigned long type;
    pread (&type, sizeof(unsigned long), 1, p);

    switch (type) {
    case BIN_DATA_BLOCK_EOF:
      // EOF block
      eof = true;
      break;

    default:
      pclose (p);
      delete v;
      gtfo ("CModelBIN : Unsupported data block 0x%08X in %s", type, binFilename);
    }
  }
/*
  // Create state information
  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 ) ;
  }

    // 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;
    }

    // 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);
    top->addKid (vtab);
*/
}

CModelBIN::~CModelBIN (void)
{
  if (rawtexture != NULL) delete rawtexture;
  delete top;
}

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

Documentation generated by