lwo.hpp

Go to the documentation of this file.

#ifndef LWO_H
#define LWO_H

/* Author: Jussi R�s�en */

#include <vector>
#include <string>
#include <math.h>
#include <assert.h>
#include <stdio.h>
#include "Vector2.hpp"
#include "Vector3.hpp"
#include "Vector4.hpp"

class Color
{
public:
  unsigned char r;
  unsigned char g;
  unsigned char b;
  unsigned char a;
  void set(const Vector3& v)
  {
    r=(unsigned char) (v.x*255.0f);
    g=(unsigned char) (v.y*255.0f);
    b=(unsigned char) (v.z*255.0f);
    a=255;
  }
};

class File
{
public:
  void* load(const char* fname)
  {
    FILE *fp = fopen(fname,"rb");
    if(fp == 0) return 0;
    fseek(fp,0,SEEK_END);
    int size = ftell(fp);
    fseek(fp,0,SEEK_SET);
    buf = new char[size];
    fread(buf,1,size,fp);
    fclose(fp);
    return buf;
  }
  void free(char *buf)
  {
    delete [] buf;
  }

private:
  char *buf;
};

#ifndef UCHAR
typedef unsigned char UCHAR;
typedef unsigned int UINT;
typedef unsigned short USHORT;
#endif

#ifndef CHAR
//typedef signed char CHAR;
typedef signed int INT;
#endif

#ifndef FLT_MAX
#define FLT_MAX HUGE_VAL
#endif

//normalize_0 on tavallinen normalisointi + jos vektorin pituus on 0, tulos on nollavektori
// operaattori | vektoreiden v�ill�on pistetulo ja * ristitulo

//=============================================================================
//=============================================================================

typedef Vector4 M_Vector4;
typedef Vector3 M_Vector3;
typedef Vector2 M_Vector2;

class LWOReader
{
public:

  struct Vertex
  {
    void      null()
    {
      m_position.clear();
      m_normal.clear();
      m_uv.clear();
      m_diffuse.clear();
    }
    void      add( const Vertex &v )
    {
      m_position += v.m_position;
      m_normal += v.m_normal;
      m_uv += v.m_uv;
      m_diffuse += v.m_diffuse;
    }
    void      mad( const Vertex &v, float c )
    {
      m_position += v.m_position * c;
      m_normal += v.m_normal * c;
      m_uv += v.m_uv * c;
      m_diffuse += v.m_diffuse * c;
    }
    void      normalize()
    {
      m_normal.normalize();
    }
    M_Vector3  m_position;
    M_Vector3  m_normal;
    int    m_triangleUsing; //30msb polyindex 2lsb edgeindex
    M_Vector2  m_uv;
    M_Vector4  m_diffuse;
  };

  struct Triangle
  {
    M_Vector3  m_normal;
    float   m_area;
    int    m_surface;
    int    m_v[3];
    char   m_dummy;
  };

  struct Edge
  {
    bool operator<( const Edge &e ) const { if( m_v[0] < e.m_v[0] ) return true; else if( m_v[0] > e.m_v[0] ) return false; else return (m_v[1] < e.m_v[1]) ? true : false; }
    int    m_v[2];
    int    m_t[2];
  };

  struct Surface
  {
    std::string  m_name;
    Color   m_color;
    int    m_polygons;
  };

  LWOReader( const char *fileName );
  ~LWOReader();

  Vertex    &getVertex( uint i )    { assert(i<m_vertices.size()); return m_vertices[i]; }
  Triangle   &getTriangle( uint i )   { assert(i<m_triangles.size()); return m_triangles[i]; }
  Edge    &getEdge( uint i )    { assert(i<m_edges.size()); return m_edges[i]; }
  Surface    &getSurface( uint i )   { assert(i<m_surfaces.size()); return m_surfaces[i]; }

  uint     getVertexCount() const   { return m_vertices.size(); }
  uint     getTriangleCount() const  { return m_triangles.size(); }
  uint     getEdgeCount() const   { return m_edges.size(); }
  uint     getSurfaceCount() const   { return m_surfaces.size(); }

  const M_Vector3  &getBoundingBoxMin() const  { return m_boundingBoxMin; }
  const M_Vector3  &getBoundingBoxMax() const  { return m_boundingBoxMax; }
  float    getBoundingRadius() const  { return m_boundingRadius; }

private:
  std::vector<Vertex>  m_vertices;
  std::vector<Triangle> m_triangles;
  std::vector<Edge>  m_edges;
  std::vector<Surface> m_surfaces;
  std::string    m_filename;

  M_Vector3    m_boundingBoxMin;
  M_Vector3    m_boundingBoxMax;
  float     m_boundingRadius;

  static UCHAR   *m_fileptr;
  static UCHAR   *m_nextchunkptr;
  static UCHAR   *m_nextsubchunkptr;
  static UCHAR   *m_fileend;
  static UCHAR   *m_readptr;

  UINT     readID4();
  int      readI1();
  int      readI2();
  int      readI4();
  UCHAR     readU1();
  USHORT     readU2();
  UINT     readU4();
  float     readF4();
  const char    *readS0();
  UINT     readVX();
  M_Vector3    readCOL12();
  M_Vector3    readVEC12();

  void     loadLW5( );
  void     loadLW6( );
};

//=============================================================================
//=============================================================================

#endif

---